class MiGA::Result

The result from a task run. It can be project-wide or dataset-specific.

Attributes

data[R]

Hash with the result metadata

Public Class Methods

RESULT_DIRS() click to toggle source

# File lib/miga/result/base.rb, line 3
def RESULT_DIRS
  @@RESULT_DIRS ||=
    MiGA::Dataset.RESULT_DIRS.merge(MiGA::Project.RESULT_DIRS)
end

create(path, force = false) { || ... } click to toggle source

Check if path describes a result and otherwise create it using the passed block. If force, ignore existing JSON in path if any, but it can rescue the versions field from the old one if it exists and the new one doesn't contain such field.

# File lib/miga/result.rb, line 39
def create(path, force = false)
  # Deal with old results first
  r_old = load(path)
  return r_old if r_old && !force

  # Create the new result using the block passed
  FileUtils.rm(path) if r_old
  yield

  # Load and return
  load(path).tap do |r_new|
    # Rescue versions and start (if any and if necessary)
    if r_old
      %[versions started].each { |i| r_new[i] ||= r_old[i] }
      r_new[:versions] = (r_old[:versions] || {}).merge(r_new[:versions])
    end
  end
end

exist?(path) click to toggle source

Check if the result described by the JSON in path already exists

# File lib/miga/result.rb, line 20
def exist?(path)
  File.exist? path
end

load(path) click to toggle source

Load the result described by the JSON in path. Returns MiGA::Result if it already exists, nil otherwise.

# File lib/miga/result.rb, line 27
def load(path)
  return nil unless MiGA::Result.exist? path

  MiGA::Result.new(path)
end

new(path) click to toggle source

Load or create the MiGA::Result described by the JSON file path

# File lib/miga/result.rb, line 67
def initialize(path)
  @path = File.absolute_path(path)
  MiGA::Result.exist?(@path) ? load : create
end

Public Instance Methods

[](k) click to toggle source

Entry with symbol k

# File lib/miga/result.rb, line 137
def [](k)
  data[k.to_sym]
end

[]=(k, v) click to toggle source

Adds value v to entry with symbol k

# File lib/miga/result.rb, line 143
def []=(k, v)
  data[k.to_sym] = v
end

add_file(k, file) click to toggle source

Register file (path relative to dir) with the symbol k. If the file doesn't exist but the .gz extension does, the gzipped file is registered instead. If neither exists, nothing is registered.

# File lib/miga/result.rb, line 151
def add_file(k, file)
  k = k.to_sym
  @data[:files] ||= {}
  @data[:files][k] = file if File.exist? File.expand_path(file, dir)
  @data[:files][k] = "#{file}.gz" if
    File.exist? File.expand_path("#{file}.gz", dir)
end

add_files(files) click to toggle source

#add_file for each key-value pair in the files Hash

# File lib/miga/result.rb, line 161
def add_files(files)
  files.each { |k, v| add_file(k, v) }
end

clean!() click to toggle source

# File lib/miga/result.rb, line 80
def clean!
  self[:clean] = true
  self
end

clean?() click to toggle source

Is the result clean? Returns Boolean

# File lib/miga/result.rb, line 74
def clean?
  !!self[:clean]
end

create() click to toggle source

Initialize and save empty result

# File lib/miga/result.rb, line 167
def create
  @data = {
    created: Time.now.to_s,
    stats: {}, files: {},
    versions: { 'MiGA' => MiGA::VERSION.join('.') }
  }
  save
end

dir(relative = false) click to toggle source

Directory containing the result; by default an absolute path, if relative is true returns the path relative to the parent project

# File lib/miga/result.rb, line 119
def dir(relative = false)
  relative ? relative_dir : File.dirname(path)
end

each_file(&blk) click to toggle source

Iterate blk for each registered file. Depending on the number of arguments of blk (arity), it's called as:

blk
blk[file_sym, file_rel]
blk[file_sym, file_rel, file_abs]

Note that multiple files may have the same symbol (file_sym), since arrays of files are supported.

# File lib/miga/result.rb, line 219
def each_file(&blk)
  return to_enum(:each_file) unless block_given?

  @data[:files] ||= {}
  self[:files].each do |k, files|
    files = [files] unless files.is_a? Array
    files.each do |file|
      case blk.arity
      when 1 then blk.call(file)
      when 2 then blk.call(k, file)
      when 3 then blk.call(k, file, File.expand_path(file, dir))
      else
        raise "Wrong number of arguments: #{blk.arity} for 1..3"
      end
    end
  end
end

file_path(k, relative = false) click to toggle source

Absolute path to the file(s) defined by symbol k, or relative path if relative is true

# File lib/miga/result.rb, line 126
def file_path(k, relative = false)
  k = k.to_sym
  f = self[:files].nil? ? nil : self[:files][k]
  return nil if f.nil?
  return File.join(dir(relative), f) unless f.is_a? Array

  f.map { |fi| File.join(dir(relative), fi) }
end

load() click to toggle source

Load (or reload) result data in the JSON file path

# File lib/miga/result.rb, line 191
def load
  @data = MiGA::Json.parse(path)
  @data[:files] ||= {}
end

path(which = :json) click to toggle source

Path to the standard files of the result. which must be one of:

:json (default) : JSON file describing the result.
:start : File with the date when the processing started.
:done : File with the date when the processing ended.

# File lib/miga/result.rb, line 105
def path(which = :json)
  case which.to_sym
  when :json
    @path
  when :start
    @path.sub(/\.json$/, '.start')
  when :done
    @path.sub(/\.json$/, '.done')
  end
end

recalculate!(reason = nil) click to toggle source

Mark the result to be recalculated, returns self

# File lib/miga/result.rb, line 93
def recalculate!(reason = nil)
  self[:recalculate] = true
  self[:recalculate_why] = reason
  self[:recalculate_when] = Time.now.to_s
  self
end

recalculate?() click to toggle source

Is the result marked to be recalculated? Returns Boolean

# File lib/miga/result.rb, line 87
def recalculate?
  !!self[:recalculate]
end

remove!() click to toggle source

Remove result, including all associated files

# File lib/miga/result.rb, line 198
def remove!
  each_file { |file| FileUtils.rm_rf(File.join(dir, file)) }
  unlink
end

save() click to toggle source

Save the result persistently (in the JSON file path)

# File lib/miga/result.rb, line 178
def save
  @data[:updated] = Time.now.to_s
  s = path(:start)
  if File.exist? s
    @data[:started] = File.read(s).chomp
    File.unlink s
  end
  MiGA::Json.generate(data, path)
  load
end

unlink() click to toggle source

Unlink result by removing the .done and .start timestamps and the .json descriptor, but don't remove any other associated files

# File lib/miga/result.rb, line 205
def unlink
  %[start done json].each do |i|
    f = path(i) and File.exist?(f) and File.unlink(f)
  end
end