musa-dsl 0.14.16

data/lib/musa-dsl/repl/repl.rb

@@ -0,0 +1,143 @@
+require 'socket'
+
+module Musa
+  class REPL
+    @@repl_mutex = Mutex.new
+
+    def initialize(binder, port: nil, redirect_stderr: nil, after_eval: nil)
+      port ||= 1327
+      redirect_stderr ||= false
+
+      @block_source = nil
+
+      if binder.receiver.respond_to?(:sequencer) &&
+         binder.receiver.sequencer.respond_to?(:on_block_error)
+
+        binder.receiver.sequencer.on_block_error do |e|
+          send_exception e
+        end
+      end
+
+      @client_threads = []
+
+      @main_thread = Thread.new do
+        @server = TCPServer.new(port)
+        begin
+          while connection = @server.accept
+            @client_threads << Thread.new do
+              buffer = nil
+
+              begin
+                while line = connection.gets
+                  line.chomp!
+                  case line
+                  when '#begin'
+                    buffer = StringIO.new
+                  when '#end'
+                    @@repl_mutex.synchronize do
+                      original_stdout = $stdout
+                      original_stderr = $stderr
+
+                      $stdout = connection
+                      $stderr = connection if redirect_stderr
+
+                      @block_source = buffer.string
+
+                      begin
+                        send_echo @block_source
+
+                        binder.eval @block_source, "(repl)", 1
+                      rescue StandardError, ScriptError => e
+                        send_exception e
+                      else
+                        after_eval.call @block_source if after_eval
+                      end
+
+                      $stdout = original_stdout
+                      $stderr = original_stderr if redirect_stderr
+                    end
+                  else
+                    buffer.puts line
+                  end
+                end
+              rescue IOError, Errno::ECONNRESET, Errno::EPIPE => e
+                warn e.message
+              end
+
+              connection.close
+            end
+          end
+        rescue Errno::ECONNRESET, Errno::EPIPE => e
+          warn e.message
+          retry
+        end
+      end
+    end
+
+    def stop
+      # TODO
+    end
+
+    private
+
+    def send_echo(e)
+      send command: '//echo'
+      send content: e
+      send command: '//end'
+    end
+
+    def send_exception(e)
+
+      send command: '//error'
+
+      selected_backtrace_locations = e.backtrace_locations.select { |bt| bt.path == '(repl)' }
+
+      if e.is_a?(ScriptError)
+        send content: e.class.name
+        send command: '//backtrace'
+        send content: e.message
+
+      elsif selected_backtrace_locations.empty?
+        send content: "#{e.class.name}: #{e.message}"
+        send command: '//backtrace'
+        send content: e.backtrace_locations.first.to_s
+
+      else
+        lines = @block_source.split("\n")
+
+        lineno = selected_backtrace_locations.first.lineno
+
+        source_before = lines[lineno - 2] if lineno >= 2
+        source_error = lines[lineno - 1]
+        source_after = lines[lineno]
+
+        send content: '***'
+        send content: "[#{lineno - 1}] #{source_before}" if source_before
+        send content: "[#{lineno}] #{source_error} \t\t<<< ERROR !!!"
+        send content: "[#{lineno + 1}] #{source_after}" if source_after
+        send content: '***'
+        send content: e.class.name
+        send content: e.message
+        send command: '//backtrace'
+        selected_backtrace_locations.each do |bt|
+          send content: bt.to_s
+        end
+      end
+      send content: ' '
+      send command: '//end'
+    end
+
+    def send(content: nil, command: nil)
+      puts escape(content) if content
+      puts command if command
+    end
+
+    def escape(text)
+      if text.start_with? '//'
+        "//#{text}"
+      else
+        text
+      end
+    end
+  end
+end

data/lib/musa-dsl/repl.rb

@@ -0,0 +1 @@
+require 'musa-dsl/repl/repl'

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

@@ -0,0 +1,189 @@
+require 'forwardable'
+
+class Musa::BaseSequencer
+  class EventHandler
+    attr_reader :stdout, :stderr
+    attr_accessor :continue_parameters
+
+    @@counter = 0
+
+    def initialize(parent = nil, capture_stdout: nil)
+      capture_stdout ||= false
+
+      @id = (@@counter += 1)
+
+      @parent = parent
+      @handlers = {}
+
+      @stop = false
+
+      if capture_stdout || !parent
+        @stdout = $stdout
+        @stderr = $stderr
+      else
+        @stdout = @parent.stdout
+        @stderr = @parent.stderr
+      end
+    end
+
+    def stop
+      @stop = true
+    end
+
+    def stopped?
+      @stop
+    end
+
+    def pause
+      raise NotImplementedError
+    end
+
+    def continue
+      @paused = false
+    end
+
+    def paused?
+      @paused
+    end
+
+    def on(event, name: nil, only_once: nil, &block)
+      only_once ||= false
+
+      @handlers[event] ||= {}
+
+      # 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 = 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
+
+      @parent._launch event, value_parameters, key_parameters if @parent && !processed
+    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
+
+    alias to_s inspect
+  end
+
+  private_constant :EventHandler
+
+  class PlayControl < EventHandler
+    attr_reader :do_after
+
+    def initialize(parent, capture_stdout: nil, after: nil)
+      super parent, capture_stdout: capture_stdout
+
+      @do_after = []
+
+      self.after &after if after
+    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 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
+
+  private_constant :PlayControl
+
+  class EveryControl < EventHandler
+    attr_reader :duration_value, :till_value, :condition_block, :do_on_stop, :do_after
+
+    attr_accessor :_start
+
+    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
+
+      @do_on_stop = []
+      @do_after = []
+
+      @do_on_stop << on_stop if on_stop
+
+      self.after after_bars, &after if after
+    end
+
+    def duration(value)
+      @duration_value = value.rationalize
+    end
+
+    def till(value)
+      @till_value = value.rationalize
+    end
+
+    def condition(&block)
+      @condition_block = 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
+
+  private_constant :EveryControl
+
+  class MoveControl
+    extend Forwardable
+
+    def initialize(every_control)
+      @every_control = every_control
+    end
+
+    def_delegators :@every_control, :stdout, :stderr, :on_stop, :after, :on, :launch, :stop
+  end
+
+  private_constant :MoveControl
+end

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

@@ -0,0 +1,354 @@
+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
+
+    def run_operation(_element)
+      raise NotImplementedError
+    end
+  end
+
+  private_constant :PlayEval
+
+  class AtModePlayEval < PlayEval
+    def initialize(block_procedure_binder)
+      @block_procedure_binder = block_procedure_binder
+    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]
+        }
+      end
+
+      value ||= {
+        current_operation: @block_procedure_binder,
+        current_parameter: element,
+        continue_operation: :at,
+        continue_parameter: position
+      }
+    end
+  end
+
+  private_constant :AtModePlayEval
+
+  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]
+          }
+        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
+
+      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
+
+    attr_reader :nl_context
+    attr_reader :block_procedure_binder
+
+    def initialize(block_procedure_binder, decoder, nl_context, parent: nil)
+      @id = @@id += 1
+      @parent = parent
+
+      @block_procedure_binder = block_procedure_binder
+      @decoder = decoder
+      @nl_context = nl_context
+      @nl_context ||= Object.new
+    end
+
+    def subcontext
+      NeumalangModePlayEval.new @block_procedure_binder, @decoder.subcontext, @nl_context, parent: self
+    end
+
+    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}"
+        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
+
+    def eval_parallel(series)
+      context = subcontext
+      series.collect { |s| context.eval_serie s[:serie] }.extend Parallel
+    end
+
+    def eval_assign_to(variable_names, value)
+      _value = nil
+
+      variable_names.each do |var_name|
+        @nl_context.instance_variable_set var_name, _value = subcontext.eval_element(value)
+      end
+
+      _value
+    end
+
+    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 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
+
+      @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
+
+      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]
+
+            _value = _value._send_nice methd[:method], value_parameters, key_parameters
+          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}"
+        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] }
+
+      when Musa::Serie
+        { current_operation: :play,
+          current_parameter: element.restart }
+
+      when Parallel
+        { current_operation: :parallel_play,
+          current_parameter: element.tap { |e| e.each(&:restart) } }
+
+      when Array
+        { current_operation: :no_eval_play,
+          current_parameter: S(*element) }
+      else
+        case element[:kind]
+        when :value
+
+          _value = eval_value element[:value]
+
+          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 }
+          end
+
+        when :neuma
+          _value = eval_neuma element[:neuma]
+
+          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[:duration] }
+          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
+
+          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 = key_parameters = nil
+
+          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]
+
+          { 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
+
+    def inspect
+      "NeumalangModePlayEval #{id} #{@decoder}"
+    end
+
+    def id
+      if @parent
+        "#{@parent.id}.#{@id}"
+      else
+        @id.to_s
+      end
+    end
+
+    alias to_s inspect
+  end
+
+  private_constant :NeumalangModePlayEval
+end