musa-dsl 0.14.29 → 0.21.3

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

@@ -0,0 +1,75 @@
+module Musa
+  module Sequencer
+    class BaseSequencer
+      module TicklessBasedTiming
+
+        attr_reader :position
+
+        def ticks_per_bar
+          Float::INFINITY
+        end
+
+        def tick_duration
+          0r
+        end
+
+        # TODO implementar hold_public_ticks adaptado a modo tickless para permitir que una operación de asignación de
+        # TODO posición con .position = X, finalice antes de comenzar a procesar el resto de ticks en un contexto multithread.
+        # TODO pero tiene sentido cuando el modo tickless se usa SOLO con .run?
+        # TODO tendría sentido sólo si también se usa con ticks temporizados, lo cual ocurriría si se reimplementa el modo tickbased
+        # TODO a partir del modo tickless.
+
+        def tick
+          _tick @position_mutex.synchronize { @position = @timeslots.first_after(@position) }
+        end
+
+        # TODO puede pensarse que un sequencer tickbased es como un ticklessbased en que cada tick se aavanza el position en 1 / ticks_per_bar
+        # TODO esto haría que los eventos que cayeran en posiciones no cuantizadas por la resolución en ticks_per_bar se ejecutarían en el siguiente
+        # TODO lo cual sería una ventaja porque eliminaría la necesidad de cuantizar en el _at.
+        # TODO Por otro lado cuando se cuantiza en _at se redondea al más cercano, mientras que el modelo basado en avanzar redondea siempre hacia arriba,
+        # TODO pero esto podría resolverse con una opción de cuantización opcional que en _at ajustara la posición a la más cercana.
+
+        def position=(new_position)
+          raise ArgumentError, "Sequencer #{self}: cannot move back. current position: #{@position} new position: #{new_position}" if new_position < @position
+
+          @on_fast_forward.each { |block| block.call(true) }
+
+          loop do
+            next_position = nil
+
+            @position_mutex.synchronize do
+              next_position = @timeslots.first_after(@position)
+            end
+
+            if next_position <= new_position
+              _tick next_position
+            else
+              break
+            end
+          end
+
+          @position = new_position
+
+          @on_fast_forward.each { |block| block.call(false) }
+        end
+
+        private
+
+        def _init_timing
+        end
+
+        def _reset_timing
+          @position = nil
+        end
+
+        def _check_position(position)
+          position
+        end
+
+        def _quantize(position)
+          position
+        end
+      end
+    end
+  end
+end

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

@@ -1,94 +1,114 @@
 require 'forwardable'
 
-class Musa::Sequencer
-  extend Forwardable
-
-  def_delegators :@sequencer, :raw_at, :tick, :on_debug_at, :on_block_error, :on_fast_forward, :before_tick
-  def_delegators :@sequencer, :beats_per_bar, :ticks_per_beat, :ticks_per_bar, :tick_duration, :round, :position=, :size, :event_handler, :empty?
-
-  def_delegators :@context, :position, :log
-  def_delegators :@context, :with, :now, :at, :wait, :play, :every, :move
-  def_delegators :@context, :everying, :playing, :moving
-  def_delegators :@context, :launch, :on
-
-  def initialize(beats_per_bar, ticks_per_beat, sequencer: nil, do_log: nil, &block)
-    @sequencer ||= Musa::BaseSequencer.new beats_per_bar, ticks_per_beat, do_log: do_log
-    @context = DSLContext.new @sequencer
-
-    with &block if block
-  end
-
-  def reset
-    @sequencer.reset
-  end
-
-  class DSLContext
-    extend Forwardable
-
-    attr_reader :sequencer
-
-    def_delegators :@sequencer, :launch, :on,
-                   :position, :everying, :playing, :moving,
-                   :ticks_per_bar, :round, :log, :inspect
-
-    def initialize(sequencer)
-      @sequencer = sequencer
-    end
-
-    def with(*value_parameters, **key_parameters, &block)
-      block ||= proc {}
-
-      _as_context_run block, value_parameters, key_parameters
-    end
-
-    def now(*value_parameters, **key_parameters, &block)
-      block ||= proc {}
-
-      @sequencer.now *value_parameters, **key_parameters do |*value_args, **key_args|
-        _as_context_run block, value_args, key_args
-      end
-    end
-
-    def at(*value_parameters, **key_parameters, &block)
-      block ||= proc {}
-
-      @sequencer.at *value_parameters, **key_parameters do |*value_args, **key_args|
-        _as_context_run block, value_args, key_args
-      end
-    end
-
-    def wait(*value_parameters, **key_parameters, &block)
-      block ||= proc {}
-
-      @sequencer.wait *value_parameters, **key_parameters do | *values, **key_values |
-        _as_context_run block, values, key_values
-      end
-    end
-
-    def play(*value_parameters, **key_parameters, &block)
-      block ||= proc {}
-
-      @sequencer.play *value_parameters, **key_parameters do |*value_args, **key_args|
-        _as_context_run block, value_args, key_args
+require_relative '../core-ext/with'
+
+module Musa
+  module Sequencer
+    class Sequencer
+      extend Forwardable
+
+      def_delegators :@sequencer,
+                     :beats_per_bar, :ticks_per_beat, :ticks_per_bar, :tick_duration,
+                     :size, :empty?,
+                     :on_debug_at, :on_error, :on_fast_forward, :before_tick,
+                     :raw_at,
+                     :tick,
+                     :reset,
+                     :position=,
+                     :event_handler
+
+      def_delegators :@context, :position, :logger, :debug
+      def_delegators :@context, :with, :now, :at, :wait, :play, :every, :move
+      def_delegators :@context, :everying, :playing, :moving
+      def_delegators :@context, :launch, :on
+      def_delegators :@context, :run
+
+      def initialize(beats_per_bar, ticks_per_beat,
+                     sequencer: nil,
+                     logger: nil,
+                     do_log: nil, do_error_log: nil, log_position_format: nil,
+                     &block)
+
+        @sequencer = sequencer
+        @sequencer ||= BaseSequencer.new beats_per_bar, ticks_per_beat,
+                                         logger: logger,
+                                         do_log: do_log,
+                                         do_error_log: do_error_log,
+                                         log_position_format: log_position_format
+
+        @context = DSLContext.new @sequencer
+
+        with &block if block_given?
       end
-    end
 
-    def every(*value_parameters, **key_parameters, &block)
-      block ||= proc {}
-
-      @sequencer.every *value_parameters, **key_parameters do |*value_args, **key_args|
-        _as_context_run block, value_args, KeyParametersProcedureBinder.new(block).apply(key_args)
+      class DSLContext
+        extend Forwardable
+        include Musa::Extension::SmartProcBinder
+        include Musa::Extension::With
+
+        attr_reader :sequencer
+
+        def_delegators :@sequencer,
+                       :launch, :on,
+                       :position, :size, :everying, :playing, :moving,
+                       :ticks_per_bar, :logger, :debug, :inspect,
+                       :run
+
+        def initialize(sequencer)
+          @sequencer = sequencer
+        end
+
+        def now(*value_parameters, **key_parameters, &block)
+          block ||= proc {}
+
+          @sequencer.now *value_parameters, **key_parameters do |*value_args, **key_args|
+            with *value_args, **key_args, &block
+          end
+        end
+
+        def at(*value_parameters, **key_parameters, &block)
+          block ||= proc {}
+
+          @sequencer.at *value_parameters, **key_parameters do |*value_args, **key_args|
+            with *value_args, **key_args, &block
+          end
+        end
+
+        def wait(*value_parameters, **key_parameters, &block)
+          block ||= proc {}
+          @sequencer.wait *value_parameters, **key_parameters do | *values, **key_values |
+            with *values, **key_values, &block
+          end
+        end
+
+        def play(*value_parameters, **key_parameters, &block)
+          block ||= proc {}
+
+          @sequencer.play *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 {}
+
+          @sequencer.every *value_parameters, **key_parameters do |*value_args, **key_args|
+            args = SmartProcBinder.new(block)._apply(value_args, key_args)
+            with *args.first, **args.last, &block
+          end
+        end
+
+        def move(*value_parameters, **key_parameters, &block)
+          block ||= proc {}
+
+          @sequencer.move *value_parameters, **key_parameters do |*value_args, **key_args|
+            with *value_args, **key_args, &block
+          end
+        end
       end
-    end
 
-    def move(*value_parameters, **key_parameters, &block)
-      block ||= proc {}
-
-      @sequencer.move *value_parameters, **key_parameters do |*value_args, **key_args|
-        _as_context_run block, value_args, key_args
-      end
+      private_constant :DSLContext
     end
   end
-
-  private_constant :DSLContext
 end
+

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

@@ -0,0 +1,34 @@
+require 'set'
+
+module Musa
+  module Sequencer
+    class BaseSequencer
+      class Timeslots < Hash
+
+        def initialize(*several_variants)
+          super
+          @sorted_keys = SortedSet.new
+        end
+
+        def []=(key, value)
+          super
+          @sorted_keys << key
+        end
+
+        def delete(key)
+          super
+          @sorted_keys.delete key
+
+        end
+
+        def first_after(position)
+          if position.nil?
+            @sorted_keys.first
+          else
+            @sorted_keys.find { |k| k >= position }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/musa-dsl/series.rb

@@ -1 +1 @@
-require 'musa-dsl/series/series'
+require_relative 'series/series'

data/lib/musa-dsl/{core-ext → series}/array-to-serie.rb

@@ -1,4 +1,4 @@
-require 'musa-dsl/series'
+require_relative '../series'
 
 class Array
   def to_serie(of_series: nil, recursive: nil)

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

@@ -1,245 +1,248 @@
-require 'musa-dsl/core-ext/duplicate'
-require 'musa-dsl/generative/generative-grammar'
+require_relative '../core-ext/deep-copy'
+require_relative '../generative/generative-grammar'
+
+using Musa::Extension::DeepCopy
 
 module Musa
-  module SerieOperations end
+  module Series
+    module SerieOperations end
 
-  module SeriePrototyping
-    def prototype?
-      @is_instance ? false : true
-    end
+    module SeriePrototyping
+      def prototype?
+        @is_instance ? false : true
+      end
 
-    def instance?
-      @is_instance ? true : false
-    end
+      def instance?
+        @is_instance ? true : false
+      end
 
-    def prototype
-      if @is_instance
-        @instance_of || (@instance_of = clone.tap(&:_prototype).mark_as_prototype!)
-      else
-        self
+      def prototype
+        if @is_instance
+          @instance_of || (@instance_of = clone.tap(&:_prototype).mark_as_prototype!)
+        else
+          self
+        end
       end
-    end
 
-    def _prototype
-      nil
-    end
+      def _prototype
+        nil
+      end
 
-    alias_method :p, :prototype
+      alias_method :p, :prototype
 
-    def mark_as_prototype!
-      @is_instance = nil
-      freeze
-    end
+      def mark_as_prototype!
+        @is_instance = nil
+        freeze
+      end
 
-    protected :_prototype, :mark_as_prototype!
+      protected :_prototype, :mark_as_prototype!
 
-    def mark_regarding!(source)
-      if source.prototype?
-        mark_as_prototype!
-      else
-        mark_as_instance!
+      def mark_regarding!(source)
+        if source.prototype?
+          mark_as_prototype!
+        else
+          mark_as_instance!
+        end
       end
-    end
 
-    protected :mark_regarding!
+      protected :mark_regarding!
 
-    def instance
-      if @is_instance
-        self
-      else
-        clone(freeze: false).tap(&:_instance).mark_as_instance!(self)
+      def instance
+        if @is_instance
+          self
+        else
+          clone(freeze: false).tap(&:_instance).mark_as_instance!(self)
+        end
       end
-    end
 
-    alias_method :i, :instance
+      alias_method :i, :instance
 
-    def _instance
-      nil
-    end
+      def _instance
+        nil
+      end
 
-    def mark_as_instance!(prototype = nil)
-      @instance_of = prototype
-      @is_instance = true
-      self
-    end
+      def mark_as_instance!(prototype = nil)
+        @instance_of = prototype
+        @is_instance = true
+        self
+      end
 
-    protected :_instance, :mark_as_instance!
+      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'
-        super message
+      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
+        end
       end
     end
-  end
 
-  module Serie
-    include SeriePrototyping
-    include SerieOperations
+    module Serie
+      include SeriePrototyping
+      include SerieOperations
 
-    def restart
-      raise PrototypingSerieError unless @is_instance
+      def restart
+        raise PrototypingSerieError unless @is_instance
 
-      @_have_peeked_next_value = false
-      @_peeked_next_value = nil
-      @_have_current_value = false
-      @_current_value = nil
+        @_have_peeked_next_value = false
+        @_peeked_next_value = nil
+        @_have_current_value = false
+        @_current_value = nil
 
-      _restart if respond_to? :_restart
+        _restart if respond_to? :_restart
 
-      self
-    end
+        self
+      end
 
-    def next_value
-      raise PrototypingSerieError unless @is_instance
+      def next_value
+        raise PrototypingSerieError 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
+        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
-      end
 
-      propagate_value @_current_value
+        propagate_value @_current_value
 
-      @_current_value
-    end
+        @_current_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 PrototypingSerieError unless @is_instance
 
-      unless @_have_peeked_next_value
-        @_have_peeked_next_value = true
-        @_peeked_next_value = _next_value
+        unless @_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 PrototypingSerieError unless @is_instance
 
-    def current_value
-      raise PrototypingSerieError unless @is_instance
+        @_current_value
+      end
 
-      @_current_value
-    end
+      def 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?
 
-      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.duplicate 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_constant :Nodificator
 
-    protected
+      protected
 
-    def propagate_value(value)
-      @_slaves.each { |s| s.push_next_value value } if @_slaves
-    end
+      def propagate_value(value)
+        @_slaves.each { |s| s.push_next_value value } if @_slaves
+      end
 
-    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
+
+      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
 
-  end
+    class Slave
+      include Serie
 
-  class Slave
-    include Serie
+      attr_reader :master
 
-    attr_reader :master
-
-    def initialize(master)
-      @master = master
-      @next_value = []
-    end
+      def initialize(master)
+        @master = master
+        @next_value = []
+      end
 
-    def _restart
-      throw OperationNotAllowedError, "SlaveSerie #{self}: slave series cannot be restarted"
-    end
+      def _restart
+        throw OperationNotAllowedError, "SlaveSerie #{self}: slave series cannot be restarted"
+      end
 
-    def next_value
-      value = @next_value.shift
+      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?
+        raise "Warning: slave serie #{self} has lost sync with his master serie #{@master}" if value.nil? && !@master.peek_next_value.nil?
 
-      propagate_value value
+        propagate_value value
 
-      value
-    end
+        value
+      end
 
-    def peek_next_value
-      value = @next_value.first
+      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?
+        raise "Warning: slave serie #{self} has lost sync with his master serie #{@master}" if value.nil? && !@master.peek_next_value.nil?
 
-      value
-    end
+        value
+      end
 
-    def infinite?
-      @master.infinite?
-    end
+      def infinite?
+        @master.infinite?
+      end
 
-    def push_next_value(value)
-      @next_value << value
+      def push_next_value(value)
+        @next_value << value
+      end
     end
   end
 end