xpflow 0.1b

data/lib/xpflow/dsl.rb

@@ -0,0 +1,816 @@
+# encoding: UTF-8
+
+#
+# DSL implementation.
+#
+
+module XPFlow
+
+    class LibraryLink
+
+        constructor :process, :key, :parts
+
+        def method_missing(method, *args, &block)
+            new_parts = @parts + [ method.to_s ]
+            full_name = new_parts.join(".")
+            obj = @process.library.resolve_name(full_name)
+            if obj.nil?
+                raise "No such object '#{full_name}'"
+            end
+            if obj.is_a?(Library)
+                raise NoMethodError, "Library referencing requires no args" if args.length > 0
+            else
+                # activity/process
+                args = XPValue.flatten(args)
+                full_name = XPValue.flatten(full_name)
+                run = RunDSL.new(@process, @key, full_name, args, {}, block)
+                return @process.push(run)
+            end
+            return LibraryLink.new(@process, @key, new_parts)
+        end
+    end
+
+    class Key
+
+        def initialize(array)
+            @array = array
+        end
+
+    end
+
+    class DSL
+
+        def initialize(process, key)
+            @process = process
+            if key.nil?
+                @_key = []
+            elsif key.is_a?(Array)
+                @_key = key
+            elsif key.is_a?(String)
+                @_key = from_string(key)
+            else
+                raise "Unsupported key type"
+            end
+            @current_key = -1
+            @keys = []
+        end
+
+        def from_string(s)  # string => Array
+            raise "error" unless s.start_with?("/")
+            arr = s.split("/"); arr.shift
+            return arr
+        end
+
+        def to_string(arr)
+            return "/" + arr.join("/")
+        end
+
+        def key
+            return to_string(@_key)
+        end
+
+        def new_key
+            @current_key += 1
+            key = @_key + [ @current_key ]
+            @keys.push(key)
+            return to_string(key)
+        end
+
+        def parse(*args, &block)
+            begin
+                $current_dsl.push(self)
+                self.instance_exec(*args, &block)
+            ensure
+                $current_dsl.pop
+            end
+            return self
+        end
+
+        def repr
+            {
+                :key => key()
+            }
+        end
+
+    end
+
+    $current_dsl = []
+
+    class DSLVariable
+
+        include Operations
+
+        attr_reader :key
+        constructor :key
+
+        def to_s
+            "Var[-@@@@-#{key}-@@@@-]"
+        end
+
+        def self.replace(s, scope)
+            out = s.gsub(/Var\[-@@@@-([\/\d]+)-@@@@-\]/) do |m|
+                key = $1
+                scope.get(key).to_s
+            end
+            return out
+        end
+
+        def to_ary
+            return 10.times.map do |i|
+                u = XPValue.flatten(self)
+                u.index(XPConst.new(i))
+            end
+        end
+
+        def as_s
+            return method_missing(:to_s)
+        end
+
+        def as_i
+            return method_missing(:to_i)
+        end
+
+        def method_missing(method, *args)
+            dsl = $current_dsl.last
+            raise "Fatal error" if dsl.nil?
+            raise "Arguments are unsupported" if args.length > 0
+            return dsl.get_of(self, method)
+        end
+
+    end
+
+    class RunDSL < DSL
+
+        constructor [ :process, :key ], :name, :args, :opts, :block
+
+        def repr
+            super.merge({
+                :type => :run,
+                :name => @name,
+                :args => @args,
+                :opts => @opts
+            })
+        end
+
+        def collect_meta(xxxx)
+            {
+
+            }
+        end
+
+        def as_run
+            return ActivityRun.new(key, @name, @args, @opts, @block)
+        end
+
+    end
+
+    class ReturnLoopDSL < DSL 
+
+        constructor [ :process, :key ], :flag, :cond, :value
+
+        def as_run
+            return ReturnLoopRun.new(key, @flag, @cond, @value)
+        end
+    end
+
+    class CheckpointDSL < DSL
+
+        constructor [ :process, :key ], :name, :opts, :parent
+
+        def as_run
+            return CheckpointRun.new(new_key, @name, @opts, @parent)
+        end
+    end
+
+    class OtherwiseDSL < DSL
+
+        constructor [ :process, :key ]
+
+    end
+
+    class ListDSL < DSL
+
+        constructor [ :process, :key ], :list
+
+        def __list__
+            return @list
+        end
+
+        def __as_run__
+            return @list.map(&:as_run)
+        end
+
+        def push(x, inc = 0)
+            @list.push(x)
+            return DSLVariable.new(x.key)
+        end
+
+        def parse_and_push(dsl, *args, &block)
+            return push(dsl.parse(*args, &block))
+        end
+
+        def as_run
+            runs = __as_run__
+            return SequenceRun.new(key, runs)
+        end
+
+        def __workflow__(*args)
+            block, _ = @process.current_workflow
+            seq = SequenceDSL.new(@process, new_key)
+            return parse_and_push(seq, *args, &block)
+        end
+
+        ### DSL PART ###
+
+        def parallel(opts = {}, &block)
+            retries = opts[:retry]
+            if retries.nil?
+                dsl = ParallelDSL.new(@process, new_key)
+                return parse_and_push(dsl, &block)
+            else
+                try :retry => retries do
+                    parallel(&block)
+                end
+            end
+        end
+
+        def any(&block)
+            one = XPValue.flatten(-1)
+            dsl = ManyDSL.new(@process, new_key, one)
+            return parse_and_push(dsl, &block)
+        end
+
+        def many(arg, &block)
+            n = XPValue.flatten(arg)
+            dsl = ManyDSL.new(@process, new_key, n)
+            return parse_and_push(dsl, &block)
+        end
+
+        def formany(arg, array, &block)
+            n = XPValue.flatten(arg)
+            array = XPValue.flatten(array)
+            dsl = ForManyDSL.new(@process, new_key, n, array)
+            return parse_and_push(dsl, &block)
+        end
+
+        def sequence(&block)
+            dsl = SequenceDSL.new(@process, new_key)
+            return parse_and_push(dsl, &block)
+        end
+
+        def seq(&block)
+            return sequence(&block)
+        end
+
+        def seqtry(&block)
+            dsl = SeqtryDSL.new(@process, new_key)
+            return parse_and_push(dsl, &block)
+        end
+
+        def foreach(array, opts = {}, &block)
+            array = XPValue.flatten(array)
+            opts = XPValue.flatten(opts)
+            dsl = ForEachDSL.new(@process, new_key, array, opts)
+            return parse_and_push(dsl, &block)
+        end
+
+        def forall(array, opts = {}, &block)
+            array = XPValue.flatten(array)
+            opts = XPValue.flatten(opts)
+            dsl = ForAllDSL.new(@process, new_key, array, opts)
+            return parse_and_push(dsl, &block)
+        end
+
+        def times(loops, &block)
+            loops = XPValue.flatten(loops)
+            dsl = TimesDSL.new(@process, new_key, loops)
+            return parse_and_push(dsl, &block)
+        end
+
+        def forany(array, &block)
+            one = XPValue.flatten(-1)
+            array = XPValue.flatten(array)
+            dsl = ForManyDSL.new(@process, new_key, one, array)
+            return parse_and_push(dsl, &block)
+        end
+
+        def on(condition, &block)
+            condition = XPValue.flatten(condition)
+            dsl = IfDSL.new(@process, new_key, condition)
+            return parse_and_push(dsl, &block)
+        end
+
+        def switch(*args, &block)
+            if args.length == 0
+                s = SwitchDSL.new(@process, new_key)
+                parse_and_push(s, &block)
+            elsif args.length == 1
+                s = BoundSwitchDSL.new(@process, new_key, XPValue.flatten(args.first))
+                parse_and_push(s, &block)
+            else
+                raise
+            end
+        end
+
+        def multi(&block)
+            dsl = MultiDSL.new(@process, new_key)
+            return parse_and_push(dsl, &block)
+        end
+
+        def try(opts = {}, &block)
+            opts = XPValue.flatten(opts)
+            dsl = TryDSL.new(@process, new_key, opts)
+            return parse_and_push(dsl, &block)
+        end
+
+        def result(path, opts = {}, &block)
+            # TODO: reimplement with macros!
+            opts = XPValue.flatten(opts)
+            path = XPValue.flatten(path)
+            dsl = ResultDSL.new(@process, new_key, path, opts)
+            return parse_and_push(dsl, &block)
+        end
+
+        def loop(opts = {}, &block)
+            opts = XPValue.flatten(opts)
+            dsl = LoopDSL.new(@process, new_key, opts)
+            return parse_and_push(dsl, &block)
+        end
+
+        def cache(opts = {}, &block)
+            dsl = CacheDSL.new(@process, new_key, opts)
+            return parse_and_push(dsl, &block)
+        end
+
+
+        def info(opts = {}, &block)
+            opts = XPValue.flatten(opts)
+            dsl = InfoDSL.new(@process, opts)
+            return parse_and_push(dsl, &block)
+        end
+
+        def run(arg, *args, &block)
+            # Kernel.puts "run: #{args} #{args.inspect}"
+            opts = XPFlow::parse_comment_opts(__FILE__)
+            name = nil
+            if arg.is_a?(Hash)
+                opts = opts.merge(arg)
+                name, args = args.first, args.tail
+            else
+                name = arg
+            end
+            raise 'No name given' if name.nil?
+            args = XPValue.flatten(args)
+            name = XPValue.flatten(name)
+            return push(RunDSL.new(@process, new_key, name, args, opts, block))
+        end
+
+        def rerun(name, *args, &block)
+            # TODO
+            try :retry => 100000 do   # as many times as needed
+                run(name, *args, &block)
+            end
+        end
+
+        def sleep(t)
+            # this has to be present in DSL for some rather obscure reasons :)
+            return method_missing(:sleep, t)
+        end
+
+        def puts(*args)
+            # overloads the standard 'puts'
+            return method_missing(:log, *args)
+        end
+
+        def fail(*args)
+            # same here
+            return method_missing(:fail, *args)
+        end
+
+        def system(cmd)
+            # same here
+            return method_missing(:system, cmd)
+        end
+
+        def send(o, method, *args)
+            # same reason as sleep
+            return method_missing(:send, o, method, *args)
+        end
+
+        def method_missing(method, *args, &block)
+            # this is rather tricky:
+            #   1. DSL has predefined commands.
+            #   2. When no command matches we try to find "injected" activity, or activity
+            #      the was injected into the DSL. That way we can move many DSL commands to activities.
+            #   3. When injected activities do not match, we try to match with a namespace. If there
+            #      is a library with such a name we return a special variable. The only use for that
+            #      is to be able to run activities like that: run g5k.reserve_nodes
+            #   4. If nothing matches, we raise an error.
+
+            # pp @process.library.traversal_graph
+
+            name = method.to_s
+            activity = @process.library.get_activity_or_nil(name)
+
+            if activity.is_a?(MacroDSL)
+                m = activity
+                seq = nil
+                raise "Macro must be provided with a workflow" if block.nil?
+                @process.with_workflow(block, args) do
+                    seq = SequenceDSL.new(@process, new_key)
+                    seq.parse(*args, &m.block)
+                    push(seq)
+                end
+                return seq
+            end
+
+            if activity.nil? == false
+                args = XPValue.flatten(args)
+                name = XPValue.flatten(name)
+                opts = XPFlow::parse_comment_opts(__FILE__)
+                run = RunDSL.new(@process, new_key, name, args, opts, block)
+                return push(run)
+            end
+
+            library = @process.library.get_library_or_nil(name)
+
+            if library.nil? == false
+                raise NoMethodError, "Library referencing requires no args" if args.length > 0
+                return LibraryLink.new(@process, new_key, [ method.to_s ])
+            end
+
+            if name.end_with?('_of') and [ 1, 2 ].include?(args.length)
+                name = name.chomp('_of')
+                return self.get_of(args.first, name.to_sym, args[1])
+            end
+
+            raise NoMethodError, "Unknown or malformed DSL command or no such activity (:#{method})"
+        end
+
+        def _visit(*args)
+            pp caller
+            raise "Somebody did something stupid (see #{self.class})."
+        end
+
+        def experiment_scope(name = nil, &block)
+            # creates a new experiment scope
+            dsl = ExperimentDSL.new(@process, name)
+            return parse_and_push(dsl, &block)
+        end
+
+        ### END OF DSL ###
+
+    end
+
+    class SequenceDSL < ListDSL
+
+        def initialize(process, key)
+            super(process, key, [])
+        end
+
+        def self.repr(o)
+            return {
+                :key => o.key,
+                :type => :seq,
+                :body => o.__list__.map(&:repr)
+            }
+        end
+
+        def repr
+            return SequenceDSL.repr(self)
+        end
+
+    end
+
+    class ProcessDSL < SequenceDSL
+
+        attr_reader :args
+        attr_reader :name
+        attr_reader :library
+
+        def initialize(name, library, &block)
+            super(self, [])
+            @name = name
+            @library = library
+            @workflows = []  # a stack of current workflows used in macros
+            if block.nil?
+                raise "Block is nil?"
+            end
+            count = block.arity
+            if count >= 0
+                @args = count.times.map { |i| DSLVariable.new(new_key()) }
+            else
+                @args = 10.times.map { |i| DSLVariable.new(new_key()) }
+            end
+            self.parse(*@args, &block)
+        end
+
+        def checkpoint(*args)
+            name = nil
+            opts = {}
+            opts = args.pop if args.last.is_a?(Hash)
+            raise 'Wrong arguments' if args.length > 1
+            name = args.first if args.length == 1
+            push(CheckpointDSL.new(@process, new_key, name, opts, self))
+        end
+
+        def get_injection(name)
+            return @library.get_injection(name)
+        end
+
+        def as_process
+            keys = @args.map(&:key)
+            seq = self.as_run
+            return ProcessActivity.new(@name, keys, seq)
+        end
+
+        def repr
+            return {
+                :type => :process,
+                :name => @name,
+                :body => SequenceDSL.repr(self)
+            }
+        end
+
+        def with_workflow(m, args)
+            begin
+                @workflows.push([ m, args ])
+                yield
+            ensure
+                @workflows.pop
+            end
+        end
+
+        def current_workflow
+            raise "No current workflow" if @workflows.length == 0
+            return @workflows.last
+        end
+
+    end
+
+
+    class InnerDSL < SequenceDSL
+
+        alias :sequence_run :as_run
+
+    end
+
+    class WithParamsDSL < InnerDSL
+
+        def parse(&block)
+            args = @args.map { |x| DSLVariable.new(x) }
+            return super(*args, &block)
+        end
+
+        def repr
+            super.merge({
+                :args => @args
+            })
+        end
+
+    end
+
+
+    class SeqtryDSL < InnerDSL
+
+        constructor [ :process, :key ]
+
+        def as_run
+            return SeqtryRun.new(key, sequence_run.body)
+        end
+
+    end
+
+    class ExperimentDSL < InnerDSL
+
+        constructor [ :process ], :name
+
+        def as_run
+            return ExperimentRun.new(@process.get_key, @name, sequence_run)
+        end
+
+    end
+
+    class ForEachDSL < WithParamsDSL
+
+        constructor [ :process, :key ], :array, :opts
+
+        def init
+            @args = [ new_key() ] # iterator
+        end
+
+        def as_run
+            return ForEachRun.new(key, @array, @args.first, @opts, sequence_run)
+        end
+
+        def repr
+            super.merge({
+                :type => :foreach,
+                :array => @array
+            })
+        end
+
+    end
+
+    class ParallelDSL < InnerDSL
+
+        def as_run
+            return ParallelRun.new(key, __as_run__)
+        end
+    end
+
+    class TimesDSL < WithParamsDSL
+
+        constructor [ :process, :key ], :loops
+
+        def init
+            @args = [ new_key() ]  # iterator
+        end
+
+        def as_run
+            return TimesRun.new(key, @loops, @args.first, sequence_run)
+        end
+    end
+
+    class ForAllDSL < WithParamsDSL
+
+        constructor [ :process, :key ], :array, :opts
+
+        def init
+            @args = [ new_key() ] # iterator
+        end
+
+        def as_run
+            return ForAllRun.new(key, @array, @args.first, @opts, sequence_run)
+        end
+    end
+
+    class ForManyDSL < WithParamsDSL
+
+        constructor [ :process, :key ], :number, :array
+
+        def init
+            @args = [ new_key() ] # iterator
+        end
+
+        def as_run
+            return ForManyRun.new(key, @number, @array, @args.first, sequence_run)
+        end
+
+    end
+
+    class ManyDSL < InnerDSL
+
+        constructor [ :process, :key ], :number
+
+        def as_run
+            return ManyRun.new(key, @number, __as_run__)
+        end
+
+    end
+
+    class TryDSL < InnerDSL
+
+        constructor [ :process, :key ], :opts
+
+        def as_run
+            return TryRun.new(key, @opts, sequence_run)
+        end
+
+    end
+
+    class ResultDSL < InnerDSL
+
+        constructor [ :process, :key ], :path, :opts
+
+        def as_run
+            return ResultRun.new(key, @path, @opts, sequence_run)
+        end
+
+    end
+
+    class CacheDSL < InnerDSL
+
+        constructor [ :process, :key ], :opts
+
+        def as_run
+            return CacheRun.new(key, @opts, sequence_run)
+        end
+
+    end
+
+    class InfoDSL < InnerDSL
+
+        constructor [ :process, :key ], :opts
+
+        def as_run
+            return InfoRun.new(key, @opts, sequence_run)
+        end
+    end
+
+
+    class IfDSL < SequenceDSL
+
+        constructor [ :process, :key ], :cond
+
+        def otherwise
+            push(OtherwiseDSL.new(@process, new_key))
+        end
+
+        def as_run
+            i = nil
+            @list.length.times do |j|
+                i = j if (@list[j].is_a?(OtherwiseDSL))
+            end
+            on_true = []
+            on_false = []
+            if i.nil?
+                on_true = @list
+            else
+                on_true = @list[0..(i-1)]
+                on_false = @list[(i+1)..-1]
+                raise if (on_true.length + on_false.length + 1) != @list.length
+            end
+            on_true = ListDSL.new(@process, new_key, on_true).as_run
+            on_false = ListDSL.new(@process, new_key, on_false).as_run
+            return IfRun.new(key, @cond, on_true, on_false)
+        end
+
+    end
+
+    class LoopDSL < WithParamsDSL
+
+        constructor [ :process, :key ], :opts
+
+        def init
+            @flag = new_key()
+            @iter = new_key()
+            @array = new_key()
+            @args = [ @iter, @array ]
+        end
+
+        def return_on(cond, value = nil)
+            cond = XPValue.flatten(cond)
+            value = XPValue.flatten(value)
+            push(ReturnLoopDSL.new(@process, key, @flag, cond, value))
+        end
+
+        def as_run
+            return LoopRun.new(key, @flag, @iter, @array, __as_run__, @opts)
+        end
+    end
+
+    class SwitchDSL < DSL
+
+        constructor [ :process, :key ], :cases => [], :default => nil
+
+        def on(cond, &block)
+            body = SequenceDSL.new(@process, new_key).parse(&block)
+            @cases.push([ XPValue.flatten(cond), body ])
+        end
+
+        def default(&block)
+            @default = SequenceDSL.new(@process, new_key).parse(&block)
+        end
+
+        def _cases_as_runs
+            return @cases.map { |c, b| [ c, b.as_run ] }
+        end
+
+        def _default_as_run
+            return nil if @default.nil?
+            return @default.as_run
+        end
+
+        def as_run
+            return SwitchRun.new(key, _cases_as_runs, _default_as_run)
+        end
+    end
+
+    class MultiDSL < SwitchDSL
+
+        def as_run
+            return MultiRun.new(key, _cases_as_runs, _default_as_run)
+        end
+    end
+
+    class BoundSwitchDSL < SwitchDSL
+
+        constructor [ :process, :key ], :cond
+
+        def as_run
+            return BoundSwitchRun.new(key, _cases_as_runs, _default_as_run, @cond)
+        end
+    end
+
+    class MacroDSL
+
+        # stores a block for workflow construction later
+
+        attr_reader :block
+
+        constructor :name, :engine, :block
+
+    end
+
+end