musa-dsl 0.23.8 → 0.23.13

data/lib/musa-dsl/neumas/array-to-neumas.rb

@@ -7,7 +7,7 @@ module Musa
       refine Array do
         def to_neumas
           if length > 1
-            MERGE(*collect { |e| convert_to_neumas(e) })
+            Musa::Series::Constructors.MERGE(*collect { |e| convert_to_neumas(e) })
           else
             convert_to_neumas(first)
           end
@@ -21,7 +21,7 @@ module Musa
         def convert_to_neumas(e)
           case e
           when Musa::Neumas::Neuma::Serie then e
-          when Musa::Neumas::Neuma::Parallel then S(e).extend(Musa::Neumas::Neuma::Serie)
+          when Musa::Neumas::Neuma::Parallel then Musa::Series::Constructors.S(e).extend(Musa::Neumas::Neuma::Serie)
           when String then e.to_neumas
           else
             raise ArgumentError, "Don't know how to convert to neumas #{e}"

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

@@ -13,7 +13,7 @@ module Musa
         @block_source = nil
 
         if binder.receiver.respond_to?(:sequencer) &&
-            binder.receiver.sequencer.respond_to?(:on_error)
+           binder.receiver.sequencer.respond_to?(:on_error)
 
           binder.receiver.sequencer.on_error do |e|
             send_exception e, output: @connection

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

@@ -1,16 +1,18 @@
-module Musa; module Sequencer
+module Musa::Sequencer
   class BaseSequencer
     private def _every(interval, control, block_procedure_binder: nil, &block)
       block ||= proc {}
 
-      block_procedure_binder ||= SmartProcBinder.new block, on_rescue: proc { |e| _rescue_error(e) }
+      block_procedure_binder ||=
+        Musa::Extension::SmartProcBinder::SmartProcBinder.new block, on_rescue: proc { |e| _rescue_error(e) }
 
       _numeric_at position, control do
         control._start_position ||= position
         control._execution_counter ||= 0
 
-        duration_exceeded =
-            (control._start_position + control.duration_value - interval) <= position if interval && control.duration_value
+        if interval && control.duration_value
+          duration_exceeded = (control._start_position + control.duration_value - interval) <= position
+        end
 
         till_exceeded = control.till_value - interval <= position if interval && control.till_value
 
@@ -22,17 +24,16 @@ module Musa; module Sequencer
         end
 
 
-        unless control.stopped? || duration_exceeded || till_exceeded || condition_failed || interval.nil?
-          _numeric_at control._start_position + control._execution_counter * interval, control do
-            _every interval, control, block_procedure_binder: block_procedure_binder
-          end
-
-        else
+        if control.stopped? || duration_exceeded || till_exceeded || condition_failed || interval.nil?
           control.do_on_stop.each(&:call)
 
           control.do_after.each do |do_after|
             _numeric_at position + (interval || 0) + do_after[:bars], control, &do_after[:block]
           end
+        else
+          _numeric_at control._start_position + control._execution_counter * interval, control do
+            _every interval, control, block_procedure_binder: block_procedure_binder
+          end
         end
       end
 
@@ -84,4 +85,4 @@ module Musa; module Sequencer
 
     private_constant :EveryControl
   end
-end; end
+end

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

@@ -1,10 +1,11 @@
-using Musa::Extension::Hashify
-using Musa::Extension::Arrayfy
+require_relative '../core-ext/arrayfy'
+require_relative '../core-ext/inspect-nice'
 
-using Musa::Extension::InspectNice
-
-module Musa; module Sequencer
+module Musa::Sequencer
   class BaseSequencer
+    using Musa::Extension::Arrayfy
+    using Musa::Extension::InspectNice
+
     private def _move(every: nil,
                       from:, to: nil,
                       step: nil,
@@ -109,11 +110,11 @@ module Musa; module Sequencer
             steps = (to[i] - from[i]) / step[i]
 
             # When to == from don't need to do any iteration with every
-            if steps + right_open_offset[i] > 0
-              every[i] = Rational(effective_duration, steps + right_open_offset[i])
-            else
-              every[i] = nil
-            end
+            every[i] = if steps + right_open_offset[i] > 0
+                         Rational(effective_duration, steps + right_open_offset[i])
+                       else
+                         nil
+                       end
 
           elsif to[i] && !step[i] && !every[i]
 
@@ -166,7 +167,7 @@ module Musa; module Sequencer
       #
       # Prepare yield block, parameters to yield block and coincident moving interval groups
       #
-      binder = SmartProcBinder.new(block)
+      binder = Musa::Extension::SmartProcBinder::SmartProcBinder.new(block)
 
       every_groups = {}
       group_counter = {}
@@ -299,46 +300,46 @@ module Musa; module Sequencer
             # Adapt values to array/hash/value mode
             #
             value_parameters, key_parameters =
-                if array_mode
-                  binder.apply(effective_values, effective_next_values,
-                               control: control,
-                               duration: _durations(every_groups, effective_duration),
-                               quantized_duration: q_durations.dup,
-                               started_ago: _started_ago(last_position, position, process_indexes),
-                               position_jitter: position_jitters.dup,
-                               duration_jitter: duration_jitters.dup,
-                               right_open: right_open.dup)
-                elsif hash_mode
-                  binder.apply(_hash_from_keys_and_values(hash_keys, effective_values),
-                               _hash_from_keys_and_values(hash_keys, effective_next_values),
-                               control: control,
-                               duration: _hash_from_keys_and_values(
-                                   hash_keys,
-                                   _durations(every_groups, effective_duration)),
-                               quantized_duration: _hash_from_keys_and_values(
-                                   hash_keys,
-                                   q_durations),
-                               started_ago: _hash_from_keys_and_values(
-                                   hash_keys,
-                                   _started_ago(last_position, position, process_indexes)),
-                               position_jitter: _hash_from_keys_and_values(
-                                   hash_keys,
-                                   position_jitters),
-                               duration_jitter: _hash_from_keys_and_values(
-                                   hash_keys,
-                                   duration_jitters),
-                               right_open: _hash_from_keys_and_values(hash_keys, right_open))
-                else
-                  binder.apply(effective_values.first,
-                               effective_next_values.first,
-                               control: control,
-                               duration: _durations(every_groups, effective_duration).first,
-                               quantized_duration: q_durations.first,
-                               position_jitter: position_jitters.first,
-                               duration_jitter: duration_jitters.first,
-                               started_ago: nil,
-                               right_open: right_open.first)
-                end
+              if array_mode
+                binder.apply(effective_values, effective_next_values,
+                             control: control,
+                             duration: _durations(every_groups, effective_duration),
+                             quantized_duration: q_durations.dup,
+                             started_ago: _started_ago(last_position, position, process_indexes),
+                             position_jitter: position_jitters.dup,
+                             duration_jitter: duration_jitters.dup,
+                             right_open: right_open.dup)
+              elsif hash_mode
+                binder.apply(_hash_from_keys_and_values(hash_keys, effective_values),
+                             _hash_from_keys_and_values(hash_keys, effective_next_values),
+                             control: control,
+                             duration: _hash_from_keys_and_values(
+                                 hash_keys,
+                                 _durations(every_groups, effective_duration)),
+                             quantized_duration: _hash_from_keys_and_values(
+                                 hash_keys,
+                                 q_durations),
+                             started_ago: _hash_from_keys_and_values(
+                                 hash_keys,
+                                 _started_ago(last_position, position, process_indexes)),
+                             position_jitter: _hash_from_keys_and_values(
+                                 hash_keys,
+                                 position_jitters),
+                             duration_jitter: _hash_from_keys_and_values(
+                                 hash_keys,
+                                 duration_jitters),
+                             right_open: _hash_from_keys_and_values(hash_keys, right_open))
+              else
+                binder.apply(effective_values.first,
+                             effective_next_values.first,
+                             control: control,
+                             duration: _durations(every_groups, effective_duration).first,
+                             quantized_duration: q_durations.first,
+                             position_jitter: position_jitters.first,
+                             duration_jitter: duration_jitters.first,
+                             started_ago: nil,
+                             right_open: right_open.first)
+              end
 
             #
             # Do the REAL thing
@@ -436,4 +437,4 @@ module Musa; module Sequencer
 
     private_constant :MoveControl
   end
-end; end
+end

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

@@ -1,5 +1,3 @@
-using Musa::Extension::DeepCopy
-
 module Musa
   module Sequencer
     class BaseSequencer
@@ -270,7 +268,7 @@ module Musa
 
           when Array
             { current_operation: :no_eval_play,
-              current_parameter: S(*element) }
+              current_parameter: Musa::Series::Constructors.S(*element) }
           else
             case element[:kind]
             when :value
@@ -294,7 +292,7 @@ module Musa
 
               if _value.is_a?(Array)
                 { current_operation: :no_eval_play,
-                  current_parameter: S(*_value) }
+                  current_parameter: Musa::Series::Constructors.S(*_value) }
               else
                 { current_operation: :block,
                   current_parameter: _value,

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

@@ -1,13 +1,10 @@
-using Musa::Extension::Hashify
-using Musa::Extension::Arrayfy
+require_relative '../core-ext/inspect-nice'
 
-using Musa::Extension::InspectNice
-
-module Musa; module Sequencer
+module Musa::Sequencer
   class BaseSequencer
-    private def _play_timed(timed_serie,
-                    control,
-                    &block)
+    using Musa::Extension::InspectNice
+
+    private def _play_timed(timed_serie, control, &block)
 
       if first_value_sample = timed_serie.peek_next_value
         debug "_play_timed: first_value_sample #{first_value_sample}"
@@ -25,7 +22,7 @@ module Musa; module Sequencer
         last_positions = hash_mode ? {} : []
       end
 
-      binder = SmartProcBinder.new(block)
+      binder = Musa::Extension::SmartProcBinder::SmartProcBinder.new(block)
 
       _play_timed_step(hash_mode, component_ids, extra_attribute_names, timed_serie,
                        position, last_positions, binder, control)
@@ -40,45 +37,52 @@ module Musa; module Sequencer
 
       source_next_value = timed_serie.next_value
 
-      affected_components = component_ids.select { |_| !source_next_value[:value][_].nil? } if source_next_value
+      if source_next_value
+        affected_components = component_ids.select { |_| !source_next_value[:value][_].nil? }
+
+        if affected_components&.any?
+          time = source_next_value[:time]
 
-      if affected_components && affected_components.any?
-        time = source_next_value[:time]
+          values = hash_mode ? {} : []
+          extra_attributes = extra_attribute_names.collect { |_| [_, hash_mode ? {} : []] }.to_h
+          started_ago = hash_mode ? {} : []
 
-        values = hash_mode ? {} : []
-        extra_attributes = extra_attribute_names.collect { |_| [_, hash_mode ? {} : []] }.to_h
-        started_ago = hash_mode ? {} : []
+          affected_components.each do |component|
+            values[component] = source_next_value[:value][component]
 
-        affected_components.each do |component|
-          values[component] = source_next_value[:value][component]
+            extra_attribute_names.each do |attribute_name|
+              extra_attributes[attribute_name][component] = source_next_value[attribute_name][component]
+            end
 
-          extra_attribute_names.each do |attribute_name|
-            extra_attributes[attribute_name][component] = source_next_value[attribute_name][component]
+            last_positions[component] = _quantize_position(time, warn: false)
           end
 
-          last_positions[component] = _quantize_position(time, warn: false)
-        end
+          component_ids.each do |component|
+            if last_positions[component] && last_positions[component] != time
+              sa = _quantize_position(time, warn: false) - last_positions[component]
+              started_ago[component] = (sa == 0) ? nil : sa
+            end
+          end
 
-        component_ids.each do |component|
-          if last_positions[component] && last_positions[component] != time
-            sa = _quantize_position(time, warn: false) - last_positions[component]
-            started_ago[component] = (sa == 0) ? nil : sa
+          _numeric_at _quantize_position(start_position + time, warn: true), control do
+            binder.call(values,
+                        **extra_attributes,
+                        time: start_position + time,
+                        started_ago: started_ago,
+                        control: control)
+
+            _play_timed_step(hash_mode,
+                             component_ids, extra_attribute_names,
+                             timed_serie,
+                             start_position,
+                             last_positions,
+                             binder, control)
           end
         end
+      else
 
-        _numeric_at _quantize_position(start_position + time, warn: true), control do
-          binder.call(values,
-                      **extra_attributes,
-                      time: start_position + time,
-                      started_ago: started_ago,
-                      control: control)
-
-          _play_timed_step(hash_mode,
-                           component_ids, extra_attribute_names,
-                           timed_serie,
-                           start_position,
-                           last_positions,
-                           binder, control)
+        control.do_after.each do |do_after|
+          _numeric_at position + do_after[:bars], control, &do_after[:block]
         end
       end
     end
@@ -107,5 +111,5 @@ module Musa; module Sequencer
 
     private_constant :PlayTimedControl
   end
-end; end
+end
 

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

@@ -1,11 +1,9 @@
+require_relative '../core-ext/inspect-nice'
 require_relative 'base-sequencer-implementation-play-helper'
 
-using Musa::Extension::Hashify
-using Musa::Extension::Arrayfy
-
 using Musa::Extension::InspectNice
 
-module Musa; module Sequencer
+module Musa::Sequencer
   class BaseSequencer
     private def _play(serie,
                       control,
@@ -20,8 +18,8 @@ module Musa; module Sequencer
 
       __play_eval ||= PlayEval.create \
           mode,
-          SmartProcBinder.new(block,
-                              on_rescue: proc { |e| _rescue_error(e) }),
+          Musa::Extension::SmartProcBinder::SmartProcBinder.new(block,
+                                                                on_rescue: proc { |e| _rescue_error(e) }),
           decoder,
           neumalang_context
 
@@ -175,4 +173,4 @@ module Musa; module Sequencer
 
     private_constant :PlayControl
   end
-end; end
+end

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

@@ -1,16 +1,10 @@
-require_relative '../core-ext/arrayfy'
 require_relative '../core-ext/smart-proc-binder'
+require_relative '../core-ext/inspect-nice'
 
-using Musa::Extension::Arrayfy
-using Musa::Extension::DeepCopy
+module Musa::Sequencer
+  using Musa::Extension::InspectNice
 
-module Musa; module Sequencer
   class BaseSequencer
-    include Musa::Extension::SmartProcBinder
-    include Musa::Extension::DeepCopy
-
-    using Musa::Extension::InspectNice
-
     private def _tick(position_to_run)
       @before_tick.each { |block| block.call position_to_run }
       queue = @timeslots[position_to_run]
@@ -72,7 +66,7 @@ module Musa; module Sequencer
       at_position = _quantize_position(at_position)
 
       block_key_parameters_binder =
-          SmartProcBinder.new block, on_rescue: proc { |e| _rescue_error(e) }
+        Musa::Extension::SmartProcBinder::SmartProcBinder.new block, on_rescue: proc { |e| _rescue_error(e) }
 
       key_parameters = {}
       key_parameters[:control] = control if block_key_parameters_binder.key?(:control)
@@ -133,8 +127,6 @@ module Musa; module Sequencer
     end
 
     class EventHandler
-      include Musa::Extension::SmartProcBinder
-
       attr_accessor :continue_parameters
 
       @@counter = 0
@@ -174,7 +166,7 @@ module Musa; module Sequencer
         @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 }
+        @handlers[event][name] = { block: Musa::Extension::SmartProcBinder::SmartProcBinder.new(block), only_once: only_once }
       end
 
       def launch(event, *value_parameters, **key_parameters)
@@ -214,4 +206,4 @@ module Musa; module Sequencer
 
     private_constant :EventHandler
   end
-end; end
+end

data/lib/musa-dsl/sequencer/base-sequencer-tick-based.rb

@@ -2,7 +2,6 @@ module Musa
   module Sequencer
     class BaseSequencer
       module TickBasedTiming
-
         using Musa::Extension::InspectNice
 
         attr_reader :position, :ticks_per_bar, :tick_duration
@@ -49,9 +48,11 @@ module Musa
             position = ticks_position.round * @tick_duration
 
             if warn
-              @logger.warn('BaseSequencer') { "_check_position: rounding "\
+              @logger.warn('BaseSequencer') do
+                '_check_position: rounding ' \
                   "position #{original_position.inspect} (#{original_position.to_f.round(5)}) "\
-                  "to tick precision: #{position.inspect} (#{position.to_f.round(5)})" }
+                  "to tick precision: #{position.inspect} (#{position.to_f.round(5)})"
+              end
             end
           end