musa-dsl 0.14.29 → 0.21.3

data/lib/musa-dsl/sequencer.rb

@@ -1 +1 @@
-require 'musa-dsl/sequencer/sequencer'
+require_relative 'sequencer/sequencer'

data/lib/musa-dsl/sequencer/base-sequencer-implementation-control.rb

@@ -1,189 +1,216 @@
 require 'forwardable'
 
-class Musa::BaseSequencer
-  class EventHandler
-    attr_reader :stdout, :stderr
-    attr_accessor :continue_parameters
+module Musa
+  module Sequencer
+    class BaseSequencer
+      class EventHandler
+        include Musa::Extension::SmartProcBinder
 
-    @@counter = 0
+        attr_accessor :continue_parameters
 
-    def initialize(parent = nil, capture_stdout: nil)
-      capture_stdout ||= false
+        @@counter = 0
 
-      @id = (@@counter += 1)
+        def initialize(parent = nil)
+          @id = (@@counter += 1)
 
-      @parent = parent
-      @handlers = {}
+          @parent = parent
+          @handlers = {}
 
-      @stop = false
+          @stop = false
+        end
 
-      if capture_stdout || !parent
-        @stdout = $stdout
-        @stderr = $stderr
-      else
-        @stdout = @parent.stdout
-        @stderr = @parent.stderr
-      end
-    end
+        def stop
+          @stop = true
+        end
 
-    def stop
-      @stop = true
-    end
+        def stopped?
+          @stop
+        end
 
-    def stopped?
-      @stop
-    end
+        def pause
+          raise NotImplementedError
+        end
 
-    def pause
-      raise NotImplementedError
-    end
+        def continue
+          @paused = false
+        end
 
-    def continue
-      @paused = false
-    end
+        def paused?
+          @paused
+        end
 
-    def paused?
-      @paused
-    end
+        def on(event, name: nil, only_once: nil, &block)
+          only_once ||= false
 
-    def on(event, name: nil, only_once: nil, &block)
-      only_once ||= false
+          @handlers[event] ||= {}
 
-      @handlers[event] ||= {}
+          # TODO: add on_rescue: proc { |e| _rescue_block_error(e) } [this method is on Sequencer, not in EventHandler]
+          @handlers[event][name] = {block: SmartProcBinder.new(block), only_once: only_once }
+        end
 
-      # TODO: add on_rescue: proc { |e| _rescue_block_error(e) } [this method is on Sequencer, not in EventHandler]
-      @handlers[event][name] = { block: KeyParametersProcedureBinder.new(block), only_once: only_once }
-    end
+        def launch(event, *value_parameters, **key_parameters)
+          _launch event, value_parameters, key_parameters
+        end
 
-    def launch(event, *value_parameters, **key_parameters)
-      _launch event, value_parameters, key_parameters
-    end
+        def _launch(event, value_parameters = nil, key_parameters = nil)
+          value_parameters ||= []
+          key_parameters ||= {}
+          processed = false
 
-    def _launch(event, value_parameters = nil, key_parameters = nil)
-      processed = false
+          if @handlers.key? event
+            @handlers[event].each do |name, handler|
+              handler[:block].call *value_parameters, **key_parameters
+              @handlers[event].delete name if handler[:only_once]
+              processed = true
+            end
+          end
 
-      if @handlers.key? event
-        @handlers[event].each do |name, handler|
-          handler[:block]._call value_parameters, key_parameters
-          @handlers[event].delete name if handler[:only_once]
-          processed = true
+          @parent._launch event, value_parameters, key_parameters if @parent && !processed
         end
-      end
 
-      @parent._launch event, value_parameters, key_parameters if @parent && !processed
-    end
+        def inspect
+          "EventHandler #{id}"
+        end
 
-    def inspect
-      "EventHandler #{id}"
-    end
+        def id
+          if @parent
+            "#{@parent.id}.#{self.class.name.split('::').last}-#{@id}"
+          else
+            "#{self.class.name.split('::').last}-#{@id.to_s}"
+          end
+        end
 
-    def id
-      if @parent
-        "#{@parent.id}.#{self.class.name.split('::').last}-#{@id}"
-      else
-        "#{self.class.name.split('::').last}-#{@id.to_s}"
+        alias to_s inspect
       end
-    end
 
-    alias to_s inspect
-  end
+      private_constant :EventHandler
 
-  private_constant :EventHandler
+      class PlayControl < EventHandler
+        attr_reader :do_after
 
-  class PlayControl < EventHandler
-    attr_reader :do_after
+        def initialize(parent, after: nil)
+          super parent
 
-    def initialize(parent, capture_stdout: nil, after: nil)
-      super parent, capture_stdout: capture_stdout
+          @do_after = []
 
-      @do_after = []
+          self.after &after if after
+        end
 
-      self.after &after if after
-    end
+        def pause
+          @paused = true
+        end
 
-    def pause
-      @paused = true
-    end
+        def store_continuation(sequencer:, serie:, nl_context:, mode:, decoder:, play_eval:, mode_args:)
+          @continuation_sequencer = sequencer
+          @continuation_parameters = {
+              serie: serie,
+              control: self,
+              nl_context: nl_context,
+              mode: mode,
+              decoder: decoder,
+              play_eval: play_eval,
+              mode_args: mode_args
+          }
+        end
 
-    def store_continuation(sequencer:, serie:, nl_context:, mode:, decoder:, play_eval:, mode_args:)
-      @continuation_sequencer = sequencer
-      @continuation_parameters = {
-          serie: serie,
-          control: self,
-          nl_context: nl_context,
-          mode: mode,
-          decoder: decoder,
-          play_eval: play_eval,
-          mode_args: mode_args
-      }
-    end
+        def continue
+          super
+          @continuation_sequencer.continuation_play(@continuation_parameters) if @continuation_sequencer
+        end
 
-    def continue
-      super
-      @continuation_sequencer.continuation_play(@continuation_parameters) if @continuation_sequencer
-    end
+        def after(_bars = nil, &block)
+          # TODO implementar parámetro _bars (?)
+          @do_after << block
+        end
+      end
 
-    def after(_bars = nil, &block)
-      # TODO implementar parámetro _bars (?)
-      @do_after << block
-    end
-  end
+      private_constant :PlayControl
 
-  private_constant :PlayControl
+      class EveryControl < EventHandler
+        attr_reader :duration_value, :till_value, :condition_block, :do_on_stop, :do_after
 
-  class EveryControl < EventHandler
-    attr_reader :duration_value, :till_value, :condition_block, :do_on_stop, :do_after
+        attr_accessor :_start_position
+        attr_accessor :_execution_counter
 
-    attr_accessor :_start
+        def initialize(parent, duration: nil, till: nil, condition: nil, on_stop: nil, after_bars: nil, after: nil)
+          super parent
 
-    def initialize(parent, capture_stdout: nil, duration: nil, till: nil, condition: nil, on_stop: nil, after_bars: nil, after: nil)
-      super parent, capture_stdout: capture_stdout
+          @duration_value = duration
+          @till_value = till
+          @condition_block = condition
 
-      @duration_value = duration
-      @till_value = till
-      @condition_block = condition
+          @do_on_stop = []
+          @do_after = []
 
-      @do_on_stop = []
-      @do_after = []
+          @do_on_stop << on_stop if on_stop
 
-      @do_on_stop << on_stop if on_stop
+          self.after after_bars, &after if after
+        end
 
-      self.after after_bars, &after if after
-    end
+        def duration(value)
+          @duration_value = value.rationalize
+        end
 
-    def duration(value)
-      @duration_value = value.rationalize
-    end
+        def till(value)
+          @till_value = value.rationalize
+        end
 
-    def till(value)
-      @till_value = value.rationalize
-    end
+        def condition(&block)
+          @condition_block = block
+        end
 
-    def condition(&block)
-      @condition_block = block
-    end
+        def on_stop(&block)
+          @do_on_stop << block
+        end
 
-    def on_stop(&block)
-      @do_on_stop << block
-    end
+        def after(bars = nil, &block)
+          bars ||= 0
+          @do_after << { bars: bars.rationalize, block: block }
+        end
+      end
 
-    def after(bars = nil, &block)
-      bars ||= 0
-      @do_after << { bars: bars.rationalize, block: block }
-    end
-  end
+      private_constant :EveryControl
 
-  private_constant :EveryControl
+      class MoveControl < EventHandler
+        attr_reader :every_control, :do_on_stop, :do_after
 
-  class MoveControl
-    extend Forwardable
+        def initialize(parent, duration: nil, till: nil, on_stop: nil, after_bars: nil, after: nil)
+          super parent
 
-    def initialize(every_control)
-      @every_control = every_control
-    end
+          @every_control = EveryControl.new(self, duration: duration, till: till)
 
-    def_delegators :@every_control, :stdout, :stderr, :on_stop, :after, :on, :launch, :stop
-  end
+          @do_on_stop = []
+          @do_after = []
+
+          @do_on_stop << on_stop if on_stop
+          self.after after_bars, &after if after
+
+          @every_control.on_stop do
+            @stop = true
+            @do_on_stop.each(&:call)
+          end
+        end
+
+        def on_stop(&block)
+          @do_on_stop << block
+        end
+
+        def after(bars = nil, &block)
+          bars ||= 0
+          @do_after << { bars: bars.rationalize, block: block }
+        end
 
-  private_constant :MoveControl
+        def stop
+          @every_control.stop
+        end
+
+        def stopped?
+          @stop
+        end
+      end
+
+      private_constant :MoveControl
+    end
+  end
 end
+

data/lib/musa-dsl/sequencer/base-sequencer-implementation-play-helper.rb

@@ -1,354 +1,369 @@
-class Musa::BaseSequencer
-  class PlayEval
-    def self.create(mode, block_procedure_binder, decoder, nl_context)
-      case mode
-      when :at
-        AtModePlayEval.new block_procedure_binder
-      when :wait
-        WaitModePlayEval.new block_procedure_binder
-      when :neumalang
-        NeumalangModePlayEval.new block_procedure_binder, decoder, nl_context
-      else
-        raise ArgumentError, "Mode #{mode} not allowed"
-      end
-    end
-
-    attr_reader :block_procedure_binder
-
-    def subcontext
-      self
-    end
-
-    def eval_element(_element)
-      raise NotImplementedError
-    end
+using Musa::Extension::DeepCopy
+
+module Musa
+  module Sequencer
+    class BaseSequencer
+      class PlayEval
+        def self.create(mode, block_procedure_binder, decoder, nl_context)
+          case mode
+          when :at
+            AtModePlayEval.new block_procedure_binder
+          when :wait
+            WaitModePlayEval.new block_procedure_binder
+          when :neumalang
+            NeumalangModePlayEval.new block_procedure_binder, decoder, nl_context
+          else
+            raise ArgumentError, "Mode #{mode} not allowed"
+          end
+        end
 
-    def run_operation(_element)
-      raise NotImplementedError
-    end
-  end
+        attr_reader :block_procedure_binder
 
-  private_constant :PlayEval
+        def subcontext
+          self
+        end
 
-  class AtModePlayEval < PlayEval
-    def initialize(block_procedure_binder)
-      @block_procedure_binder = block_procedure_binder
-    end
+        def eval_element(_element)
+          raise NotImplementedError
+        end
 
-    def run_operation(element)
-      value = nil
-
-      if element.is_a? Hash
-        value = {
-          current_operation: :block,
-          current_block: @block_procedure_binder,
-          current_parameter: element,
-          continue_operation: :at,
-          continue_parameter: element[:at]
-        }
+        def run_operation(_element)
+          raise NotImplementedError
+        end
       end
 
-      value ||= {
-        current_operation: @block_procedure_binder,
-        current_parameter: element,
-        continue_operation: :at,
-        continue_parameter: position
-      }
-    end
-  end
-
-  private_constant :AtModePlayEval
+      private_constant :PlayEval
 
-  class WaitModePlayEval < PlayEval
-    def initialize(block_procedure_binder)
-      @block_procedure_binder = block_procedure_binder
-    end
-
-    def run_operation(element)
-      value = nil
-
-      if element.is_a? Hash
-        if element.key? :duration
-          value = {
-            current_operation: :block,
-            current_block: @block_procedure_binder,
-            current_parameter: element,
-            continue_operation: :wait,
-            continue_parameter: element[:duration]
-          }
+      class AtModePlayEval < PlayEval
+        def initialize(block_procedure_binder)
+          @block_procedure_binder = block_procedure_binder
         end
 
-        if element.key? :wait_event
-          value = {
-            current_operation: :block,
-            current_block: @block_procedure_binder,
-            current_parameter: element,
-            continue_operation: :on,
-            continue_parameter: element[:wait_event]
+        def run_operation(element)
+          value = nil
+
+          if element.is_a? Hash
+            value = {
+                current_operation: :block,
+                current_block: @block_procedure_binder,
+                current_parameter: element,
+                continue_operation: :at,
+                continue_parameter: element[:at]
+            }
+          end
+
+          value ||= {
+              current_operation: @block_procedure_binder,
+              current_parameter: element,
+              continue_operation: :at,
+              continue_parameter: position
           }
         end
       end
 
-      value ||= {
-        current_operation: :block,
-        current_block: @block_procedure_binder,
-        current_parameter: element,
-        continue_operation: :now
-      }
-
-      value
-    end
-  end
-
-  private_constant :WaitModePlayEval
-
-  class NeumalangModePlayEval < PlayEval
-    module Parallel end
-
-    @@id = 0
+      private_constant :AtModePlayEval
 
-    attr_reader :nl_context
-    attr_reader :block_procedure_binder
+      class WaitModePlayEval < PlayEval
+        include Musa::Datasets
 
-    def initialize(block_procedure_binder, decoder, nl_context, parent: nil)
-      @id = @@id += 1
-      @parent = parent
+        def initialize(block_procedure_binder)
+          @block_procedure_binder = block_procedure_binder
+        end
 
-      @block_procedure_binder = block_procedure_binder
-      @decoder = decoder
-      @nl_context = nl_context
-      @nl_context ||= Object.new
-    end
+        def run_operation(element)
+          value = nil
+
+          if element.is_a? Hash
+            if AbsD.is_compatible?(element)
+              element = AbsD.to_AbsD(element)
+
+              value = {
+                  current_operation: :block,
+                  current_block: @block_procedure_binder,
+                  current_parameter: element,
+                  continue_operation: :wait,
+                  continue_parameter: element.forward_duration
+              }
+            end
+
+            if element.key? :wait_event
+              value = {
+                  current_operation: :block,
+                  current_block: @block_procedure_binder,
+                  current_parameter: element,
+                  continue_operation: :on,
+                  continue_parameter: element[:wait_event]
+              }
+            end
+          end
 
-    def subcontext
-      NeumalangModePlayEval.new @block_procedure_binder, @decoder.subcontext, @nl_context, parent: self
-    end
+          value ||= {
+              current_operation: :block,
+              current_block: @block_procedure_binder,
+              current_parameter: element,
+              continue_operation: :now
+          }
 
-    def eval_element(element)
-      if element.is_a? Musa::Neumalang::Dataset
-        element
-      else
-        case element[:kind]
-        when :serie         then eval_serie element[:serie]
-        when :parallel      then eval_parallel element[:parallel]
-        when :assign_to     then eval_assign_to element[:assign_to], element[:assign_value]
-        when :use_variable  then eval_use_variable element[:use_variable]
-        when :command       then eval_command element[:command], element[:value_parameters], element[:key_parameters]
-        when :value         then eval_value element[:value]
-        when :neuma         then eval_neuma element[:neuma]
-        when :call_methods  then eval_call_methods element[:on], element[:call_methods]
-        when :indirection   then eval_indirection element[:indirection]
-        when :reference     then eval_reference element[:reference]
-        when :event         then element
-        else
-          raise ArgumentError, "eval_element: don't know how to process #{element}"
+          value
         end
       end
-    end
-
-    def eval_value(value)
-      value
-    end
-
-    def eval_neuma(neuma)
-      @decoder.decode neuma
-    end
 
-    def eval_serie(serie)
-      context = subcontext
-      serie.instance.eval(on_restart: proc { context = subcontext }) { |e| context.eval_element e }
-    end
+      private_constant :WaitModePlayEval
 
-    def eval_parallel(series)
-      context = subcontext
-      series.collect { |s| context.eval_serie s[:serie] }.extend Parallel
-    end
+      class NeumalangModePlayEval < PlayEval
+        include Musa::Datasets
 
-    def eval_assign_to(variable_names, value)
-      _value = nil
+        module Parallel end
 
-      variable_names.each do |var_name|
-        @nl_context.instance_variable_set var_name, _value = subcontext.eval_element(value)
-      end
+        @@id = 0
 
-      _value
-    end
+        attr_reader :nl_context
+        attr_reader :block_procedure_binder
 
-    def eval_use_variable(variable_name)
-      if @nl_context.instance_variable_defined? variable_name
-        @nl_context.instance_variable_get(variable_name)
-      else
-        raise NameError, "Variable #{variable_name} is not defined in context #{@nl_context}"
-      end
-    end
+        def initialize(block_procedure_binder, decoder, nl_context, parent: nil)
+          @id = @@id += 1
+          @parent = parent
 
-    def eval_command(block, value_parameters, key_parameters)
-      _value_parameters = value_parameters.collect { |e| subcontext.eval_element(e) } if value_parameters
-      _key_parameters = key_parameters.collect { |k, e| [k, subcontext.eval_element(e)] }.to_h if key_parameters
+          @block_procedure_binder = block_procedure_binder
+          @decoder = decoder
+          @nl_context = nl_context
 
-      @nl_context._as_context_run block, _value_parameters, _key_parameters
-    end
-
-    def eval_call_methods(on, call_methods)
-      play_eval = subcontext
-
-      value = play_eval.eval_element on
+          @nl_context ||= Object.new
+        end
 
-      if value.is_a? Parallel
-        value.collect do |_value|
-          call_methods.each do |methd|
-            value_parameters = methd[:value_parameters].collect { |e| play_eval.subcontext.eval_element(e) } if methd[:value_parameters]
-            key_parameters = methd[:key_parameters].collect { |k, e| [k, play_eval.subcontext.eval_element(e)] }.to_h if methd[:key_parameters]
+        def subcontext
+          NeumalangModePlayEval.new @block_procedure_binder, @decoder.subcontext, @nl_context, parent: self
+        end
 
-            _value = _value._send_nice methd[:method], value_parameters, key_parameters
+        def eval_element(element)
+          if AbsD.is_compatible?(element)
+            AbsD.to_AbsD(element)
+          else
+            case element[:kind]
+            when :serie         then eval_serie element[:serie]
+            when :parallel      then eval_parallel element[:parallel]
+            when :assign_to     then eval_assign_to element[:assign_to], element[:assign_value]
+            when :use_variable  then eval_use_variable element[:use_variable]
+            when :command       then eval_command element[:command], element[:value_parameters], element[:key_parameters]
+            when :value         then eval_value element[:value]
+            when :gdvd          then eval_gdvd element[:gdvd]
+            when :p             then eval_p element[:p]
+            when :call_methods  then eval_call_methods element[:on], element[:call_methods]
+            when :reference     then eval_reference element[:reference]
+            when :event         then element
+            else
+              raise ArgumentError, "eval_element: don't know how to process #{element}"
+            end
           end
-
-          _value
-        end.extend Parallel
-      else
-        call_methods.each do |methd|
-          value_parameters = methd[:value_parameters].collect { |e| play_eval.subcontext.eval_element(e) } if methd[:value_parameters]
-          key_parameters = methd[:key_parameters].collect { |k, e| [k, play_eval.subcontext.eval_element(e)] }.to_h if methd[:key_parameters]
-
-          value = value._send_nice methd[:method], value_parameters, key_parameters
         end
 
-        value
-      end
-    end
-
-    def eval_reference(element)
-      if element.is_a?(Hash) && element.key?(:kind)
-        case element[:kind]
-        when :command
-          element[:command]
-        else
-          raise ArgumentError, "eval_reference(&): don't know how to process element #{element}"
+        def eval_value(value)
+          value
         end
-      else
-        raise ArgumentError, "eval_reference(&): don't know how to process element #{element}"
-      end
-    end
-
-    def run_operation(element)
-      case element
-      when nil
-        { current_operation: :none,
-          continue_operation: :now }
 
-      when Musa::Neumalang::Dataset
-        { current_operation: :block,
-          current_parameter: element,
-          continue_operation: :wait,
-          continue_parameter: element[:duration] }
+        def eval_gdvd(gdvd)
+          @decoder.decode(gdvd)
+        end
 
-      when Musa::Serie
-        { current_operation: :play,
-          current_parameter: element.restart }
+        def eval_p(p)
+          p.to_ps_serie(@decoder.base_duration).instance
+        end
 
-      when Parallel
-        { current_operation: :parallel_play,
-          current_parameter: element.tap { |e| e.each(&:restart) } }
+        def eval_serie(serie)
+          context = subcontext
+          serie.instance.eval(on_restart: proc { context = subcontext }) { |e| context.eval_element e }
+        end
 
-      when Array
-        { current_operation: :no_eval_play,
-          current_parameter: S(*element) }
-      else
-        case element[:kind]
-        when :value
+        def eval_parallel(series)
+          context = subcontext
+          series.collect { |s| context.eval_serie s[:serie] }.extend Parallel
+        end
 
-          _value = eval_value element[:value]
+        def eval_assign_to(variable_names, value)
+          _value = nil
 
-          if _value.is_a?(Hash) && _value.key?(:duration)
-            { current_operation: :block,
-              current_parameter: _value,
-              continue_operation: :wait,
-              continue_parameter: _value[:duration] }
-          else
-            { current_operation: :block,
-              current_parameter: _value,
-              continue_operation: :now }
+          variable_names.each do |var_name|
+            @nl_context.instance_variable_set var_name, _value = subcontext.eval_element(value)
           end
 
-        when :neuma
-          _value = eval_neuma element[:neuma]
+          _value
+        end
 
-          if _value.is_a?(Array)
-            { current_operation: :no_eval_play,
-              current_parameter: S(*_value) }
+        def eval_use_variable(variable_name)
+          if @nl_context.instance_variable_defined?(variable_name)
+            @nl_context.instance_variable_get(variable_name)
           else
-            { current_operation: :block,
-              current_parameter: _value,
-              continue_operation: :wait,
-              continue_parameter: _value[:duration] }
+            raise NameError, "Variable #{variable_name} is not defined in context #{@nl_context}"
           end
+        end
 
-        when :serie
-
-          { current_operation: :play,
-            current_parameter: eval_serie(element[:serie]) }
-
-        when :parallel
-
-          { current_operation: :parallel_play,
-            current_parameter: eval_parallel(element[:parallel]) }
-
-        when :assign_to
+        def eval_command(block, value_parameters, key_parameters)
+          _value_parameters = value_parameters ? value_parameters.collect { |e| subcontext.eval_element(e) } : []
+          _key_parameters = key_parameters ? key_parameters.collect { |k, e| [k, subcontext.eval_element(e)] }.to_h : {}
 
-          eval_assign_to element[:assign_to], element[:assign_value]
+          # used instance_exec because the code on block comes from a neumalang source, so the correct execution context is the neumalang context
+          # (no other context has any sense)
+          #
+          @nl_context.instance_exec *_value_parameters, **_key_parameters, &block
+        end
 
-          { current_operation: :none,
-            continue_operation: :now }
+        def eval_call_methods(on, call_methods)
+          play_eval = subcontext
 
-        when :use_variable
+          value = play_eval.eval_element on
 
-          run_operation eval_use_variable(element[:use_variable])
+          if value.is_a? Parallel
+            value.collect do |_value|
+              call_methods.each do |methd|
+                value_parameters = methd[:value_parameters] ? methd[:value_parameters].collect { |e| play_eval.subcontext.eval_element(e) } : []
+                key_parameters = methd[:key_parameters] ? methd[:key_parameters].collect { |k, e| [k, play_eval.subcontext.eval_element(e)] }.to_h : {}
 
-        when :event
+                _value = _value.send methd[:method], *value_parameters, **key_parameters
+              end
 
-          value_parameters = key_parameters = nil
+              _value
+            end.extend Parallel
+          else
+            call_methods.each do |methd|
+              value_parameters = methd[:value_parameters] ? methd[:value_parameters].collect { |e| play_eval.subcontext.eval_element(e) } : []
+              key_parameters = methd[:key_parameters] ? methd[:key_parameters].collect { |k, e| [k, play_eval.subcontext.eval_element(e)] }.to_h : {}
 
-          value_parameters = element[:value_parameters].collect { |e| subcontext.eval_element(e) } if element[:value_parameters]
-          key_parameters = element[:key_parameters].collect { |k, e| [k, subcontext.eval_element(e)] }.to_h if element[:key_parameters]
+              value = value.send methd[:method], *value_parameters, **key_parameters
+            end
 
-          { current_operation: :event,
-            current_event: element[:event],
-            current_value_parameters: value_parameters,
-            current_key_parameters: key_parameters,
-            continue_operation: :now }
+            value
+          end
+        end
 
-        when :command
+        def eval_reference(element)
+          if element.is_a?(Hash) && element.key?(:kind)
+            case element[:kind]
+            when :command
+              element[:command]
+            else
+              raise ArgumentError, "eval_reference(&): don't know how to process element #{element}"
+            end
+          else
+            raise ArgumentError, "eval_reference(&): don't know how to process element #{element}"
+          end
+        end
 
-          run_operation eval_command(element[:command], element[:value_parameters], element[:key_parameters])
+        def run_operation(element)
+          case element
+          when nil
+            { current_operation: :none,
+              continue_operation: :now }
 
-        when :call_methods
+          when Musa::Datasets::AbsD
+            { current_operation: :block,
+              current_parameter: element,
+              continue_operation: :wait,
+              continue_parameter: element.forward_duration }
 
-          run_operation eval_call_methods(element[:on], element[:call_methods])
+          when Musa::Series::Serie
+            { current_operation: :play,
+              current_parameter: element.restart }
 
-        when :reference
+          when Parallel
+            { current_operation: :parallel_play,
+              current_parameter: element.tap { |e| e.each(&:restart) } }
 
-          run_operation eval_reference(element[:reference])
+          when Array
+            { current_operation: :no_eval_play,
+              current_parameter: S(*element) }
+          else
+            case element[:kind]
+            when :value
+              _value = eval_value element[:value]
+
+              if AbsD.is_compatible?(_value)
+                _value = AbsD.to_AbsD(_value)
+
+                { current_operation: :block,
+                  current_parameter: _value,
+                  continue_operation: :wait,
+                  continue_parameter: _value.forward_duration }
+              else
+                { current_operation: :block,
+                  current_parameter: _value,
+                  continue_operation: :now }
+              end
+
+            when :gdvd
+              _value = eval_gdvd element[:gdvd]
+
+              if _value.is_a?(Array)
+                { current_operation: :no_eval_play,
+                  current_parameter: S(*_value) }
+              else
+                { current_operation: :block,
+                  current_parameter: _value,
+                  continue_operation: :wait,
+                  continue_parameter: _value.forward_duration }
+              end
+
+            when :p
+              { current_operation: :play,
+                current_parameter: eval_p(element[:p]) }
+
+            when :serie
+              { current_operation: :play,
+                current_parameter: eval_serie(element[:serie]) }
+
+            when :parallel
+              { current_operation: :parallel_play,
+                current_parameter: eval_parallel(element[:parallel]) }
+
+            when :assign_to
+              eval_assign_to element[:assign_to], element[:assign_value]
+
+              { current_operation: :none,
+                continue_operation: :now }
+
+            when :use_variable
+              run_operation eval_use_variable(element[:use_variable])
+
+            when :event
+              value_parameters = element[:value_parameters] ? element[:value_parameters].collect { |e| subcontext.eval_element(e) } : []
+              key_parameters = element[:key_parameters] ? element[:key_parameters].collect { |k, e| [k, subcontext.eval_element(e)] }.to_h : {}
+
+              { current_operation: :event,
+                current_event: element[:event],
+                current_value_parameters: value_parameters,
+                current_key_parameters: key_parameters,
+                continue_operation: :now }
+
+            when :command
+              run_operation eval_command(element[:command], element[:value_parameters], element[:key_parameters])
+
+            when :call_methods
+              run_operation eval_call_methods(element[:on], element[:call_methods])
+
+            when :reference
+              run_operation eval_reference(element[:reference])
+
+            else
+              raise ArgumentError, "run_operation: don't know how to process #{element}"
+            end
+          end
+        end
 
-        else
-          raise ArgumentError, "run_operation: don't know how to process #{element}"
+        def inspect
+          "NeumalangModePlayEval #{id} #{@decoder}"
         end
-      end
-    end
 
-    def inspect
-      "NeumalangModePlayEval #{id} #{@decoder}"
-    end
+        def id
+          if @parent
+            "#{@parent.id}.#{@id}"
+          else
+            @id.to_s
+          end
+        end
 
-    def id
-      if @parent
-        "#{@parent.id}.#{@id}"
-      else
-        @id.to_s
+        alias to_s inspect
       end
-    end
 
-    alias to_s inspect
+      private_constant :NeumalangModePlayEval
+    end
   end
-
-  private_constant :NeumalangModePlayEval
 end