musa-dsl 0.23.8 → 0.23.13

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/sequencer/sequencer-dsl.rb

@@ -18,7 +18,7 @@ module Musa
                      :event_handler
 
       def_delegators :@dsl, :position, :quantize_position, :logger, :debug
-      def_delegators :@dsl, :with, :now, :at, :wait, :play, :play_timed, :every, :move
+      def_delegators :@dsl, :now, :at, :wait, :play, :play_timed, :every, :move
       def_delegators :@dsl, :everying, :playing, :moving
       def_delegators :@dsl, :launch, :on
       def_delegators :@dsl, :run
@@ -28,6 +28,7 @@ module Musa
                      sequencer: nil,
                      logger: nil,
                      do_log: nil, do_error_log: nil, log_position_format: nil,
+                     keep_proc_context: nil,
                      &block)
 
         @sequencer = sequencer
@@ -37,14 +38,17 @@ module Musa
                                          do_error_log: do_error_log,
                                          log_position_format: log_position_format
 
-        @dsl = DSLContext.new @sequencer
+        @dsl = DSLContext.new @sequencer, keep_proc_context: keep_proc_context
 
-        with &block if block_given?
+        @dsl.with &block if block_given?
+      end
+
+      def with(&block)
+        @dsl.with &block
       end
 
       class DSLContext
         extend Forwardable
-        include Musa::Extension::SmartProcBinder
         include Musa::Extension::With
 
         attr_reader :sequencer
@@ -57,8 +61,9 @@ module Musa
                        :ticks_per_bar, :logger, :debug, :inspect,
                        :run
 
-        def initialize(sequencer)
+        def initialize(sequencer, keep_proc_context:)
           @sequencer = sequencer
+          @keep_proc_context_on_with = keep_proc_context
         end
 
         def now(*value_parameters, **key_parameters, &block)
@@ -104,7 +109,7 @@ module Musa
           block ||= proc {}
 
           @sequencer.every *value_parameters, **key_parameters do |*value_args, **key_args|
-            args = SmartProcBinder.new(block)._apply(value_args, key_args)
+            args = Musa::Extension::SmartProcBinder::SmartProcBinder.new(block)._apply(value_args, key_args)
             with *args.first, **args.last, &block
           end
         end

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
@@ -48,10 +47,14 @@ module Musa
       ForLoop.new from, to, step
     end
 
-    def RND(*values, from: nil, to: nil, step: nil, random: nil)
+    def RND(*_values, values: nil, from: nil, to: nil, step: nil, random: nil)
+      raise ArgumentError, "Can't use both direct values #{_values} and values named parameter #{values} at the same time." if values && !_values.empty?
+
       random = Random.new random if random.is_a?(Integer)
       random ||= Random.new
 
+      values ||= _values
+
       if !values.empty? && from.nil? && to.nil? && step.nil?
         RandomValuesFromArray.new values.explode_ranges, random
       elsif values.empty? && !to.nil?
@@ -67,10 +70,14 @@ module Musa
       Sequence.new(series)
     end
 
-    def RND1(*values, from: nil, to: nil, step: nil, random: nil)
+    def RND1(*_values, values: nil, from: nil, to: nil, step: nil, random: nil)
+      raise ArgumentError, "Can't use both direct values #{_values} and values named parameter #{values} at the same time." if values && !_values.empty?
+
       random = Random.new random if random.is_a?(Integer)
       random ||= Random.new
 
+      values ||= _values
+
       if !values.empty? && from.nil? && to.nil? && step.nil?
         RandomValueFromArray.new values.explode_ranges, random
       elsif values.empty? && !to.nil?
@@ -111,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
@@ -128,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,
@@ -15,7 +13,7 @@ module Musa
                  left_open: nil,
                  right_open: nil)
 
-      Series.QUANTIZE(self,
+      Series::Constructors.QUANTIZE(self,
                       reference: reference,
                       step: step,
                       value_attribute: value_attribute,
@@ -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