musa-dsl 0.14.18 → 0.21.0

data/lib/musa-dsl/sequencer/base-sequencer-public.rb

@@ -1,262 +1,273 @@
-require 'musa-dsl/core-ext/arrayfy'
-require 'musa-dsl/core-ext/key-parameters-procedure-binder'
+require_relative '../core-ext/arrayfy'
+require_relative '../core-ext/smart-proc-binder'
+require_relative '../logger'
 
-require 'musa-dsl/series'
+require_relative '../series'
 
-class Musa::BaseSequencer
-  attr_reader :ticks_per_bar, :tick_duration, :running_position
-  attr_reader :everying, :playing, :moving
+require_relative 'timeslots'
 
-  @@tick_mutex = Mutex.new
+require_relative 'base-sequencer-tick-based'
+require_relative 'base-sequencer-tickless-based'
 
-  def initialize(beats_per_bar, ticks_per_beat, do_log: nil)
-    do_log ||= false
+module Musa
+  module Sequencer
+    class BaseSequencer
+      attr_reader :beats_per_bar, :ticks_per_beat
+      attr_reader :running_position
+      attr_reader :everying, :playing, :moving
+      attr_reader :logger
 
-    @on_debug_at = []
-    @on_fast_forward = []
-    @on_block_error = []
+      def initialize(beats_per_bar = nil, ticks_per_beat = nil, logger: nil, do_log: nil, do_error_log: nil, log_position_format: nil)
 
-    @ticks_per_bar = Rational(beats_per_bar * ticks_per_beat)
-    @tick_duration = Rational(1, @ticks_per_bar)
+        raise ArgumentError,
+              "'beats_per_bar' and 'ticks_per_beat' parameters should be both nil or both have values" \
+              unless beats_per_bar && ticks_per_beat || beats_per_bar.nil? && ticks_per_beat.nil?
 
-    @score = {}
-
-    @everying = []
-    @playing = []
-    @moving = []
-
-    @do_log = do_log
-
-    reset
-  end
-
-  def reset
-    @score.clear
-    @everying.clear
-    @playing.clear
-    @moving.clear
+        if logger
+          @logger = logger
+        else
+          @logger = Musa::Logger::Logger.new(sequencer: self, position_format: log_position_format)
 
-    @event_handlers = [EventHandler.new]
+          @logger.error! if do_error_log || do_error_log.nil?
+          @logger.debug! if do_log
+        end
 
-    @position = @ticks_per_bar - 1
-  end
+        if beats_per_bar && ticks_per_beat
+          @beats_per_bar = Rational(beats_per_bar)
+          @ticks_per_beat = Rational(ticks_per_beat)
 
-  def tick
-    position_to_run = (@position += 1)
+          self.singleton_class.include TickBasedTiming
+        else
+          self.singleton_class.include TicklessBasedTiming
+        end
 
-    if @score[position_to_run]
-      @score[position_to_run].each do |command|
+        _init_timing
 
-        if command.key?(:parent_control) && !command[:parent_control].stopped?
-          @event_handlers.push command[:parent_control]
+        @on_debug_at = []
+        @on_error = []
 
-          @@tick_mutex.synchronize do
-            original_stdout = $stdout
-            original_stderr = $stderr
+        @before_tick = []
+        @on_fast_forward = []
 
-            $stdout = command[:parent_control].stdout
-            $stderr = command[:parent_control].stderr
+        @tick_mutex = Mutex.new
+        @position_mutex = Mutex.new
 
-            command[:block]._call command[:value_parameters], command[:key_parameters] if command[:block]
+        @timeslots = Timeslots.new
 
-            $stdout = original_stdout
-            $stderr = original_stderr
-          end
+        @everying = []
+        @playing = []
+        @moving = []
 
-          @event_handlers.pop
-        else
-          @@tick_mutex.synchronize do
-            command[:block]._call command[:value_parameters], command[:key_parameters] if command[:block]
-          end
-        end
+        reset
       end
 
-      @score.delete position_to_run
-    end
-  end
+      def reset
+        @timeslots.clear
+        @everying.clear
+        @playing.clear
+        @moving.clear
 
-  def size
-    @score.size
-  end
-
-  def empty?
-    @score.empty?
-  end
+        @event_handlers = [EventHandler.new]
 
-  def round(bar)
-    Rational((bar * @ticks_per_bar).round(0), @ticks_per_bar)
-  end
+        _reset_timing
+      end
 
-  def event_handler
-    @event_handlers.last
-  end
+      def size
+        @timeslots.values.sum(&:size)
+      end
 
-  def on_debug_at(&block)
-    @on_debug_at << block
-  end
+      def empty?
+        @timeslots.empty?
+      end
 
-  def on_block_error(&block)
-    @on_block_error << block
-  end
+      def run
+        tick until empty?
+      end
 
-  def on_fast_forward(&block)
-    @on_fast_forward << block
-  end
+      def event_handler
+        @event_handlers.last
+      end
 
-  def position
-    Rational(@position, @ticks_per_bar)
-  end
+      def on_debug_at(&block)
+        @on_debug_at << SmartProcBinder.new(block)
+      end
 
-  def position=(bposition)
-    position = bposition * @ticks_per_bar
+      def on_error(&block)
+        @on_error << SmartProcBinder.new(block)
+      end
 
-    raise ArgumentError, "Sequencer #{self}: cannot move back. current position: #{@position} new position: #{position}" if position < @position
+      def on_fast_forward(&block)
+        @on_fast_forward << SmartProcBinder.new(block)
+      end
 
-    @on_fast_forward.each { |block| block.call(true) }
+      def before_tick(&block)
+        @before_tick << SmartProcBinder.new(block)
+      end
 
-    tick while @position < position
+      def on(event, &block)
+        @event_handlers.last.on event, &block
+      end
 
-    @on_fast_forward.each { |block| block.call(false) }
-  end
+      def launch(event, *value_parameters, **key_parameters)
+        @event_handlers.last.launch event, *value_parameters, **key_parameters
+      end
 
-  def on(event, &block)
-    @event_handlers.last.on event, &block
-  end
+      def wait(bars_delay, with: nil, debug: nil, &block)
+        debug ||= false
 
-  def launch(event, *value_parameters, **key_parameters)
-    @event_handlers.last.launch event, *value_parameters, **key_parameters
-  end
+        control = EventHandler.new @event_handlers.last
+        @event_handlers.push control
 
-  def wait(bars_delay, with: nil, debug: nil, &block)
-    debug ||= false
+        if bars_delay.is_a? Numeric
+          _numeric_at position + bars_delay.rationalize, control, with: with, debug: debug, &block
+        else
+          bars_delay = Series::S(*bars_delay) if bars_delay.is_a?(Array)
+          bars_delay = bars_delay.instance if bars_delay
 
-    control = EventHandler.new @event_handlers.last, capture_stdout: true
-    @event_handlers.push control
+          with = Series::S(*with).repeat if with.is_a?(Array)
+          with = with.instance if with
 
-    if bars_delay.is_a? Numeric
-      _numeric_at position + bars_delay.rationalize, control, with: with, debug: debug, &block
-    else
-      bars_delay = Series::S(*bars_delay) if bars_delay.is_a? Array
-      bars_delay = bars_delay.instance if bars_delay
+          _serie_at bars_delay.eval { |delay| position + delay }, control, with: with, debug: debug, &block
+        end
 
-      with = Series::S(*with).repeat if with.is_a? Array
-      with = with.instance if with
+        @event_handlers.pop
 
-      _serie_at bars_delay.eval { |delay| position + delay }, control, with: with, debug: debug, &block
-    end
+        control
+      end
 
-    @event_handlers.pop
+      def now(with: nil, &block)
+        control = EventHandler.new @event_handlers.last
+        @event_handlers.push control
 
-    control
-  end
+        _numeric_at position, control, with: with, &block
 
-  def now(with: nil, &block)
-    control = EventHandler.new @event_handlers.last, capture_stdout: true
-    @event_handlers.push control
+        @event_handlers.pop
 
-    _numeric_at position, control, with: with, &block
+        control
+      end
 
-    @event_handlers.pop
+      def raw_at(bar_position, force_first: nil, &block)
+        _raw_numeric_at bar_position.rationalize, force_first: force_first, &block
 
-    control
-  end
+        nil
+      end
 
-  def raw_at(bar_position, force_first: nil, &block)
-    _raw_numeric_at bar_position, force_first: force_first, &block
+      def at(bar_position, with: nil, debug: nil, &block)
+        debug ||= false
 
-    nil
-  end
+        control = EventHandler.new @event_handlers.last
+        @event_handlers.push control
 
-  def at(bar_position, with: nil, debug: nil, &block)
-    debug ||= false
+        if bar_position.is_a? Numeric
+          _numeric_at bar_position.rationalize, control, with: with, debug: debug, &block
+        else
+          bar_position = Series::S(*bar_position) if bar_position.is_a? Array
+          bar_position = bar_position.instance if bar_position
 
-    control = EventHandler.new @event_handlers.last, capture_stdout: true
-    @event_handlers.push control
+          with = Series::S(*with).repeat if with.is_a? Array
+          with = with.instance if with
 
-    if bar_position.is_a? Numeric
-      _numeric_at bar_position, control, with: with, debug: debug, &block
-    else
-      bar_position = Series::S(*bar_position) if bar_position.is_a? Array
-      bar_position = bar_position.instance if bar_position
+          _serie_at bar_position, control, with: with, debug: debug, &block
+        end
 
-      with = Series::S(*with).repeat if with.is_a? Array
-      with = with.instance if with
+        @event_handlers.pop
 
-      _serie_at bar_position, control, with: with, debug: debug, &block
-    end
+        control
+      end
 
-    @event_handlers.pop
+      def play(serie, mode: nil, parameter: nil, after: nil, context: nil, **mode_args, &block)
+        mode ||= :wait
 
-    control
-  end
+        control = PlayControl.new @event_handlers.last, after: after
+        @event_handlers.push control
 
-  def play(serie, mode: nil, parameter: nil, after: nil, context: nil, **mode_args, &block)
-    mode ||= :wait
+        _play serie.instance, control, context, mode: mode, parameter: parameter, **mode_args, &block
 
-    control = PlayControl.new @event_handlers.last, after: after, capture_stdout: true
-    @event_handlers.push control
+        @event_handlers.pop
 
-    _play serie.instance, control, context, mode: mode, parameter: parameter, **mode_args, &block
+        @playing << control
 
-    @event_handlers.pop
+        control.after do
+          @playing.delete control
+        end
 
-    @playing << control
+        control
+      end
 
-    control.after do
-      @playing.delete control
-    end
+      def continuation_play(parameters)
+        _play parameters[:serie],
+              parameters[:control],
+              parameters[:nl_context],
+              mode: parameters[:mode],
+              decoder: parameters[:decoder],
+              __play_eval: parameters[:play_eval],
+              **parameters[:mode_args]
+      end
 
-    control
-  end
+      def every(interval, duration: nil, till: nil, condition: nil, on_stop: nil, after_bars: nil, after: nil, &block)
+        # nil interval means 'only once'
+        interval = interval.rationalize unless interval.nil?
 
-  def continuation_play(parameters)
-    _play parameters[:serie],
-          parameters[:control],
-          parameters[:nl_context],
-          mode: parameters[:mode],
-          decoder: parameters[:decoder],
-          __play_eval: parameters[:play_eval],
-          **parameters[:mode_args]
-  end
+        control = EveryControl.new @event_handlers.last,
+                                   duration: duration,
+                                   till: till,
+                                   condition: condition,
+                                   on_stop: on_stop,
+                                   after_bars: after_bars,
+                                   after: after
 
-  def every(binterval, duration: nil, till: nil, condition: nil, on_stop: nil, after_bars: nil, after: nil, &block)
-    binterval = binterval.rationalize
+        @event_handlers.push control
 
-    control = EveryControl.new @event_handlers.last, capture_stdout: true, duration: duration, till: till, condition: condition, on_stop: on_stop, after_bars: after_bars, after: after
-    @event_handlers.push control
+        _every interval, control, &block
 
-    _every binterval, control, &block
+        @event_handlers.pop
 
-    @event_handlers.pop
+        @everying << control
 
-    @everying << control
+        control.after do
+          @everying.delete control
+        end
 
-    control.after do
-      @everying.delete control
-    end
+        control
+      end
 
-    control
-  end
+      def move(every: nil,
+               from: nil, to: nil, step: nil,
+               duration: nil, till: nil,
+               function: nil,
+               right_open: nil,
+               on_stop: nil,
+               after_bars: nil,
+               after: nil,
+               &block)
+
+        control = _move every: every,
+                        from: from, to: to, step: step,
+                        duration: duration, till: till,
+                        function: function,
+                        right_open: right_open,
+                        on_stop: on_stop,
+                        after_bars: after_bars,
+                        after: after,
+                        &block
+
+        @moving << control
+
+        control.after do
+          @moving.delete control
+        end
 
-  def move(every: nil, from: nil, to: nil, step: nil, duration: nil, till: nil, right_open: nil, on_stop: nil, after_bars: nil, after: nil, &block)
-    control = _move every: every, from: from, to: to, step: step, duration: duration, till: till, right_open: right_open, on_stop: on_stop, after_bars: after_bars, after: after, &block
+        control
+      end
 
-    @moving << control
+      def debug(msg = nil)
+        @logger.debug { msg || '...' }
+      end
 
-    control.after do
-      @moving.delete control
+      def to_s
+        super + ": position=#{position}"
+      end
     end
-
-    control
-  end
-
-  def log(msg = nil)
-    _log msg
   end
-
-  def inspect
-    super + ": position=#{position}"
-  end
-
-  alias to_s inspect
 end
+