musa-dsl 0.22.0 → 0.22.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45dc15743b61b3ee68c878d59509dc86c7703198fbad479c60f299003ffdbb49
-  data.tar.gz: f598a8fccc84f4941652cf9f6bc186419e466c0d75cd772ff128d462b5af400a
+  metadata.gz: 77d95cd844364ae8dce08779712a34fdb0e8e349336717ffc7e49580c293b647
+  data.tar.gz: 16b7d33203bdd273acd5f235189025fa15797e7d09a1bee498151d521c0109d3
 SHA512:
-  metadata.gz: 65296b4e141478755d23425f346b80ddfe9f72ffc6bf89fd69f032a86b5f600171e5da53bc07edada254a3f790dfc5375ec1872e710eca106ab124f8f0779855
-  data.tar.gz: 86c4ad977fc506e3a21c427a5bd2ea381c5d49d7d28447cdc4154ee576a07d43baf5dbb4d14666cb4d1bd9f63a0ab311f67b7508143e651821105c9eae3bdd45
+  metadata.gz: bad2f753e7c62c93276dd5a019f57ff8eb2b5c23c38a20989e4dcc5f7a3a4365dfdd1532750da0cbb8dbe0a08c459fb02f8f62b0fd1246f1a5f8da8c755c49c5
+  data.tar.gz: a7a7e3d32b7a723c206ec098585cbbad76d2ef377ad55007a722537ef0b1070a9a43a4a18740758db82167193b55e1b524e7bb7f3bdf5251e7beba1c2effd6d5

data/lib/musa-dsl.rb

@@ -1,5 +1,5 @@
 module Musa
-  VERSION = '0.22.0'
+  VERSION = '0.22.5'
 end
 
 require_relative 'musa-dsl/core-ext'

data/lib/musa-dsl/datasets/p.rb

@@ -22,8 +22,10 @@ module Musa::Datasets
       end
     end
 
-    def to_timed_serie(time_start = nil, base_duration: nil)
+    def to_timed_serie(time_start: nil, time_start_component: nil, base_duration: nil)
       time_start ||= 0r
+      time_start += self.first[time_start_component] if time_start_component
+
       base_duration ||= 1/4r # TODO review incoherence between neumalang 1/4r base duration for quarter notes and general 1r size of bar
 
       # TODO if instead of using clone (needed because of p.shift) we use index counter the P elements would be evaluated on the last moment

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

@@ -22,8 +22,8 @@ module Musa
           indexes
         end
 
-        def to_p(time_dimension, keep_time: nil)
-          condensed_matrices.collect { |m| m.to_p(time_dimension, keep_time: keep_time) }
+        def to_p(time_dimension:, keep_time: nil)
+          condensed_matrices.collect { |m| m.to_p(time_dimension: time_dimension, keep_time: keep_time) }
         end
 
         def condensed_matrices
@@ -69,14 +69,14 @@ module Musa
       refine ::Matrix do
         include Musa::Datasets
 
-        def to_p(time_dimension, keep_time: nil)
+        def to_p(time_dimension:, keep_time: nil)
           decompose(self.to_a, time_dimension).collect do |points|
             line = []
 
             start_point = points[0]
             start_time = start_point[time_dimension]
 
-            line << start_point.tap { |_| _.delete_at(time_dimension) unless keep_time; _ }.extend(Datasets::V)
+            line << start_point.clone.tap { |_| _.delete_at(time_dimension) unless keep_time; _ }.extend(Datasets::V)
 
             (1..points.size-1).each do |i|
               end_point = points[i]
@@ -84,7 +84,7 @@ module Musa
               end_time = end_point[time_dimension]
 
               line << end_time - start_time
-              line << end_point.tap { |_| _.delete_at(time_dimension) unless keep_time; _ }.extend(Datasets::V)
+              line << end_point.clone.tap { |_| _.delete_at(time_dimension) unless keep_time; _ }.extend(Datasets::V)
 
               start_time = end_time
             end
@@ -107,8 +107,9 @@ module Musa
 
           x_dim_values_indexes.keys.sort.each do |value|
             x_dim_values_indexes[value].each do |index|
+              #
               # hacia un lado
-
+              #
               unless used_indexes.include?(index)
                 i = index
                 xx = array[i][time_dimension]
@@ -125,8 +126,9 @@ module Musa
 
                 directional_segments << a if a.size > 1
 
+                #
                 # y hacia el otro
-
+                #
                 i = index
                 xx = array[i][time_dimension]
 

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

@@ -324,8 +324,13 @@ module Musa
               run_operation eval_use_variable(element[:use_variable])
 
             when :event
-              value_parameters = element[:value_parameters] ? element[:value_parameters].collect { |e| subcontext.eval_element(e) } : []
-              key_parameters = element[:key_parameters] ? element[:key_parameters].collect { |k, e| [k, subcontext.eval_element(e)] }.to_h : {}
+              value_parameters = element[:value_parameters] ?
+                                     element[:value_parameters].collect { |e| subcontext.eval_element(e) } :
+                                     []
+
+              key_parameters = element[:key_parameters] ?
+                                   element[:key_parameters].collect { |k, e| [k, subcontext.eval_element(e)] }.to_h :
+                                   {}
 
               { current_operation: :event,
                 current_event: element[:event],

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

@@ -7,98 +7,59 @@ module Musa; module Sequencer
   class BaseSequencer
     private def _play_timed(timed_serie,
                     control,
-                    reference: nil,
-                    step: nil,
-                    right_open: nil,
                     &block)
 
-      reference ||= 0r
-      step ||= 1r
-
       if first_value_sample = timed_serie.peek_next_value
-
         debug "_play_timed: first_value_sample #{first_value_sample}"
 
         hash_mode = first_value_sample[:value].is_a?(Hash)
 
         if hash_mode
-          components = first_value_sample[:value].keys
-
-          reference = reference.hashify(keys: components)
-          step = step.hashify(keys: components)
-          right_open = right_open.hashify(keys:components)
+          component_ids = first_value_sample[:value].keys
         else
           size = first_value_sample[:value].size
-          components = (0 .. size-1).to_a
-
-          reference = reference.arrayfy(size: size)
-          step = step.arrayfy(size: size)
-          right_open = right_open.arrayfy(size: size)
-        end
-
-        split = timed_serie.flatten_timed.split
-        quantized_series = hash_mode ? {} : []
-
-        components.each do |component|
-          quantized_series[component] =
-              QUANTIZE(split[component],
-                       reference: reference[component],
-                       step: step[component],
-                       right_open: right_open[component],
-                       stops: true).instance
+          component_ids = (0 .. size-1).to_a
         end
+        extra_attribute_names = Set[*(first_value_sample.keys - [:time, :value])]
 
         last_positions = hash_mode ? {} : []
       end
 
       binder = SmartProcBinder.new(block)
 
-      _play_timed_step(hash_mode, components, quantized_series, position, last_positions, binder, control)
+      _play_timed_step(hash_mode, component_ids, extra_attribute_names, timed_serie,
+                       position, last_positions, binder, control)
     end
 
-
-    private def _play_timed_step(hash_mode, components, quantized_series, start_position, last_positions,
+    private def _play_timed_step(hash_mode,
+                                 component_ids, extra_attribute_names,
+                                 timed_serie,
+                                 start_position,
+                                 last_positions,
                                  binder, control)
 
-      affected_components_by_time = {}
-
-      components.each do |component|
-        if v = quantized_series[component].peek_next_value
+      source_next_value = timed_serie.next_value
 
-          debug "_play_timed_step: quantized_series[#{component}].peek_next_value #{v}"
-          time = v[:time]
-
-          affected_components_by_time[time] ||= []
-          affected_components_by_time[time] << component
-        end
-      end
+      affected_components = component_ids.select { |_| !source_next_value[:value][_].nil? } if source_next_value
 
-      if affected_components_by_time.any?
-        time = affected_components_by_time.keys.sort.first
+      if affected_components && affected_components.any?
+        time = source_next_value[:time]
 
         values = hash_mode ? {} : []
-        next_values = hash_mode ? {} : []
-        durations = hash_mode ? {} : []
-        q_durations = hash_mode ? {} : []
+        extra_attributes = extra_attribute_names.collect { |_| [_, hash_mode ? {} : []] }.to_h
         started_ago = hash_mode ? {} : []
 
-        affected_components_by_time[time].each do |component|
-          value = quantized_series[component].next_value
-
-          values[component] = value[:value]
-          durations[component] = value[:duration]
-
-          q_durations[component] =
-              _quantize_position(time + durations[component], warn: false) -
-              _quantize_position(time, warn: false)
+        affected_components.each do |component|
+          values[component] = source_next_value[:value][component]
 
-          nv = quantized_series[component].peek_next_value
-          next_values[component] = (nv && nv[:value] != values[component]) ? nv[:value] : nil
+          extra_attribute_names.each do |attribute_name|
+            extra_attributes[attribute_name][component] = source_next_value[attribute_name][component]
+          end
 
           last_positions[component] = _quantize_position(time, warn: false)
         end
 
-        components.each do |component|
+        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
@@ -106,82 +67,21 @@ module Musa; module Sequencer
         end
 
         _numeric_at start_position + _quantize_position(time, warn: false), control do
-          debug "_play_timed_step: before binder.call: durations #{durations} q_durations #{q_durations}"
-          binder.call(values, next_values,
-                      duration: durations,
-                      quantized_duration: q_durations,
+          binder.call(values,
+                      **extra_attributes,
                       started_ago: started_ago,
                       control: control)
 
-          _play_timed_step(hash_mode, components, quantized_series, start_position, last_positions,
+          _play_timed_step(hash_mode,
+                           component_ids, extra_attribute_names,
+                           timed_serie,
+                           start_position,
+                           last_positions,
                            binder, control)
         end
       end
     end
 
-    # TODO implement this alternative play method as another mode
-    # Este es un modo muy interesante pero que implica un procesamiento diferente en el yield_block que no me
-    # sirve para el código de samples/multidim_sample, puesto que en este el next_values es literal,
-    # mientras que samples/multidim_sample necesita que el next_value sea nil si el valor no cambia durante el periodo.
-    #
-    private def _play_timed_step_b(hash_mode, components, quantized_series, start_position, last_positions,
-                                   binder, control)
-
-      affected_components_by_time = {}
-
-      components.each do |component|
-        if v = quantized_series[component].peek_next_value
-          time = v[:time]
-
-          affected_components_by_time[time] ||= []
-          affected_components_by_time[time] << component
-        end
-      end
-
-      if !affected_components_by_time.empty?
-        time = affected_components_by_time.keys.sort.first
-
-        values = hash_mode ? {} : []
-        next_values = hash_mode ? {} : []
-        durations = hash_mode ? {} : []
-        q_durations = hash_mode ? {} : []
-        started_ago = hash_mode ? {} : []
-
-        affected_components_by_time[time].each do |component|
-          value = quantized_series[component].next_value
-
-          values[component] = value[:value]
-          durations[component] = value[:duration]
-
-          q_durations[component] =
-              _quantize_position(time + durations[component], warn: false) -
-                  _quantize_position(time, warn: false)
-
-          last_positions[component] = _quantize_position(time, warn: false)
-        end
-
-        components.each do |component|
-          nv = quantized_series[component].peek_next_value
-          next_values[component] = nv[:value] if nv
-
-          if last_positions[component] && last_positions[component] != time
-            started_ago[component] = _quantize_position(time, warn: false) - last_positions[component]
-          end
-        end
-
-        _numeric_at start_position + _quantize_position(time, warn: false), control do
-          binder.call(values, next_values,
-                      duration: durations,
-                      quantized_duration: q_durations,
-                      started_ago: started_ago,
-                      control: control)
-
-          _play_timed_step_b(hash_mode, components, quantized_series, start_position, last_positions,
-                             binder, control)
-        end
-      end
-    end
-
     class PlayTimedControl < EventHandler
       attr_reader :do_on_stop, :do_after
 

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

@@ -63,21 +63,16 @@ module Musa; module Sequencer
       nil
     end
 
-    private def _numeric_at(at_position, control, with: nil, debug: nil, &block)
+    private def _numeric_at(at_position, control, debug: nil, &block)
       raise ArgumentError, "'at_position' parameter cannot be nil" if at_position.nil?
       raise ArgumentError, 'Yield block is mandatory' unless block
 
       at_position = _quantize_position(at_position)
 
-      value_parameters = []
-      value_parameters << with if !with.nil? && !with.is_a?(Hash)
-
       block_key_parameters_binder =
           SmartProcBinder.new block, on_rescue: proc { |e| _rescue_error(e) }
 
       key_parameters = {}
-      key_parameters.merge! block_key_parameters_binder._apply(nil, with).last if with.is_a?(Hash)
-
       key_parameters[:control] = control if block_key_parameters_binder.key?(:control)
 
       if at_position == @position
@@ -85,7 +80,7 @@ module Musa; module Sequencer
 
         begin
           locked = @tick_mutex.try_lock
-          block_key_parameters_binder._call(value_parameters, key_parameters)
+          block_key_parameters_binder._call(nil, key_parameters)
         ensure
           @tick_mutex.unlock if locked
         end
@@ -100,8 +95,8 @@ module Musa; module Sequencer
           end
         end
 
-        @timeslots[at_position] << { parent_control: control, block: block_key_parameters_binder,
-                                     value_parameters: value_parameters,
+        @timeslots[at_position] << { parent_control: control,
+                                     block: block_key_parameters_binder,
                                      key_parameters: key_parameters }
       else
         @logger.warn('BaseSequencer') { "._numeric_at: ignoring past 'at' command for #{at_position}" }
@@ -110,20 +105,14 @@ module Musa; module Sequencer
       nil
     end
 
-    private def _serie_at(bar_position_serie, control, with: nil, debug: nil, &block)
-      bar_position = bar_position_serie.next_value
-
-      with_value = if with.respond_to? :next_value
-                     with.next_value
-                   else
-                     with
-                   end
+    private def _serie_at(position_or_serie, control, debug: nil, &block)
+      bar_position = position_or_serie.next_value
 
       if bar_position
-        _numeric_at bar_position, control, with: with_value, debug: debug, &block
+        _numeric_at bar_position, control, debug: debug, &block
 
         _numeric_at bar_position, control, debug: false do
-          _serie_at bar_position_serie, control, with: with, debug: debug, &block
+          _serie_at position_or_serie, control, debug: debug, &block
         end
       else
         # serie finalizada
@@ -224,8 +213,3 @@ module Musa; module Sequencer
     private_constant :EventHandler
   end
 end; end
-
-require_relative 'base-sequencer-implementation-every'
-require_relative 'base-sequencer-implementation-move'
-require_relative 'base-sequencer-implementation-play'
-require_relative 'base-sequencer-implementation-play-timed'

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

@@ -27,9 +27,7 @@ module Musa
           _release_public_ticks
         end
 
-        private
-
-        def _init_timing
+        private def _init_timing
           @ticks_per_bar = Rational(beats_per_bar * ticks_per_beat)
           @tick_duration = Rational(1, @ticks_per_bar)
 
@@ -37,11 +35,11 @@ module Musa
           @hold_ticks = 0
         end
 
-        def _reset_timing
+        private def _reset_timing
           @position = @position_mutex.synchronize { 1r - @tick_duration }
         end
 
-        def _quantize_position(position, warn: true)
+        private def _quantize_position(position, warn: true)
           ticks_position = position / @tick_duration
 
           if ticks_position.round != ticks_position
@@ -58,11 +56,11 @@ module Musa
           position
         end
 
-        def _hold_public_ticks
+        private def _hold_public_ticks
           @hold_public_ticks = true
         end
 
-        def _release_public_ticks
+        private def _release_public_ticks
           @hold_ticks.times { _tick(@position_mutex.synchronize { @position += @tick_duration }) }
           @hold_ticks = 0
           @hold_public_ticks = false

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

@@ -53,16 +53,14 @@ module Musa
           @on_fast_forward.each { |block| block.call(false) }
         end
 
-        private
-
-        def _init_timing
+        private def _init_timing
         end
 
-        def _reset_timing
+        private def _reset_timing
           @position = nil
         end
 
-        def _quantize_position(position, warn: false)
+        private def _quantize_position(position, warn: false)
           position
         end
       end