musa-dsl 0.21.0 → 0.22.0

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

@@ -17,7 +17,9 @@ module Musa
       attr_reader :everying, :playing, :moving
       attr_reader :logger
 
-      def initialize(beats_per_bar = nil, ticks_per_beat = nil, logger: nil, do_log: nil, do_error_log: nil, log_position_format: nil)
+      def initialize(beats_per_bar = nil, ticks_per_beat = nil,
+                     logger: nil,
+                     do_log: nil, do_error_log: nil, log_position_format: nil)
 
         raise ArgumentError,
               "'beats_per_bar' and 'ticks_per_beat' parameters should be both nil or both have values" \
@@ -175,10 +177,18 @@ module Musa
         control
       end
 
-      def play(serie, mode: nil, parameter: nil, after: nil, context: nil, **mode_args, &block)
+      def play(serie,
+               mode: nil,
+               parameter: nil,
+               after_bars: nil,
+               after: nil,
+               context: nil,
+               **mode_args,
+               &block)
+
         mode ||= :wait
 
-        control = PlayControl.new @event_handlers.last, after: after
+        control = PlayControl.new @event_handlers.last, after_bars: after_bars, after: after
         @event_handlers.push control
 
         _play serie.instance, control, context, mode: mode, parameter: parameter, **mode_args, &block
@@ -197,14 +207,57 @@ module Musa
       def continuation_play(parameters)
         _play parameters[:serie],
               parameters[:control],
-              parameters[:nl_context],
+              parameters[:neumalang_context],
               mode: parameters[:mode],
               decoder: parameters[:decoder],
               __play_eval: parameters[:play_eval],
               **parameters[:mode_args]
       end
 
-      def every(interval, duration: nil, till: nil, condition: nil, on_stop: nil, after_bars: nil, after: nil, &block)
+      def play_timed(timed_serie,
+                     reference: nil,
+                     step: nil,
+                     right_open: nil,
+                     on_stop: nil,
+                     after_bars: nil, after: nil,
+                     &block)
+
+        control = PlayTimedControl.new(@event_handlers.last,
+                                       on_stop: on_stop, after_bars: after_bars, after: after)
+
+        control.on_stop do
+          control.do_after.each do |do_after|
+            _numeric_at position + do_after[:bars], control, &do_after[:block]
+          end
+        end
+
+        @event_handlers.push control
+
+        _play_timed(timed_serie.instance,
+                    control,
+                    reference: reference,
+                    step: step,
+                    right_open: right_open,
+                    &block)
+
+        @event_handlers.pop
+
+        @playing << control
+
+        control.after do
+          @playing.delete control
+        end
+
+        control
+      end
+
+      def every(interval,
+                duration: nil, till: nil,
+                condition: nil,
+                on_stop: nil,
+                after_bars: nil, after: nil,
+                &block)
+
         # nil interval means 'only once'
         interval = interval.rationalize unless interval.nil?
 

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

@@ -41,27 +41,23 @@ module Musa
           @position = @position_mutex.synchronize { 1r - @tick_duration }
         end
 
-        def _check_position(position)
+        def _quantize_position(position, warn: true)
           ticks_position = position / @tick_duration
 
           if ticks_position.round != ticks_position
             original_position = position
             position = ticks_position.round * @tick_duration
 
-            if @do_log
-              _log "BaseSequencer._numeric_at: warning: rounding "\
-                  "position #{position} (#{original_position.to_f.round(5)}) "\
-                  "to tick precision: #{position} (#{position.to_f.round(5)})"
+            if warn
+              @logger.warn('BaseSequencer') { "_check_position: rounding "\
+                  "position #{original_position} (#{original_position.to_f.round(5)}) "\
+                  "to tick precision: #{position} (#{position.to_f.round(5)})" }
             end
           end
 
           position
         end
 
-        def _quantize(position)
-          (position / @tick_duration).round * @tick_duration
-        end
-
         def _hold_public_ticks
           @hold_public_ticks = true
         end

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

@@ -62,11 +62,7 @@ module Musa
           @position = nil
         end
 
-        def _check_position(position)
-          position
-        end
-
-        def _quantize(position)
+        def _quantize_position(position, warn: false)
           position
         end
       end

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

@@ -89,6 +89,14 @@ module Musa
           end
         end
 
+        def play_timed(*value_parameters, **key_parameters, &block)
+          block ||= proc {}
+
+          @sequencer.play_timed *value_parameters, **key_parameters do |*value_args, **key_args|
+            with *value_args, **key_args, &block
+          end
+        end
+
         def every(*value_parameters, **key_parameters, &block)
           block ||= proc {}
 

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

@@ -18,57 +18,73 @@ module Musa
 
       def prototype
         if @is_instance
-          @instance_of || (@instance_of = clone.tap(&:_prototype).mark_as_prototype!)
+          @instance_of || (@instance_of = self.clone.tap(&:_prototype!).mark_as_prototype!)
         else
           self
         end
       end
 
-      def _prototype
-        nil
-      end
-
       alias_method :p, :prototype
 
-      def mark_as_prototype!
-        @is_instance = nil
-        freeze
+      def instance
+        if @is_instance
+          self
+        else
+          clone(freeze: false).tap(&:_instance!).mark_as_instance!(self)
+        end
       end
 
-      protected :_prototype, :mark_as_prototype!
+      alias_method :i, :instance
 
-      def mark_regarding!(source)
-        if source.prototype?
-          mark_as_prototype!
-        else
-          mark_as_instance!
+      # By default, if there is a @source attribute that contains the source of the serie, SeriePrototyping will
+      # 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.
+      #
+      protected def _prototype!
+        @source = @source.prototype if @source
+
+        if @sources
+          if @sources.is_a?(Array)
+            @sources = @sources.collect(&:prototype).freeze
+          elsif @sources.is_a?(Hash)
+            @sources = @sources.transform_values(&:prototype).freeze
+          end
         end
       end
 
-      protected :mark_regarding!
+      protected def _instance!
+        @source = @source.instance if @source
 
-      def instance
-        if @is_instance
-          self
-        else
-          clone(freeze: false).tap(&:_instance).mark_as_instance!(self)
+        if @sources
+          if @sources.is_a?(Array)
+            @sources = @sources.collect(&:instance)
+          elsif @sources.is_a?(Hash)
+            @sources = @sources.transform_values(&:instance)
+          end
         end
       end
 
-      alias_method :i, :instance
+      protected def mark_regarding!(source)
+        if source.prototype?
+          mark_as_prototype!
+        else
+          mark_as_instance!
+        end
+      end
 
-      def _instance
-        nil
+      protected def mark_as_prototype!
+        @is_instance = nil
+        freeze
       end
 
-      def mark_as_instance!(prototype = nil)
+      protected def mark_as_instance!(prototype = nil)
         @instance_of = prototype
         @is_instance = true
         self
       end
 
-      protected :_instance, :mark_as_instance!
-
       class PrototypingSerieError < RuntimeError
         def initialize(message = nil)
           message ||= 'This serie is a prototype serie: cannot be consumed. To consume the serie use an instance serie via .instance method'
@@ -106,8 +122,6 @@ module Musa
           end
         end
 
-        propagate_value @_current_value
-
         @_current_value
       end
 
@@ -180,15 +194,7 @@ module Musa
 
       private_constant :Nodificator
 
-      protected
-
-      def propagate_value(value)
-        @_slaves.each { |s| s.push_next_value value } if @_slaves
-      end
-
-      private
-
-      def process_for_to_a(value)
+      private def process_for_to_a(value)
         case value
         when Serie
           value.to_a(recursive: true, restart: false, duplicate: false)
@@ -203,46 +209,5 @@ module Musa
         end
       end
     end
-
-    class Slave
-      include Serie
-
-      attr_reader :master
-
-      def initialize(master)
-        @master = master
-        @next_value = []
-      end
-
-      def _restart
-        throw OperationNotAllowedError, "SlaveSerie #{self}: slave series cannot be restarted"
-      end
-
-      def next_value
-        value = @next_value.shift
-
-        raise "Warning: slave serie #{self} has lost sync with his master serie #{@master}" if value.nil? && !@master.peek_next_value.nil?
-
-        propagate_value value
-
-        value
-      end
-
-      def peek_next_value
-        value = @next_value.first
-
-        raise "Warning: slave serie #{self} has lost sync with his master serie #{@master}" if value.nil? && !@master.peek_next_value.nil?
-
-        value
-      end
-
-      def infinite?
-        @master.infinite?
-      end
-
-      def push_next_value(value)
-        @next_value << value
-      end
-    end
   end
 end

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

@@ -0,0 +1,61 @@
+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(AbsTimed)
+              end
+            when Array
+              result = []
+              source_value_value.each_index do |index|
+                result[index] = { time: time, value: source_value_value[index] }.extend(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/hash-or-array-serie-splitter.rb

@@ -0,0 +1,95 @@
+module Musa
+  module Series
+    module SerieOperations
+      def split
+        Splitter.new(Splitter::BufferedProxy.new(self))
+      end
+
+      class Splitter
+        def initialize(proxy)
+          @proxy = proxy
+          @series = {}
+        end
+
+        def [](key_or_index)
+          if @series.has_key?(key_or_index)
+            @series[key_or_index]
+          else
+            @series[key_or_index] = Split.new(@proxy, key_or_index)
+          end
+        end
+
+        class BufferedProxy
+          include SeriePrototyping
+
+          def initialize(hash_or_array_serie)
+            @source = hash_or_array_serie
+            restart restart_source: false
+
+            mark_regarding! @source
+          end
+
+          protected def _instance!
+            super
+            restart
+          end
+
+          def restart(restart_source: true)
+            @source.restart if restart_source
+            @values = nil
+          end
+
+          def next_value(key_or_index)
+            if @values.nil? || @values[key_or_index].nil? || @values[key_or_index].empty?
+              hash_or_array_value = @source.next_value
+
+              case hash_or_array_value
+              when Hash
+                @values ||= {}
+                hash_or_array_value.each do |k, v|
+                  @values[k] ||= []
+                  @values[k] << v
+                end
+              when Array
+                @values ||= []
+                hash_or_array_value.each_index do |i|
+                  @values[i] ||= []
+                  @values[i] << hash_or_array_value[i]
+                end
+              end
+            end
+
+            if @values && !@values[key_or_index].nil?
+              @values[key_or_index].shift
+            else
+              nil
+            end
+          end
+        end
+
+        class Split
+          include Serie
+
+          def initialize(proxy, key_or_index)
+            @source = proxy
+            @key_or_index = key_or_index
+
+            mark_regarding! @source
+          end
+
+          def _restart
+            @source.restart
+          end
+
+          def _next_value
+            @source.next_value(@key_or_index)
+          end
+        end
+
+        private_constant :Split
+      end
+
+      private_constant :Splitter
+    end
+  end
+end