musa-dsl 0.22.2 → 0.23.0

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

@@ -9,6 +9,8 @@ module Musa; module Sequencer
     include Musa::Extension::SmartProcBinder
     include Musa::Extension::DeepCopy
 
+    using Musa::Extension::InspectNice
+
     private def _tick(position_to_run)
       @before_tick.each { |block| block.call position_to_run }
       queue = @timeslots[position_to_run]
@@ -63,21 +65,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 +82,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 +97,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 +107,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 +215,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

@@ -3,6 +3,8 @@ module Musa
     class BaseSequencer
       module TickBasedTiming
 
+        using Musa::Extension::InspectNice
+
         attr_reader :position, :ticks_per_bar, :tick_duration
 
         def tick
@@ -27,9 +29,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 +37,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
@@ -50,19 +50,19 @@ module Musa
 
             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)})" }
+                  "position #{original_position.inspect} (#{original_position.to_f.round(5)}) "\
+                  "to tick precision: #{position.inspect} (#{position.to_f.round(5)})" }
             end
           end
 
           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-public.rb → base-sequencer.rb}

@@ -30,6 +30,7 @@ module Musa
         else
           @logger = Musa::Logger::Logger.new(sequencer: self, position_format: log_position_format)
 
+          @logger.fatal!
           @logger.error! if do_error_log || do_error_log.nil?
           @logger.debug! if do_log
         end
@@ -82,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
@@ -114,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
@@ -137,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
 
@@ -154,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
@@ -215,9 +215,6 @@ module Musa
       end
 
       def play_timed(timed_serie,
-                     reference: nil,
-                     step: nil,
-                     right_open: nil,
                      on_stop: nil,
                      after_bars: nil, after: nil,
                      &block)
@@ -233,12 +230,7 @@ module Musa
 
         @event_handlers.push control
 
-        _play_timed(timed_serie.instance,
-                    control,
-                    reference: reference,
-                    step: step,
-                    right_open: right_open,
-                    &block)
+        _play_timed(timed_serie.instance, control, &block)
 
         @event_handlers.pop
 

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

@@ -17,11 +17,11 @@ module Musa
                      :position=,
                      :event_handler
 
-      def_delegators :@context, :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
-      def_delegators :@context, :run
+      def_delegators :@dsl, :position, :quantize_position, :logger, :debug
+      def_delegators :@dsl, :with, :now, :at, :wait, :play, :play_timed, :every, :move
+      def_delegators :@dsl, :everying, :playing, :moving
+      def_delegators :@dsl, :launch, :on
+      def_delegators :@dsl, :run
 
       def initialize(beats_per_bar = nil,
                      ticks_per_beat = nil,
@@ -37,7 +37,7 @@ module Musa
                                          do_error_log: do_error_log,
                                          log_position_format: log_position_format
 
-        @context = DSLContext.new @sequencer
+        @dsl = DSLContext.new @sequencer
 
         with &block if block_given?
       end
@@ -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-public'
+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

@@ -5,209 +5,358 @@ using Musa::Extension::DeepCopy
 
 module Musa
   module Series
-    module SerieOperations end
+    module Constructors; extend self; end
+    module Operations; end
 
-    module SeriePrototyping
-      def prototype?
-        @is_instance ? false : true
-      end
+    include Constructors
 
-      def instance?
-        @is_instance ? true : false
+    module Serie
+      def self.base
+        SerieImplementation
       end
 
-      def prototype
-        if @is_instance
-          @instance_of || (@instance_of = self.clone.tap(&:_prototype!).mark_as_prototype!)
-        else
-          self
+      def self.with(source: false,
+                    source_as: nil,
+                    private_source: nil,
+                    sources: false,
+                    sources_as: nil,
+                    private_sources: nil,
+                    smart_block: false,
+                    block: false,
+                    block_as: nil)
+
+        source_as ||= :source
+        source_setter = (source_as.to_s + '=').to_sym
+
+        sources_as ||= :sources
+        sources_setter = (sources_as.to_s + '=').to_sym
+
+        block_as ||= :proc
+        block_setter = (block_as.to_s + '=').to_sym
+
+        Module.new do
+          include SerieImplementation
+
+          if source
+            define_method source_as do ||
+              @source
+            end
+
+            define_method source_setter do |serie|
+              raise ArgumentError, "New source should be a #{@get}" unless @source.nil? || @source.prototype? == serie&.prototype?
+
+              serie ||= Musa::Series::Constructors.NIL
+              @get = serie&.instance? ? :instance : :prototype
+              @source = serie
+              mark_regarding! @source
+            end
+
+            if private_source
+              private source_as
+              private source_setter
+            end
+          end
+
+          if sources
+            define_method sources_as do ||
+              @sources
+            end
+
+            define_method sources_setter do |series|
+              case series
+              when Array
+                getter = @get || ((series.first)&.instance? ? :instance : :prototype)
+                @sources = series.collect(&getter)
+              when Hash
+                getter = @get || ((series.values.first)&.instance? ? :instance : :prototype)
+                @sources = series.transform_values(&getter)
+              else
+                raise ArgumentError, "Only allowed Array or Hash"
+              end
+
+              mark_as! getter
+            end
+
+            if private_sources
+              private sources_as
+              private sources_setter
+            end
+          end
+
+          if smart_block
+            define_method block_as do |&block|
+              if block
+                @block = Musa::Extension::SmartProcBinder::SmartProcBinder.new(block)
+              else
+                @block.proc
+              end
+            end
+
+            define_method block_setter do |block|
+              @block = Musa::Extension::SmartProcBinder::SmartProcBinder.new(block)
+            end
+
+          elsif block
+            define_method block_as do |&block|
+              if block
+                @block = block
+              else
+                @block
+              end
+            end
+
+            define_method block_setter do |block|
+              @block = block
+            end
+          end
         end
       end
 
-      alias_method :p, :prototype
+      module Prototyping
+        def prototype?
+          @is_instance ? false : true
+        end
 
-      def instance
-        if @is_instance
-          self
-        else
-          clone(freeze: false).tap(&:_instance!).mark_as_instance!(self)
+        def instance?
+          @is_instance ? true : false
         end
-      end
 
-      alias_method :i, :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
+        def prototype
+          if @is_instance
+            if !@instance_of
+              @instance_of = clone
+              @instance_of._prototype!
+              @instance_of.mark_as_prototype!
+              @instance_of.init if @instance_of.respond_to?(:init)
+            end
+
+            @instance_of
+          else
+            self
           end
         end
-      end
 
-      protected def _instance!
-        @source = @source.instance if @source
+        alias_method :p, :prototype
 
-        if @sources
-          if @sources.is_a?(Array)
-            @sources = @sources.collect(&:instance)
-          elsif @sources.is_a?(Hash)
-            @sources = @sources.transform_values(&:instance)
+        def instance
+          if @is_instance
+            self
+          else
+            new_instance = clone
+
+            new_instance._instance!
+            new_instance.mark_as_instance!(self)
+            new_instance.init if new_instance.respond_to?(:init)
+
+            new_instance
           end
         end
-      end
 
-      protected def mark_regarding!(source)
-        if source.prototype?
-          mark_as_prototype!
-        else
-          mark_as_instance!
+        alias_method :i, :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 accommodate to real subclass specificities.
+        #
+        protected def _prototype!
+          @source = @source.prototype if @source
+
+          if @sources
+            if @sources.is_a?(Array)
+              @sources = @sources.collect(&:prototype)
+            elsif @sources.is_a?(Hash)
+              @sources = @sources.transform_values(&:prototype)
+            end
+          end
         end
-      end
 
-      protected def mark_as_prototype!
-        @is_instance = nil
-        freeze
-      end
+        protected def _instance!
+          @source = @source.instance if @source
 
-      protected def mark_as_instance!(prototype = nil)
-        @instance_of = prototype
-        @is_instance = true
-        self
-      end
+          if @sources
+            if @sources.is_a?(Array)
+              @sources = @sources.collect(&:instance)
+            elsif @sources.is_a?(Hash)
+              @sources = @sources.transform_values(&:instance)
+            end
+          end
+        end
 
-      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'
-          super message
+        protected def mark_as!(getter)
+          case getter
+          when :prototype
+            mark_as_prototype!
+          when :instance
+            mark_as_instance!
+          else
+            raise ArgumentError, "Only can be marked as :prototype or :instance"
+          end
         end
-      end
-    end
 
-    module Serie
-      include SeriePrototyping
-      include SerieOperations
+        protected def mark_regarding!(source)
+          if source.prototype?
+            mark_as_prototype!
+          else
+            mark_as_instance!
+          end
+        end
 
-      def restart
-        raise PrototypingSerieError unless @is_instance
+        protected def mark_as_prototype!
+          @get = :prototype
 
-        @_have_peeked_next_value = false
-        @_peeked_next_value = nil
-        @_have_current_value = false
-        @_current_value = nil
+          @is_instance = nil
+          self
+        end
 
-        _restart if respond_to? :_restart
+        protected def mark_as_instance!(prototype = nil)
+          @get = :instance
 
-        self
+          @instance_of = prototype
+          @is_instance = true
+          self
+        end
+
+        class PrototypingError < 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'
+            super message
+          end
+        end
       end
 
-      def next_value
-        raise PrototypingSerieError unless @is_instance
+      module SerieImplementation
+        include Serie
+        include Prototyping
+        include Operations
 
-        unless @_have_current_value && @_current_value.nil?
-          if @_have_peeked_next_value
-            @_have_peeked_next_value = false
-            @_current_value = @_peeked_next_value
-          else
-            @_current_value = _next_value
+        def init
+          @_have_peeked_next_value = false
+          @_peeked_next_value = nil
+          @_have_current_value = false
+          @_current_value = nil
+
+          _init
+
+          self
+        end
+
+        private def _init; end
+
+        def restart(...)
+          raise PrototypingError unless @is_instance
+          init
+          _restart(...)
+
+          self
+        end
+
+        private def _restart; end
+
+        def next_value
+          raise PrototypingError unless @is_instance
+
+          unless @_have_current_value && @_current_value.nil?
+            if @_have_peeked_next_value
+              @_have_peeked_next_value = false
+              @_current_value = @_peeked_next_value
+            else
+              @_current_value = _next_value
+            end
           end
+
+          @_current_value
         end
 
-        @_current_value
-      end
+        private def _next_value; end
 
-      alias_method :v, :next_value
+        alias_method :v, :next_value
 
-      def peek_next_value
-        raise PrototypingSerieError unless @is_instance
+        def peek_next_value
+          raise PrototypingError unless @is_instance
 
-        unless @_have_peeked_next_value
-          @_have_peeked_next_value = true
-          @_peeked_next_value = _next_value
+          if !@_have_peeked_next_value
+            @_have_peeked_next_value = true
+            @_peeked_next_value = _next_value
+          end
+
+          @_peeked_next_value
         end
 
-        @_peeked_next_value
-      end
+        def current_value
+          raise PrototypingError unless @is_instance
 
-      def current_value
-        raise PrototypingSerieError unless @is_instance
+          @_current_value
+        end
 
-        @_current_value
-      end
+        def infinite?
+          @source&.infinite? || false
+        end
 
-      def infinite?
-        false
-      end
+        def to_a(recursive: nil, duplicate: nil, restart: nil, dr: nil)
+          recursive ||= false
 
-      def to_a(recursive: nil, duplicate: nil, restart: nil, dr: nil)
-        recursive ||= false
+          dr = instance? if dr.nil?
 
-        dr ||= instance?
+          duplicate = dr if duplicate.nil?
+          restart = dr if restart.nil?
 
-        duplicate = dr if duplicate.nil?
-        restart = dr if restart.nil?
+          raise 'Cannot convert to array an infinite serie' if infinite?
 
-        raise 'Cannot convert to array an infinite serie' if infinite?
+          array = []
 
-        array = []
+          serie = instance
 
-        serie = instance
+          serie = serie.clone(deep: true) if duplicate
+          serie = serie.restart if restart
 
-        serie = serie.clone(deep: true) if duplicate
-        serie = serie.restart if restart
+          while value = serie.next_value
+            array << if recursive
+                       process_for_to_a(value)
+                     else
+                       value
+                     end
+          end
 
-        while value = serie.next_value
-          array << if recursive
-                     process_for_to_a(value)
-                   else
-                     value
-                   end
+          array
         end
 
-        array
-      end
+        alias_method :a, :to_a
 
-      alias_method :a, :to_a
-
-      def to_node(**attributes)
-        Nodificator.to_node(self, **attributes)
-      end
+        def to_node(**attributes)
+          Nodificator.to_node(self, **attributes)
+        end
 
-      alias_method :node, :to_node
+        alias_method :node, :to_node
 
-      class Nodificator
-        extend Musa::GenerativeGrammar
+        class Nodificator
+          extend Musa::GenerativeGrammar
 
-        def self.to_node(serie, **attributes)
-          N(serie, **attributes)
+          def self.to_node(serie, **attributes)
+            N(serie, **attributes)
+          end
         end
-      end
 
-      private_constant :Nodificator
-
-      private def process_for_to_a(value)
-        case value
-        when Serie
-          value.to_a(recursive: true, restart: false, duplicate: false)
-        when Array
-          a = value.clone
-          a.collect! { |v| v.is_a?(Serie) ? v.to_a(recursive: true, restart: false, duplicate: false) : process_for_to_a(v) }
-        when Hash
-          h = value.clone
-          h.transform_values! { |v| v.is_a?(Serie) ? v.to_a(recursive: true, restart: false, duplicate: false) : process_for_to_a(v) }
-        else
-          value
+        private_constant :Nodificator
+
+        private def process_for_to_a(value)
+          case value
+          when Serie
+            value.to_a(recursive: true, restart: false, duplicate: false)
+          when Array
+            a = value.clone
+            a.collect! { |v| v.is_a?(Serie) ? v.to_a(recursive: true, restart: false, duplicate: false) : process_for_to_a(v) }
+          when Hash
+            h = value.clone
+            h.transform_values! { |v| v.is_a?(Serie) ? v.to_a(recursive: true, restart: false, duplicate: false) : process_for_to_a(v) }
+          else
+            value
+          end
         end
       end
+
+      private_constant :SerieImplementation
     end
   end
 end