musa-dsl 0.23.11 → 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

@@ -10,8 +10,9 @@ module Musa::Sequencer
         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
 
@@ -23,17 +24,16 @@ module Musa::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
 

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

@@ -1,11 +1,11 @@
 require_relative '../core-ext/arrayfy'
 require_relative '../core-ext/inspect-nice'
 
-using Musa::Extension::Arrayfy
-using Musa::Extension::InspectNice
-
 module Musa::Sequencer
   class BaseSequencer
+    using Musa::Extension::Arrayfy
+    using Musa::Extension::InspectNice
+
     private def _move(every: nil,
                       from:, to: nil,
                       step: nil,
@@ -110,11 +110,11 @@ module Musa::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]
 
@@ -167,7 +167,7 @@ module Musa::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 = {}
@@ -300,46 +300,46 @@ module Musa::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

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

@@ -268,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
@@ -292,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,9 +1,9 @@
 require_relative '../core-ext/inspect-nice'
 
-using Musa::Extension::InspectNice
-
 module Musa::Sequencer
   class BaseSequencer
+    using Musa::Extension::InspectNice
+
     private def _play_timed(timed_serie, control, &block)
 
       if first_value_sample = timed_serie.peek_next_value

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

@@ -18,8 +18,8 @@ module Musa::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
 

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

@@ -1,9 +1,9 @@
 require_relative '../core-ext/smart-proc-binder'
 require_relative '../core-ext/inspect-nice'
 
-using Musa::Extension::InspectNice
-
 module Musa::Sequencer
+  using Musa::Extension::InspectNice
+
   class BaseSequencer
     private def _tick(position_to_run)
       @before_tick.each { |block| block.call position_to_run }

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
 

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

@@ -97,19 +97,19 @@ module Musa
       end
 
       def on_debug_at(&block)
-        @on_debug_at << SmartProcBinder.new(block)
+        @on_debug_at << Musa::Extension::SmartProcBinder::SmartProcBinder.new(block)
       end
 
       def on_error(&block)
-        @on_error << SmartProcBinder.new(block)
+        @on_error << Musa::Extension::SmartProcBinder::SmartProcBinder.new(block)
       end
 
       def on_fast_forward(&block)
-        @on_fast_forward << SmartProcBinder.new(block)
+        @on_fast_forward << Musa::Extension::SmartProcBinder::SmartProcBinder.new(block)
       end
 
       def before_tick(&block)
-        @before_tick << SmartProcBinder.new(block)
+        @before_tick << Musa::Extension::SmartProcBinder::SmartProcBinder.new(block)
       end
 
       def on(event, &block)
@@ -132,7 +132,7 @@ module Musa
           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, debug: debug, &block
+          _serie_at bars_delay.with { |delay| position + delay }, control, debug: debug, &block
         end
 
         @event_handlers.pop

data/lib/musa-dsl/series/array-to-serie.rb

@@ -1,5 +1,7 @@
 require_relative '../series'
 
+# TODO: esto sería un refinement, no?
+
 class Array
   def to_serie(of_series: nil, recursive: nil)
     of_series ||= false
@@ -8,11 +10,11 @@ class Array
     raise ArgumentError, 'Cannot convert to serie of_series and recursive simultaneously' if recursive && of_series
 
     if recursive
-      S(*(collect { |_| _.is_a?(Array) ? _.to_serie(recursive: true) : _ }))
+      Musa::Series::Constructors.S(*(collect { |_| _.is_a?(Array) ? _.to_serie(recursive: true) : _ }))
     elsif of_series
-      S(*(collect { |_| S(*_) }))
+      Musa::Series::Constructors.S(*(collect { |_| Musa::Series::Constructors.S(*_) }))
     else
-      S(*self)
+      Musa::Series::Constructors.S(*self)
     end
   end
 

data/lib/musa-dsl/series/base-series.rb

@@ -1,8 +1,6 @@
 require_relative '../core-ext/deep-copy'
 require_relative '../generative/generative-grammar'
 
-using Musa::Extension::DeepCopy
-
 module Musa
   module Series
     module Constructors; extend self; end
@@ -338,6 +336,8 @@ module Musa
         include Prototyping
         include Operations
 
+        using Musa::Extension::DeepCopy
+
         def init
           @_have_peeked_next_value = false
           @_peeked_next_value = nil

data/lib/musa-dsl/series/buffer-serie.rb

@@ -206,11 +206,6 @@ module Musa
           @index -= offset
         end
 
-        # private def _init
-        #   @source.prototype.singleton._register(self) if instance?
-        #   @index = @last_nil_index
-        # end
-        #
         private def _sources_resolved
           @source.singleton._register(self) if instance?
           @index = @last_nil_index

data/lib/musa-dsl/series/main-serie-constructors.rb

@@ -3,13 +3,12 @@ require_relative '../core-ext/smart-proc-binder'
 
 require_relative 'base-series'
 
-using Musa::Extension::Arrayfy
-using Musa::Extension::ExplodeRanges
-
 # TODO: añadir en for: steps: (nº de pasos en los que repartir el incremento)
 
 module Musa
   module Series::Constructors
+    using Musa::Extension::ExplodeRanges
+
     def UNDEFINED
       UndefinedSerie.new
     end
@@ -119,7 +118,8 @@ module Musa
       end
     end
 
-    private_constant :UndefinedSerie
+    # UndefinedSerie is not private because is used in Composer
+    # private_constant :UndefinedSerie
 
     class NilSerie
       include Series::Serie.base
@@ -136,6 +136,8 @@ module Musa
     class FromArray
       include Series::Serie.base
 
+      using Musa::Extension::Arrayfy
+
       def initialize(values = nil, extends = nil)
         @values = values
         mark_as_prototype!

data/lib/musa-dsl/series/main-serie-operations.rb

@@ -84,11 +84,11 @@ module Musa
       end
 
       def after(*series)
-        Sequence.new [self, *series]
+        Musa::Series::Constructors.MERGE self, *series
       end
 
       def +(other)
-        Sequence.new [self, other]
+        Musa::Series::Constructors.MERGE self, other
       end
 
       def cut(length)

data/lib/musa-dsl/series/quantizer-serie.rb

@@ -4,8 +4,6 @@ require_relative '../core-ext/inspect-nice'
 require_relative 'base-series'
 
 # TODO remove debugging puts, intermediate hash comments on :info and InspectNice
-using Musa::Extension::InspectNice
-
 module Musa
   module Series::Operations
     def quantize(reference: nil, step: nil,
@@ -70,7 +68,7 @@ module Musa
           time = n[0].rationalize
           value = n[1].rationalize
         else
-          raise RuntimeError, "Don't know how to process #{n}"
+          raise "Don't know how to process #{n}"
         end
 
         return time, value
@@ -115,9 +113,8 @@ module Musa
       end
 
       private def _next_value
+        i = 2
         if @stops
-          i = 2
-
           loop do
             while @segments.size < i && process2; end
 
@@ -142,17 +139,16 @@ module Musa
               return { time: first[:time],
                        @value_attribute => first[:value],
                        duration: durations_to_sum.sum { |_| _[:duration] } }
-                         .extend(Musa::Datasets::AbsTimed)
-                         .extend(Musa::Datasets::AbsD)
+                     .extend(Musa::Datasets::AbsTimed)
+                     .extend(Musa::Datasets::AbsD)
             else
               i += 1
             end
           end
 
-          return nil
+          nil
 
         else
-          i = 2
           # puts "\n\n"
           loop do
             while @segments.size < i && process2; end
@@ -179,8 +175,8 @@ module Musa
               return { time: first[:time],
                        @value_attribute => first[:value],
                        duration: durations_to_sum.sum { |_| _[:duration] } }
-                         .extend(Musa::Datasets::AbsTimed)
-                         .extend(Musa::Datasets::AbsD)
+                     .extend(Musa::Datasets::AbsTimed)
+                     .extend(Musa::Datasets::AbsD)
             else
               i += 1
             end
@@ -211,7 +207,7 @@ module Musa
 
           # puts "process2: from_time #{from_time} from_value #{from_value} to_time #{to_time} to_value #{to_value} to_last #{to_point_is_last || 'nil'} sign #{sign}"
 
-          if sign == 0
+          if sign.zero?
             if @segments.last && @segments.last[:time] == from_time
 
               @segments.last[:duration] = to_time - from_time
@@ -261,8 +257,8 @@ module Musa
 
             loop_from_value.step(loop_to_value, step_value_increment) do |value|
               if @segments.last &&
-                @segments.last[:time] == intermediate_point_time &&
-                @segments.last[:value] == value
+                 @segments.last[:time] == intermediate_point_time &&
+                 @segments.last[:value] == value
 
                 @segments.last[:duration] = step_time_increment
                 @segments.last[:info] += '; edited on b'
@@ -294,7 +290,7 @@ module Musa
 
       private def process(time, value, last_time_value)
         if time && value
-          raise RuntimeError, 'time only can go forward' if @last_processed_time && time <= @last_processed_time
+          raise 'time only can go forward' if @last_processed_time && time <= @last_processed_time
 
           q_value = round_quantize(value)
 
@@ -399,23 +395,23 @@ module Musa
           if @first
             @first = false
 
-            if time > first_time
-              result = { time: first_time,
+            result = if time > first_time
+                       { time: first_time,
                          @value_attribute => round_to_nearest_quantize(first_value, value),
                          duration: time - first_time }
-                           .extend(Musa::Datasets::AbsD)
-                           .extend(Musa::Datasets::AbsTimed)
-            else
-              result = _next_value
-            end
+                         .extend(Musa::Datasets::AbsD)
+                         .extend(Musa::Datasets::AbsTimed)
+                     else
+                       _next_value
+                     end
           else
             if @crossings[1]
               next_time = @crossings[1][:time]
               result = { time: time,
                          @value_attribute => value,
                          duration: next_time - time }
-                           .extend(Musa::Datasets::AbsD)
-                           .extend(Musa::Datasets::AbsTimed)
+                       .extend(Musa::Datasets::AbsD)
+                       .extend(Musa::Datasets::AbsTimed)
 
               @crossings.shift
 
@@ -424,8 +420,8 @@ module Musa
                 result = { time: @crossings[0][:time],
                            @value_attribute => @crossings[0][@value_attribute],
                            duration: @last_time - @crossings[0][:time] }
-                             .extend(Musa::Datasets::AbsD)
-                             .extend(Musa::Datasets::AbsTimed)
+                         .extend(Musa::Datasets::AbsD)
+                         .extend(Musa::Datasets::AbsTimed)
 
                 @last_time = nil
               end
@@ -436,8 +432,8 @@ module Musa
             result = { time: first_time,
                        value: round_to_nearest_quantize(first_value),
                        duration: @last_time - first_time }
-                         .extend(Musa::Datasets::AbsD)
-                         .extend(Musa::Datasets::AbsTimed)
+                     .extend(Musa::Datasets::AbsD)
+                     .extend(Musa::Datasets::AbsTimed)
 
             @first = false
             @last_time = false
@@ -453,8 +449,8 @@ module Musa
             if @last_time.nil? || c[:time] > @last_time
 
               if c[:stop] &&
-                  @crossings.dig(-1, :stop) &&
-                  @crossings.dig(-1, @value_attribute) == c[@value_attribute]
+                 @crossings.dig(-1, :stop) &&
+                 @crossings.dig(-1, @value_attribute) == c[@value_attribute]
 
                 c[:stops] = (@crossings[-1][:stops] || 0) + 1
 
@@ -473,7 +469,7 @@ module Musa
         from_time, from_value = get_time_value(@source.next_value)
 
         if from_time && from_value
-          raise RuntimeError, "time only can go forward" if @last_time && from_time <= @last_time
+          raise 'time only can go forward' if @last_time && from_time <= @last_time
 
           @last_time = from_time
 
@@ -500,36 +496,36 @@ module Musa
         delta_time = to_time - from_time
 
         crossings =
-            from_step.step(last_step, sign).collect do |i|
-              value = @crossing_reference + i * @step_size
+          from_step.step(last_step, sign).collect do |i|
+            value = @crossing_reference + i * @step_size
 
-              { time: from_time + (delta_time / delta_value) * (value - from_value),
-                @value_attribute => value + sign * @halfway_offset }
-            end
+            { time: from_time + (delta_time / delta_value) * (value - from_value),
+              @value_attribute => value + sign * @halfway_offset }
+          end
 
         if @include_stops
           first_crossing_time = crossings.dig(0, :time)
           last_crossing_time = crossings.dig(-1, :time)
 
-          if first_crossing_time.nil? || from_time < first_crossing_time
-            stop_before = [ { time: from_time,
+          stop_before = if first_crossing_time.nil? || from_time < first_crossing_time
+                          [ { time: from_time,
                               @value_attribute =>
-                                  round_to_nearest_quantize(from_value,
-                                                            crossings.dig(0, @value_attribute)),
+                                                round_to_nearest_quantize(from_value,
+                                                                          crossings.dig(0, @value_attribute)),
                               stop: true } ]
-          else
-            stop_before = []
-          end
+                        else
+                          []
+                        end
 
-          if last_crossing_time.nil? || to_time > last_crossing_time
-            stop_after = [ { time: to_time,
+          stop_after = if last_crossing_time.nil? || to_time > last_crossing_time
+                         [ { time: to_time,
                              @value_attribute =>
-                                 round_to_nearest_quantize(to_value,
-                                                           crossings.dig(-1, @value_attribute)),
+                                              round_to_nearest_quantize(to_value,
+                                                                        crossings.dig(-1, @value_attribute)),
                              stop: true } ]
-          else
-            stop_after = []
-          end
+                       else
+                         []
+                       end
 
           stop_before + crossings + stop_after
         else