xpflow 0.1b

data/lib/xpflow/utils.rb

@@ -0,0 +1,569 @@
+
+# encoding: UTF-8
+
+#
+#  Implements useful routines and some nasty/ugly/ingenious/beautiful tricks. 
+#
+
+require 'thread'
+
+class Class
+
+    def __build_constructor__(*fields)
+        attrs = []
+        supers = []
+        inits = Hash.new
+
+        if fields.first.is_a?(Array)
+            supers = fields.first
+            attrs = fields[1..-1]
+        else
+            attrs = fields
+        end
+
+        if attrs.last.is_a?(Hash)
+            inits = attrs.last
+            attrs.pop
+        end
+
+        s = "def initialize("
+        s += (supers + attrs).map { |x| x.to_s }.join(", ")
+        s += ")\n"
+        s += "super("
+        s += supers.map { |x| x.to_s }.join(", ")
+        s += ")\n"
+
+        attrs.each do |x|
+            s += "@#{x} = #{x}\n"
+        end
+
+        inits.each_pair do |k, v|
+            s += "@#{k} = #{v.inspect}\n"
+        end
+
+        s += "self.init if self.respond_to?(:init)\n"
+
+        s += "end\n"
+
+        return s
+    end
+
+    # Generates constructor on-the-fly from a specification.
+    # See 'test_tricks' in tests or classes derived from AbstractRun.
+
+    def constructor(*fields)
+        s1 = __build_constructor__(*fields)
+        class_eval(s1)
+    end
+
+    # Declares a list of objects that the object consists of.
+    # Used to recursively traverse the structure of the workflow.
+    # See classes derived from AbstractRun.
+
+    def children(*fields)
+        list = fields.map { |x| "@#{x}" }.join(', ')
+        s  = "def __children__\n"
+        s += "    return XPFlow::resolve_children([ #{list} ])\n"
+        s += "end\n"
+        h = fields.map { |x| ":#{x} => @#{x}" }.join(", ")
+        s += "def __children_hash__\n"
+        s += "    return { #{h} }\n"
+        s += "end\n"
+        class_eval(s)
+    end
+
+    # Declares additional variables declared in a run.
+    def declares(*fields)
+        hash = fields.map { |f| "@#{f} => self" }.join(", ")
+        s  = "def __declarations__\n"
+        s += "    return { #{hash} }\n"
+        s += "end\n"
+        class_eval(s)
+    end
+
+    def activities(*methods)
+        maps = {}
+        methods.each do |m|
+            if m.is_a?(Hash)
+                m.each_pair { |k, v| maps[k] = v }
+            elsif m.is_a?(Symbol)
+                maps[m] = m
+            else
+                raise
+            end
+        end
+        s  = "def __activities__\n"
+        s += "    return #{maps.inspect.gsub('=>',' => ')}\n"
+        s += "end\n"
+        class_eval(s)
+    end
+
+end
+
+class Object
+
+    attr_writer :__repr__
+    
+    def __repr__
+        return instance_exec(&@__repr__) if @__repr__.is_a?(Proc)
+        return @__repr__ unless @__repr__.nil?
+        return to_s
+    end
+
+    def instance_variables_compat
+        # Ruby 1.8 returns strings, but version 1.9 returns symbols
+        return instance_variables.map { |x| x.to_sym }.sort
+    end
+
+    def inject_method(name, &block)
+        if $ruby19
+            self.define_singleton_method(name, &block)
+        else
+            (class << self; self; end).send(:define_method, name, &block)
+        end
+    end
+
+end
+
+class String
+
+    def extract(exp)
+        return exp.match(self).captures.first
+    end
+
+end
+
+class Array
+
+    def tail
+        self[1..-1]
+    end
+
+    def same(x)
+        return ((x - self == []) && (self - x == []))
+    end
+
+    def split_into(n)
+        # splits into n arrays of the same size
+        this = self
+        raise "Impossible to split #{this.length} into #{n} groups" \
+            if this.length % n != 0
+        chunk = this.length / n
+        return n.times.map { |i| this.slice(i*chunk, chunk)  }
+    end
+
+end
+
+class Hash
+
+    alias :old_select :select
+
+    def select(*args, &block)
+        return Hash[old_select(*args, &block)]
+    end if $ruby18
+end
+
+class IO
+
+    def self.write(name, content)
+        File.open(name, 'wb') do |f|
+            f.write(content)
+        end
+    end
+
+end
+
+
+module XPFlow
+
+    # parse comments next to the invocation of the 
+    # function higher in the stack
+
+    def self.realpath(filename)
+        return Pathname.new(filename).realpath.to_s
+    end
+
+    def self.stack_array
+        stack = Kernel.caller()
+        stack = stack.map do |frame|
+            m = frame.match(/^(.+):(\d+)$/)
+            m = frame.match(/^(.+):(\d+):in .+$/) if m.nil?
+            raise "Could not parse stack '#{frame}'" if m.nil?
+            filename, lineno = m.captures
+
+            filename = realpath(filename)
+            [ filename, lineno.to_i ]
+        end
+        return stack
+    end
+
+    def self.parse_comment_opts(source)
+        source = realpath(source)
+        stack = stack_array()
+        while stack.first.first != source
+            # remove all possible non-dsl files on the stack
+            stack.shift
+        end
+        while stack.first.first == source
+            # get all possible dsl files on the stack
+            stack.shift
+        end
+        # now the first frame *SHOULD* be the one that entered DSL
+        filename, line = stack.first
+        line = IO.read(filename).lines.to_a[line - 1]
+        if !line.include?('#!')
+            return { }
+        else
+            comment = line.split('#!').last.strip
+            opts = { }
+            comment.split(",").each do |pair|
+                pair = pair.strip
+                if !pair.include?('=')
+                    opts[pair.to_sym] = true
+                else
+                    k, v = pair.split('=', 2).map(&:strip)
+                    opts[k.to_sym] = eval(v)
+                end
+            end
+            return opts
+        end
+    end
+
+    # Removes nodes that are not important from
+    # graphing point of view
+
+    def self.block_info(block)
+        # gives a string repr. of arguments to this block
+        s = []
+        arity = block.arity
+        if !block.respond_to?(:parameters)  # Ruby 1.8
+            is_neg = (arity < 0)
+            arity = (-arity - 1) if is_neg
+            args = arity.times.map { |i| "arg#{i+1}" }
+            args.push('[args...]')
+            return args.join(', ')
+        end
+        for t, name in to_lambda(block).parameters
+            name = "[#{name}]" if t == :opt
+            name = "[#{name}...]" if t == :rest
+            s.push(name)
+        end
+        return s.join(', ')
+    end
+
+    def self.to_lambda(block)
+        # converts a block to lambda (see http://stackoverflow.com/questions/2946603)
+        obj = Object.new
+        obj.define_singleton_method(:_, &block)
+        return obj.method(:_).to_proc
+    end
+
+
+    # Used by 'children' above.
+    # Interprets dependant objects of the object
+    # and flattens them to one large list.
+
+    def self.resolve_children(obj)
+        raise unless obj.is_a?(Array)
+        res = []
+        for x in obj
+            if x.is_a?(Array)
+                res += resolve_children(x)
+            elsif x.is_a?(Hash)
+                res += resolve_children(x.values)
+            else
+                res.push(x)
+            end
+        end
+        return res
+    end
+
+    # Exception thrown if the execution of the workflow failed.
+    # Possibly encapsulates many inner exceptions.
+
+    class RunError < StandardError
+
+        attr_reader :run
+        alias :old_to_s :to_s
+
+        def initialize(run, children, msg = nil)
+            super(msg)
+            children = [ children ] unless children.is_a?(Array)
+            @run = run
+            @children = children
+        end
+
+        def self.trace(x)
+            if x.is_a?(RunError)
+                return x.stacktrace
+            else
+                frame = x.backtrace.first
+                file, line = /^(.+):(\d+)/.match(frame).captures
+                return [ [x.to_s, [ Frame.new(file, line.to_i) ]] ]
+            end
+        end
+
+        def stacktrace
+            elements = @children.map { |c| RunError.trace(c) }.reduce([], :+)
+            elements.each do |reason, stack|
+                stack.push(@run.meta)
+            end
+            return elements
+        end
+
+        # Gives one line summary of the error.
+
+        def summary
+            s = stacktrace()
+            if s.length == 1
+                reason, stack = s.first
+                frame = stack.first
+                return "'#{reason}' (#{frame.location})"
+            else
+                return "#{s.length} errors"
+            end
+        end
+
+        def to_s
+            summary
+        end
+
+    end
+
+    # A special version of RunError exception
+    # that simply throws an error message.
+
+    class RunMsgError < RunError
+
+        def initialize(run, msg)
+            super(run, nil, msg)
+        end
+
+        def stacktrace
+            return [ [self.to_s, [ @run.meta ] ] ]
+        end
+
+        def to_s
+            return old_to_s
+        end
+
+    end
+
+    # Measures execution time (use 'Timer.measure')
+    # and returns useful information.
+    # For example:
+    # t = Timer.measure do
+    #    sleep 1
+    # end
+    # puts t.with_ms
+
+    class Timer
+
+        def self.measure
+            start = Time.now
+            x = yield
+            done = Time.now
+            return Timer.new(done - start, x)
+        end
+
+        def initialize(t, v)
+            @t = t
+            @v = v
+        end
+
+        def value
+            return @v
+        end
+
+        def to_s(digits = nil)
+            return @t.to_s if digits.nil?
+            return "%.#{digits}f" % @t
+        end
+
+        def with_ms
+            return to_s(3)
+        end
+
+        def secs
+            return @t
+        end
+    end
+
+    class AbstractDumper
+
+        def digest(meta)
+            # convert a meta-hash to deterministic string
+            fingerprint = meta.each.map.to_a.sort
+            return Digest::SHA256.hexdigest(fingerprint.inspect)
+        end
+
+        def dump(obj, opts = {})
+            obj = obj.clone
+            validity = Timespan.to_secs(opts.fetch(:valid, Infinity))
+            obj['valid'] = Time.now.to_f + validity
+            obj['time_string'] = Time.now.to_s
+            obj['time_float'] = Time.now.to_f
+            set(digest(obj['meta']), obj.to_yaml)
+        end
+
+        def load(meta)
+            s = get(digest(meta))
+            return nil if s.nil?
+            obj = YAML::load(s)
+            return nil if obj['meta'] != meta  # collision
+            return nil if Time.now.to_f > obj['valid']  # expired
+            return obj
+        end
+
+        def set(key, value)
+            raise 'Not implemented'
+        end
+
+        def get(key)
+            raise 'Not implemented'
+        end
+
+    end
+
+    class FileDumper < AbstractDumper
+
+        @@prefix = ".xpflow-cp-"
+
+        def filename(key)
+            return "#{@@prefix}#{key}"
+        end
+
+        def set(key, value)
+            File.open(filename(key), 'w') do |f|
+                f.write(value)
+            end
+        end
+
+        def get(key)
+            name = filename(key)
+            return nil unless File.exists?(name)
+            File.open(name) do |f| 
+                f.read
+            end
+        end
+
+        def list
+            # lists checkpoints
+            # TODO: relegate to AbstractDumper somehow
+            files = Dir.glob("./#{@@prefix}*")
+            h = Hash.new { |h, k| h[k] = [] }
+            files.each do |f|
+                contents = IO.read(f)
+                cp = YAML.load(contents)
+                name = cp["meta"][:name]
+                h[name].push(cp)
+            end
+
+            h2 = { }
+
+            h.each_pair do |name, cps|
+                begin
+                    h2[name] = cps.sort { |x, y| x['time_float'] <=> y['time_float'] }
+                rescue
+                    # if cp style changed
+                end
+            end
+
+            return h2
+        end
+
+    end
+
+    class MemoryDumper < AbstractDumper
+
+        def initialize
+            super
+            @lock = Mutex.new
+            @store = {}
+        end
+
+        def get(key)
+            @lock.synchronize do
+                @store[key]
+            end
+        end
+
+        def set(key, value)
+            @lock.synchronize do
+                @store[key] = value
+            end
+        end
+
+    end
+
+
+    class Cache
+
+        # TODO: avoid cache stampede
+
+        def initialize
+            @lock = Mutex.new
+            @store = {}
+        end
+
+        def get(label)
+            @lock.synchronize do
+                @store[label]
+            end
+        end
+
+        def set(label, value)
+            @lock.synchronize do
+                @store[label] = value
+            end
+        end
+
+        def fetch(label)
+            x = get(label)
+            return x unless x.nil?
+            v = yield
+            set(label, v)
+            return v
+        end
+
+    end
+
+    class Timespan
+        # parses various timespan formats
+
+        def self.to_secs(s)
+            return s.to_f if s.is_a?(Numeric)
+            return Infinity if [ 'always', 'forever', 'infinitely' ].include?(s.to_s)
+            parts = s.to_s.split(':').map { |x| Integer(x) rescue nil }
+            if parts.all? && [ 2, 3 ].include?(parts.length)
+                secs = parts.zip([ 3600, 60, 1 ]).map { |x, y| x * y }.reduce(:+)
+                return secs
+            end
+            m = /^(\d+|\d+\.\d*)\s*(\w*)?$/.match(s)
+            num, unit = m.captures
+            mul = case unit
+                when '' then 1
+                when 's' then 1
+                when 'm' then 60
+                when 'h' then 60 * 60
+                when 'd' then 24 * 60 * 60
+                else nil
+            end
+            raise "Unknown timespan unit: '#{unit}' in #{s}" if mul.nil?
+            return num.to_f * mul
+        end
+
+        def self.to_time(s)
+            secs = to_secs(s).to_i
+            minutes = secs / 60; secs %= 60
+            hours = minutes / 60; minutes %= 60
+            minutes += 1 if secs > 0
+            return '%.02d:%.02d' % [ hours, minutes ]
+        end
+
+    end
+
+    Infinity = 1.0/0.0
+
+end
+