musa-dsl 0.22.4 → 0.22.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe8d0a64e4ba5518c7ed0fe4b75fffbf059217ef65e83025889a21d1c830a6e7
-  data.tar.gz: a78c43004243d81a9411c42e34338ecfe4ca7ef17322417dc2e8eb9a953b9abd
+  metadata.gz: 77d95cd844364ae8dce08779712a34fdb0e8e349336717ffc7e49580c293b647
+  data.tar.gz: 16b7d33203bdd273acd5f235189025fa15797e7d09a1bee498151d521c0109d3
 SHA512:
-  metadata.gz: 6bf51f55471c9a753ec648cb1c223ef0564307d2807ec0c569a144856ef330ca7567e8ed4f8f0f651e1808ea42712c02c686ac123424d0feaa90955e2f6d77fe
-  data.tar.gz: 2bd503000a0d7cd2bd0e74f9790cbf5533335bc7d74cc6846cb60ea3bad4f1fd3fb24e74ed0bd1c6955b476d45274f51047202c89e12582e5fd642753d34144e
+  metadata.gz: bad2f753e7c62c93276dd5a019f57ff8eb2b5c23c38a20989e4dcc5f7a3a4365dfdd1532750da0cbb8dbe0a08c459fb02f8f62b0fd1246f1a5f8da8c755c49c5
+  data.tar.gz: a7a7e3d32b7a723c206ec098585cbbad76d2ef377ad55007a722537ef0b1070a9a43a4a18740758db82167193b55e1b524e7bb7f3bdf5251e7beba1c2effd6d5

data/lib/musa-dsl.rb

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

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,107 +7,59 @@ module Musa; module Sequencer
   class BaseSequencer
     private def _play_timed(timed_serie,
                     control,
-                    reference: nil,
-                    step: nil,
-                    predictive: nil,
-                    right_open: nil,
-                    stops: nil,
                     &block)
 
-      reference ||= 0r
-      step ||= 1r
-      predictive ||= predictive
-      stops = stops.nil? ? true : stops
-
       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)
-          predictive = predictive.hashify(keys:components)
-          stops = stops.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)
-          predictive = predictive.arrayfy(size: size)
-          stops = stops.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],
-                       predictive: predictive[component],
-                       right_open: right_open[component],
-                       stops: stops[component]).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
-
-          debug "_play_timed_step: quantized_series[#{component}].peek_next_value #{v}"
-          time = v[:time]
+      source_next_value = timed_serie.next_value
 
-          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
+        affected_components.each do |component|
+          values[component] = source_next_value[:value][component]
 
-          values[component] = value[:value]
-          durations[component] = value[:duration]
-
-          q_durations[component] =
-              _quantize_position(time + durations[component], warn: false) -
-              _quantize_position(time, warn: false)
-
-          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
@@ -115,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

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

@@ -83,6 +83,11 @@ module Musa
         @timeslots.empty?
       end
 
+      def quantize_position(position, warn: nil)
+        warn ||= false
+        _quantize_position(position, warn: warn)
+      end
+
       def run
         tick until empty?
       end
@@ -115,22 +120,19 @@ module Musa
         @event_handlers.last.launch event, *value_parameters, **key_parameters
       end
 
-      def wait(bars_delay, with: nil, debug: nil, &block)
+      def wait(bars_delay, debug: nil, &block)
         debug ||= false
 
         control = EventHandler.new @event_handlers.last
         @event_handlers.push control
 
         if bars_delay.is_a? Numeric
-          _numeric_at position + bars_delay.rationalize, control, with: with, debug: debug, &block
+          _numeric_at position + bars_delay.rationalize, control, debug: debug, &block
         else
           bars_delay = Series::S(*bars_delay) if bars_delay.is_a?(Array)
           bars_delay = bars_delay.instance if bars_delay
 
-          with = Series::S(*with).repeat if with.is_a?(Array)
-          with = with.instance if with
-
-          _serie_at bars_delay.eval { |delay| position + delay }, control, with: with, debug: debug, &block
+          _serie_at bars_delay.eval { |delay| position + delay }, control, debug: debug, &block
         end
 
         @event_handlers.pop
@@ -138,11 +140,11 @@ module Musa
         control
       end
 
-      def now(with: nil, &block)
+      def now(&block)
         control = EventHandler.new @event_handlers.last
         @event_handlers.push control
 
-        _numeric_at position, control, with: with, &block
+        _numeric_at position, control, &block
 
         @event_handlers.pop
 
@@ -155,22 +157,19 @@ module Musa
         nil
       end
 
-      def at(bar_position, with: nil, debug: nil, &block)
+      def at(bar_position, debug: nil, &block)
         debug ||= false
 
         control = EventHandler.new @event_handlers.last
         @event_handlers.push control
 
         if bar_position.is_a? Numeric
-          _numeric_at bar_position.rationalize, control, with: with, debug: debug, &block
+          _numeric_at bar_position.rationalize, control, debug: debug, &block
         else
           bar_position = Series::S(*bar_position) if bar_position.is_a? Array
           bar_position = bar_position.instance if bar_position
 
-          with = Series::S(*with).repeat if with.is_a? Array
-          with = with.instance if with
-
-          _serie_at bar_position, control, with: with, debug: debug, &block
+          _serie_at bar_position, control, debug: debug, &block
         end
 
         @event_handlers.pop
@@ -216,11 +215,6 @@ module Musa
       end
 
       def play_timed(timed_serie,
-                     reference: nil,
-                     step: nil,
-                     predictive: nil,
-                     stops: nil,
-                     right_open: nil,
                      on_stop: nil,
                      after_bars: nil, after: nil,
                      &block)
@@ -236,14 +230,7 @@ module Musa
 
         @event_handlers.push control
 
-        _play_timed(timed_serie.instance,
-                    control,
-                    reference: reference,
-                    step: step,
-                    predictive: predictive,
-                    stops: stops,
-                    right_open: right_open,
-                    &block)
+        _play_timed(timed_serie.instance, control, &block)
 
         @event_handlers.pop
 

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

@@ -17,7 +17,7 @@ module Musa
                      :position=,
                      :event_handler
 
-      def_delegators :@context, :position, :logger, :debug
+      def_delegators :@context, :position, :quantize_position, :logger, :debug
       def_delegators :@context, :with, :now, :at, :wait, :play, :play_timed, :every, :move
       def_delegators :@context, :everying, :playing, :moving
       def_delegators :@context, :launch, :on
@@ -51,7 +51,9 @@ module Musa
 
         def_delegators :@sequencer,
                        :launch, :on,
-                       :position, :size, :everying, :playing, :moving,
+                       :position, :quantize_position,
+                       :size,
+                       :everying, :playing, :moving,
                        :ticks_per_bar, :logger, :debug, :inspect,
                        :run
 

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

@@ -1,3 +1,10 @@
 require_relative 'base-sequencer'
+
 require_relative 'base-sequencer-implementation'
+
+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'
+
 require_relative 'sequencer-dsl'

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

@@ -30,7 +30,7 @@ module Musa
         if @is_instance
           self
         else
-          clone(freeze: false).tap(&:_instance!).mark_as_instance!(self)
+          clone(freeze: false).tap(&:_instance!).mark_as_instance!(self).tap(&:restart)
         end
       end
 
@@ -40,7 +40,7 @@ module Musa
       # handle prototyping/instancing automatically.
       # If there is a @sources attribute with the eventual several sources, SeriePrototyping will handle them by
       # default.
-      # If needed the subclasses can override this behaviour to accomodate to real subclass specificities.
+      # If needed the subclasses can override this behaviour to accommodate to real subclass specificities.
       #
       protected def _prototype!
         @source = @source.prototype if @source

data/lib/musa-dsl/series/hash-or-array-serie-splitter.rb

@@ -45,6 +45,22 @@ module Musa
           end
         end
 
+        def to_hash
+          if @proxy.hash_mode?
+            @proxy.components.collect { |key| [key, self[key]] }.to_h
+          else
+            raise RuntimeError, 'Splitter is not based on Hash: can\'t convert to Hash'
+          end
+        end
+
+        def to_array
+          if @proxy.array_mode?
+            [].tap { |_| @proxy.components.each { |i| _[i] = self[i] } }
+          else
+            raise RuntimeError, 'Splitter is not based on Array: can\'t convert to Array'
+          end
+        end
+
         class BufferedProxy
           include SeriePrototyping
 

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

@@ -192,6 +192,8 @@ module Musa
     private_constant :Sequence
 
     class FromEvalBlockWithParameters
+      using Musa::Extension::DeepCopy
+
       include Serie
       include Musa::Extension::SmartProcBinder
 
@@ -211,8 +213,8 @@ module Musa
       end
 
       def _restart
-        @value_parameters = @original_value_parameters.collect(&:clone)
-        @key_parameters = @original_key_parameters.transform_values(&:clone)
+        @value_parameters = @original_value_parameters.clone(deep: true)
+        @key_parameters = @original_key_parameters.clone(deep: true)
 
         @first = true
         @value = nil

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

@@ -112,6 +112,10 @@ module Musa
         ProcessWith.new self, &yield_block
       end
 
+      def anticipate(&yield_block)
+        Anticipate.new self, &yield_block
+      end
+
       ###
       ### Implementation
       ###
@@ -130,7 +134,7 @@ module Musa
           @block = SmartProcBinder.new(block) if block_given?
 
           if @source.prototype?
-            @sources = @sources.transform_values { |s| s.prototype }
+            @sources = @sources.transform_values { |s| s.prototype }.freeze
           else
             @sources = @sources.transform_values { |s| s.instance }
           end
@@ -168,6 +172,37 @@ module Musa
 
       private_constant :ProcessWith
 
+      class Anticipate
+        include Musa::Extension::SmartProcBinder
+        include Serie
+
+        attr_reader :source, :block
+
+        def initialize(serie, &block)
+          @source = serie
+          @block = block
+
+          mark_regarding! @source
+        end
+
+        def _restart
+          @source.restart
+        end
+
+        def _next_value
+          value = @source.next_value
+          peek_next_value = @source.peek_next_value
+
+          @block.call(value, peek_next_value)
+        end
+
+        def infinite?
+          @source.infinite?
+        end
+      end
+
+      private_constant :Anticipate
+
       class Switcher
         include Serie
 
@@ -185,7 +220,7 @@ module Musa
             @sources = hash_series.clone.transform_values(&get)
           end
 
-          if get == :_prototype!
+          if get == :prototype!
             @sources.freeze
           end
 
@@ -236,7 +271,7 @@ module Musa
 
           _restart false
 
-          if get == :_prototype!
+          if get == :prototype
             @sources.freeze
           end
 
@@ -293,7 +328,7 @@ module Musa
             @sources = hash_series.clone.transform_values(&get)
           end
 
-          if get == :_prototype!
+          if get == :prototype
             @sources.freeze
           end
 

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

@@ -87,8 +87,6 @@ module Musa
 
       attr_reader :source
 
-      attr_reader :points_history
-
       def initialize(reference, step, source, value_attribute, stops, left_open, right_open)
         @reference = reference
         @step_size = step.abs
@@ -218,13 +216,13 @@ module Musa
             if @segments.last && @segments.last[:time] == from_time
 
               @segments.last[:duration] = to_time - from_time
-              @segments.last[:info] += "; edited on a as start"
+              @segments.last[:info] += '; edited on a as start'
 
             else
               @segments << { time: from_time,
                              value: from_value,
                              duration: to_time - from_time,
-                             info: "added on a as start" }
+                             info: 'added on a as start' }
 
             end
 
@@ -233,7 +231,7 @@ module Musa
                              value: from_value,
                              duration: 0,
                              stop: true,
-                             info: "added on a as end stop" }
+                             info: 'added on a as end stop' }
             end
           else
             time_increment = to_time - from_time
@@ -268,7 +266,7 @@ module Musa
                 @segments.last[:value] == value
 
                 @segments.last[:duration] = step_time_increment
-                @segments.last[:info] += "; edited on b"
+                @segments.last[:info] += '; edited on b'
 
                 # puts "process2: editing #{@segments.last}"
 
@@ -276,7 +274,7 @@ module Musa
                 @segments <<  v = { time: intermediate_point_time,
                                     value: value,
                                     duration: step_time_increment,
-                                    info: "added on b" }
+                                    info: 'added on b' }
 
                 # puts "process2: adding #{v.inspect}"
               end
@@ -297,7 +295,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 RuntimeError, 'time only can go forward' if @last_processed_time && time <= @last_processed_time
 
           q_value = round_quantize(value)
 

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

@@ -12,5 +12,4 @@ require_relative 'queue-serie'
 require_relative 'hash-or-array-serie-splitter'
 
 require_relative 'quantizer-serie'
-require_relative 'flattener-timed-serie'
-require_relative 'union-timed-series'
+require_relative 'timed-serie'

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

@@ -0,0 +1,354 @@
+require_relative '../datasets/e'
+
+module Musa
+  module Series
+    extend self
+
+    def TIMED_UNION(*array_of_timed_series, **hash_of_timed_series)
+      raise ArgumentError, 'Can\'t union an array of series with a hash of series' if array_of_timed_series.any? && hash_of_timed_series.any?
+
+      if array_of_timed_series.any?
+        TimedUnionOfArrayOfSeries.new(array_of_timed_series)
+      elsif hash_of_timed_series.any?
+        TimedUnionOfHashOfSeries.new(hash_of_timed_series)
+      else
+        raise ArgumentError, 'Missing argument series'
+      end
+    end
+
+    class TimedUnionOfArrayOfSeries
+      include Serie
+
+      attr_reader :sources
+
+      def initialize(series)
+        @sources = if series[0].prototype?
+                     series.collect(&:prototype).freeze
+                   else
+                     series.collect(&:instance)
+                   end
+
+        _restart false
+
+        mark_regarding! series[0]
+      end
+
+      private def _restart(restart_sources = true)
+        @sources.each { |serie| serie.restart } if restart_sources
+        @sources_next_values = Array.new(@sources.size)
+
+        @components = nil
+      end
+
+      private def _next_value
+        sources_values = @sources_next_values.each_index.collect do |i|
+          @sources_next_values[i] || (@sources_next_values[i] = @sources[i].next_value)
+        end
+
+        @components, @hash_mode, @array_mode = infer_components(sources_values) unless @components
+
+        time = sources_values.collect { |_| _&.[](:time) }.compact.min
+
+        if time
+          selected_values = sources_values.collect { |_| _ if _&.[](:time) == time }
+
+          @sources_next_values.each_index do |i|
+            if @sources_next_values[i]&.[](:time) == time
+              @sources_next_values[i] = nil
+            end
+          end
+
+          result = { time: time }
+
+          @components.each do |attribute_name, components|
+            if @hash_mode
+              result[attribute_name] = {}
+            elsif @array_mode
+              result[attribute_name] = []
+            else # value mode
+              result[attribute_name] = []
+            end
+
+            components.each do |target_key_or_index, source_placement|
+              result[attribute_name][target_key_or_index] = selected_values.dig(*source_placement)
+            end
+          end
+
+          result
+        else
+          nil
+        end
+      end
+
+      def infinite?
+        !!@sources.find(&:infinite?)
+      end
+    end
+
+    private def infer_components(sources_values)
+      other_attributes = Set[]
+
+      sources_values.each do |source_value|
+        (source_value.keys - [:time, :value]).each { |_| other_attributes << _ }
+      end
+
+      components = {}
+      components[:value] = {}
+
+      hash_mode = array_mode = nil
+
+      other_attributes.each do |attribute_name|
+        components[attribute_name] = {}
+      end
+
+      target_index = 0
+
+      sources_values.each_with_index do |source_value, i|
+        case source_value[:value]
+        when Hash
+          hash_mode = true
+
+          source_value[:value].keys.each do |key|
+            raise RuntimeError, "Value: key #{key} already used" unless components[:value][key].nil?
+
+            components[:value][key] = [i, :value, key]
+
+            other_attributes.each do |attribute_name|
+              raise RuntimeError, "Attribute #{attribute_name}: key #{key} already used" unless components[attribute_name][key].nil?
+              components[attribute_name][key] = [i, attribute_name, key]
+            end
+          end
+        when Array
+          array_mode = true
+
+          (0..source_value[:value].size - 1).each do |index|
+            components[:value][target_index] = [i, :value, index]
+
+            other_attributes.each do |attribute_name|
+              components[attribute_name][target_index] = [i, attribute_name, index]
+            end
+
+            target_index += 1
+          end
+        else
+          components[:value][target_index] = [i, :value]
+
+          other_attributes.each do |attribute_name|
+            components[attribute_name][target_index] = [i, attribute_name]
+          end
+
+          target_index += 1
+        end
+      end
+
+      raise RuntimeError, "source series values are of incompatible type (can't combine Hash and Array values)" if array_mode && hash_mode
+
+      return components, hash_mode, array_mode
+    end
+
+    private_constant :TimedUnionOfArrayOfSeries
+
+    class TimedUnionOfHashOfSeries
+      include Serie
+
+      attr_reader :sources
+
+      def initialize(series)
+        @components = series.keys
+
+        @sources = if series.values.first.prototype?
+                     series.transform_values(&:prototype).freeze
+                   else
+                     series.transform_values(&:instance)
+                   end
+
+        _restart false
+
+        mark_regarding! series.values.first
+      end
+
+      private def _restart(restart_sources = true)
+        @sources.each_value { |serie| serie.restart } if restart_sources
+        @sources_next_values = @components.collect { |k| [k, nil] }.to_h
+        @other_attributes = nil
+      end
+
+      private def _next_value
+        sources_values = @sources_next_values.collect do |key, _|
+          [key, @sources_next_values[key] || (@sources_next_values[key] = @sources[key].next_value)]
+        end.to_h
+
+        @other_attributes = infer_other_attributes(sources_values) unless @other_attributes
+
+        time = sources_values.values.collect { |_| _&.[](:time) }.compact.min
+
+        if time
+          selected_values = sources_values.transform_values { |_| _ if _&.[](:time) == time }
+
+          @sources_next_values.each_key do |key|
+            if @sources_next_values[key]&.[](:time) == time
+              @sources_next_values[key] = nil
+            end
+          end
+
+          result = { time: time, value: {} }
+
+          @other_attributes.each do |attribute_name|
+            result[attribute_name] = {}
+          end
+
+          @components.each do |component|
+            result[:value][component] = selected_values[component]&.[](:value)
+
+            @other_attributes.each do |attribute_name|
+              result[attribute_name][component] = selected_values[component]&.[](attribute_name)
+            end
+          end
+
+          result
+        else
+          nil
+        end
+      end
+
+      def infinite?
+        !!@sources.find(&:infinite?)
+      end
+
+      private def infer_other_attributes(sources_values)
+        other_attributes = Set[]
+
+        sources_values.each_value do |source_value|
+          (source_value.keys - [:time, :value]).each do |attribute_name|
+            other_attributes << attribute_name
+          end
+        end
+
+        other_attributes
+      end
+    end
+
+    private_constant :TimedUnionOfHashOfSeries
+
+    module SerieOperations
+      def flatten_timed
+        TimedFlattener.new(self)
+      end
+
+      def compact_timed
+        TimedCompacter.new(self)
+      end
+
+      def union_timed(*other_timed_series, key: nil, **other_key_timed_series)
+        if key && other_key_timed_series.any?
+          Series::TIMED_UNION(key => self, **other_key_timed_series)
+
+        elsif other_timed_series.any? && other_key_timed_series.empty?
+          Series::TIMED_UNION(self, *other_timed_series)
+
+        else
+          raise ArgumentError, 'Can\'t union an array of series with a hash of series'
+        end
+      end
+
+      class TimedFlattener
+        include Serie
+
+        attr_reader :source
+
+        def initialize(serie)
+          @source = serie
+          mark_regarding! @source
+        end
+
+        def _restart
+          @source.restart
+        end
+
+        def _next_value
+          source_value = @source.next_value
+
+          if !source_value.nil?
+            time = source_value[:time]
+            source_value_value = source_value[:value]
+
+            source_value_extra = (source_value.keys - [:time, :value]).collect do |attribute_name|
+              [attribute_name, source_value[attribute_name]]
+            end.to_h
+
+            case source_value_value
+            when Hash
+              result = {}
+              source_value_value.each_pair do |key, value|
+                result[key] = { time: time, value: value }.extend(Musa::Datasets::AbsTimed)
+
+                source_value_extra.each do |attribute_name, attribute_value|
+                  result[key][attribute_name] = attribute_value[key]
+                end
+              end
+
+            when Array
+              result = []
+              source_value_value.each_index do |index|
+                result[index] = { time: time, value: source_value_value[index] }.extend(Musa::Datasets::AbsTimed)
+
+                source_value_extra.each do |attribute_name, attribute_value|
+                  result[index][attribute_name] = attribute_value[index]
+                end
+              end
+            else
+              result = source_value.clone.extend(Musa::Datasets::AbsTimed)
+            end
+
+            result
+          else
+            nil
+          end
+        end
+
+        def infinite?
+          @source.infinite?
+        end
+      end
+
+      private_constant :TimedFlattener
+    end
+
+    class TimedCompacter
+      include Serie
+
+      attr_reader :source
+
+      def initialize(serie)
+        @source = serie
+        mark_regarding! @source
+      end
+
+      def _restart
+        @source.restart
+      end
+
+      def _next_value
+        while (source_value = @source.next_value) && skip_value?(source_value[:value]); end
+        source_value
+      end
+
+      def infinite?
+        @source.infinite?
+      end
+
+      private def skip_value?(timed_value)
+        case timed_value
+        when Hash
+          timed_value.all? { |_, v| v.nil? }
+        when Array
+          timed_value.all?(&:nil?)
+        else
+          timed_value.nil?
+        end
+      end
+    end
+
+    private_constant :TimedCompacter
+  end
+end

data/musa-dsl.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name        = 'musa-dsl'
-  s.version     = '0.22.4'
-  s.date        = '2020-11-14'
+  s.version     = '0.22.5'
+  s.date        = '2020-11-18'
   s.summary     = 'A simple Ruby DSL for making complex music'
   s.description = 'Musa-DSL: A Ruby DSL for algorithmic music composition, device language neutral (MIDI, OSC, etc)'
   s.authors     = ['Javier Sánchez Yeste']

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: musa-dsl
 version: !ruby/object:Gem::Version
-  version: 0.22.4
+  version: 0.22.5
 platform: ruby
 authors:
 - Javier Sánchez Yeste
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-14 00:00:00.000000000 Z
+date: 2020-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: citrus
@@ -179,7 +179,6 @@ files:
 - lib/musa-dsl/series.rb
 - lib/musa-dsl/series/array-to-serie.rb
 - lib/musa-dsl/series/base-series.rb
-- lib/musa-dsl/series/flattener-timed-serie.rb
 - lib/musa-dsl/series/hash-or-array-serie-splitter.rb
 - lib/musa-dsl/series/holder-serie.rb
 - lib/musa-dsl/series/main-serie-constructors.rb
@@ -188,7 +187,7 @@ files:
 - lib/musa-dsl/series/quantizer-serie.rb
 - lib/musa-dsl/series/queue-serie.rb
 - lib/musa-dsl/series/series.rb
-- lib/musa-dsl/series/union-timed-series.rb
+- lib/musa-dsl/series/timed-serie.rb
 - lib/musa-dsl/transcription.rb
 - lib/musa-dsl/transcription/from-gdv-to-midi.rb
 - lib/musa-dsl/transcription/from-gdv-to-musicxml.rb

data/lib/musa-dsl/series/flattener-timed-serie.rb

@@ -1,61 +0,0 @@
-require_relative '../datasets/e'
-
-module Musa
-  module Series
-
-    module SerieOperations
-      def flatten_timed
-        TimedFlattener.new(self)
-      end
-
-      class TimedFlattener
-        include Serie
-
-        attr_reader :source
-
-        def initialize(serie)
-          @source = serie
-          mark_regarding! @source
-        end
-
-        def _restart
-          @source.restart
-        end
-
-        def _next_value
-          source_value = @source.next_value
-
-          if !source_value.nil?
-            time = source_value[:time]
-            source_value_value = source_value[:value]
-
-            case source_value_value
-            when Hash
-              result = {}
-              source_value_value.each_pair do |key, value|
-                result[key] = { time: time, value: value }.extend(Musa::Datasets::AbsTimed)
-              end
-            when Array
-              result = []
-              source_value_value.each_index do |index|
-                result[index] = { time: time, value: source_value_value[index] }.extend(Musa::Datasets::AbsTimed)
-              end
-            else
-              raise RuntimeError, "Don't know how to handle #{source_value_value}"
-            end
-
-            result
-          else
-            nil
-          end
-        end
-
-        def infinite?
-          @source.infinite?
-        end
-      end
-
-      private_constant :TimedFlattener
-    end
-  end
-end

data/lib/musa-dsl/series/union-timed-series.rb

@@ -1,109 +0,0 @@
-require_relative '../datasets/e'
-
-module Musa
-  module Series
-
-    extend self
-
-    def TIMED_UNION(*timed_series)
-      TimedUnion.new(timed_series)
-    end
-
-    class TimedUnion
-      include Serie
-
-      attr_reader :sources
-
-      def initialize(series)
-        @sources = if series[0].prototype?
-                     series.collect(&:prototype).freeze
-                   else
-                     series.collect(&:instance)
-                   end
-
-        _restart false
-
-        mark_regarding! series[0]
-      end
-
-      private def _restart(restart_sources = true)
-        @sources.each { |serie| serie.restart } if restart_sources
-        @sources_next_values = Array.new(@sources.size)
-
-        @components = nil
-        @hash_mode = @array_mode = nil
-      end
-
-      private def _next_value
-        sources_values = @sources_next_values.each_index.collect do |i|
-          @sources_next_values[i] || (@sources_next_values[i] = @sources[i].next_value)
-        end
-
-        infer_components(sources_values) if !@components
-
-        time = sources_values.collect { |_| _&.[](:time) }.compact.min
-
-        if time
-          selected_values = sources_values.collect { |_| _ if _&.[](:time) == time }
-
-          @sources_next_values.each_index do |i|
-            if @sources_next_values[i]&.[](:time) == time
-              @sources_next_values[i] = nil
-            end
-          end
-
-          if @hash_mode
-            result = {}
-          elsif @array_mode
-            result = []
-          else # value mode
-            result = []
-          end
-
-          @components.each do |target_key_or_index, source_placement|
-            result[target_key_or_index] = selected_values.dig(*source_placement)
-          end
-
-          { time: time,
-            value: result }
-        else
-          nil
-        end
-      end
-
-      def infinite?
-        !!@sources.find(&:infinite?)
-      end
-    end
-
-    private def infer_components(sources_values)
-      @components = {}
-      target_index = 0
-
-      sources_values.each_with_index do |source_value, i|
-        case source_value[:value]
-        when Hash
-          @hash_mode = true
-
-          source_value[:value].keys.each do |key|
-            @components[key] = [i, :value, key]
-          end
-        when Array
-          @array_mode = true
-
-          (0..source_value[:value].size - 1).each do |index|
-            @components[target_index] = [i, :value, index]
-            target_index += 1
-          end
-        else
-          @components[target_index] = [i, :value]
-          target_index += 1
-        end
-      end
-
-      raise RuntimeError, "source series values are of incompatible type (can't combine Hash and Array values)" if @array_mode && @hash_mode
-    end
-
-    private_constant :TimedUnion
-  end
-end