musa-dsl 0.22.2 → 0.23.0

data/lib/musa-dsl/generative/backboner.rb

@@ -3,13 +3,8 @@ require_relative '../core-ext/with'
 
 using Musa::Extension::Arrayfy
 
-# incluir With -> hecho
-# eliminar method_missing
-# crear rama tb debe recibir la serie de la history -> ya lo hace
-# crear rama puede repetirse (hasta terminar según ended_when) -> no
-#
-# hacer que pueda funcionar en tiempo real? le vas suministrando seeds y le vas diciendo qué opción has elegido (p.ej. para hacer un armonizador en tiempo real)
-# esto mismo sería aplicable en otros generadores? variatio/darwin? generative-grammar? markov?
+# TODO hacer que pueda funcionar en tiempo real? le vas suministrando seeds y le vas diciendo qué opción has elegido (p.ej. para hacer un armonizador en tiempo real)
+# TODO esto mismo sería aplicable en otros generadores? variatio/darwin? generative-grammar? markov?
 
 module Musa
   module Backboner
@@ -17,12 +12,12 @@ module Musa
       include Musa::Extension::With
 
       def initialize(&block)
-        @context = RulesEvalContext.new(&block)
+        @dsl = RulesEvalContext.new(&block)
       end
 
       def generate_possibilities(object, confirmed_node = nil, node = nil, grow_rules = nil)
         node ||= Node.new
-        grow_rules ||= @context._grow_rules
+        grow_rules ||= @dsl._grow_rules
 
         history = confirmed_node.history if confirmed_node
         history ||= []
@@ -33,9 +28,9 @@ module Musa
         if grow_rule
           grow_rule.generate_possibilities(object, history).each do |new_object|
             new_node = Node.new new_object, node
-            new_node.mark_as_ended! if @context._ended? new_object
+            new_node.mark_as_ended! if @dsl._ended? new_object
 
-            rejection = @context._cut_rules.find { |cut_rule| cut_rule.rejects?(new_object, history) }
+            rejection = @dsl._cut_rules.find { |cut_rule| cut_rule.rejects?(new_object, history) }
             # TODO: include rejection secondary reasons in rejection message
 
             new_node.reject! rejection if rejection

data/lib/musa-dsl/generative/generative-grammar.rb

@@ -100,9 +100,7 @@ module Musa
           options[index].to_serie.to_node
         end
 
-        def to_serie(flatten: nil, &condition)
-          flatten ||= true
-
+        def to_serie(flatten: true, &condition)
           serie = _options(&condition).collect { |o| o.collect(&:content) }.to_serie(of_series: true).merge
           serie = serie.flatten if flatten
 

data/lib/musa-dsl/generative/markov.rb

@@ -7,9 +7,8 @@ module Musa
   module Markov
     class Markov
       include Musa::Extension::SmartProcBinder
-      include Musa::Series::Serie
+      include Musa::Series::Serie.base
 
-      attr_accessor :start, :finish, :random, :transitions
 
       def initialize(transitions:, start:, finish: nil, random: nil)
         @transitions = transitions.clone.freeze
@@ -22,23 +21,28 @@ module Musa
 
         @procedure_binders = {}
 
-        _restart
+        init
       end
 
-      def _restart
+      attr_accessor :start
+      attr_accessor :finish
+      attr_accessor :random
+      attr_accessor :transitions
+
+      private def _init
         @current = nil
         @finished = false
         @history = []
       end
 
-      def _next_value
+      private def _next_value
         if @finished
           @current = nil
         else
           if @current.nil?
             @current = @start
           else
-            if @transitions.has_key? @current
+            if @transitions.has_key?(@current)
               options = @transitions[@current]
 
               case options

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

@@ -1,7 +1,12 @@
 require 'logger'
 
+require_relative '../core-ext/inspect-nice'
+
+
 module Musa; module Logger
   class Logger < ::Logger
+    using Musa::Extension::InspectNice
+
     def initialize(sequencer: nil, position_format: nil)
       super STDERR, level: WARN
 
@@ -22,7 +27,7 @@ module Musa; module Logger
 
           progname = "[#{progname}]" if progname
 
-          "#{position}#{level}#{progname} #{msg}\n"
+          "#{position}#{level}#{progname}#{' ' if position || level || progname}#{msg}\n"
         else
           "\n"
         end

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

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

data/lib/musa-dsl/midi/midi-voices.rb

@@ -169,6 +169,7 @@ module Musa
       private_constant :ControllersControl
 
       class NoteControl
+        attr_reader :voice, :pitch, :velocity, :velocity_off, :duration
         attr_reader :start_position, :end_position
 
         def initialize(voice, pitch:, velocity: nil, duration: nil, velocity_off: nil)

data/lib/musa-dsl/music/scales.rb

@@ -303,7 +303,7 @@ module Musa
 
       def [](grade_or_symbol)
 
-        raise ArgumentError, "grade_or_symbol '#{grade_or_symbol}' should be a Numeric, String or Symbol" unless grade_or_symbol.is_a?(Symbol) || grade_or_symbol.is_a?(String) || grade_or_symbol.is_a?(Integer)
+        raise ArgumentError, "grade_or_symbol '#{grade_or_symbol}' should be a Integer, String or Symbol" unless grade_or_symbol.is_a?(Symbol) || grade_or_symbol.is_a?(String) || grade_or_symbol.is_a?(Integer)
 
         wide_grade, sharps = grade_of(grade_or_symbol)
 

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

@@ -15,7 +15,7 @@ module Musa
           include Musa::Neumas
 
           def value
-            _SE(captures(:expression).collect(&:value), extends: Neuma::Serie)
+            S(*captures(:expression).collect(&:value)).extend(Neuma::Serie)
           end
         end
 

data/lib/musa-dsl/neumas/array-to-neumas.rb

@@ -21,7 +21,7 @@ module Musa
         def convert_to_neumas(e)
           case e
           when Musa::Neumas::Neuma::Serie then e
-          when Musa::Neumas::Neuma::Parallel then _SE([e], extends: Musa::Neumas::Neuma::Serie)
+          when Musa::Neumas::Neuma::Parallel then S(e).extend(Musa::Neumas::Neuma::Serie)
           when String then e.to_neumas
           else
             raise ArgumentError, "Don't know how to convert to neumas #{e}"

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

@@ -262,11 +262,11 @@ module Musa
 
           when Musa::Series::Serie
             { current_operation: :play,
-              current_parameter: element.restart }
+              current_parameter: element.instance.restart }
 
           when Parallel
             { current_operation: :parallel_play,
-              current_parameter: element.tap { |e| e.each(&:restart) } }
+              current_parameter: element.instance.tap { |e| e.each(&:restart) } }
 
           when Array
             { current_operation: :no_eval_play,
@@ -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,181 +7,82 @@ module Musa; module Sequencer
   class BaseSequencer
     private def _play_timed(timed_serie,
                     control,
-                    reference: nil,
-                    step: nil,
-                    right_open: nil,
                     &block)
 
-      reference ||= 0r
-      step ||= 1r
-
       if first_value_sample = timed_serie.peek_next_value
-
         debug "_play_timed: first_value_sample #{first_value_sample}"
 
         hash_mode = first_value_sample[:value].is_a?(Hash)
 
         if hash_mode
-          components = first_value_sample[:value].keys
-
-          reference = reference.hashify(keys: components)
-          step = step.hashify(keys: components)
-          right_open = right_open.hashify(keys:components)
+          component_ids = first_value_sample[:value].keys
         else
           size = first_value_sample[:value].size
-          components = (0 .. size-1).to_a
-
-          reference = reference.arrayfy(size: size)
-          step = step.arrayfy(size: size)
-          right_open = right_open.arrayfy(size: size)
-        end
-
-        split = timed_serie.flatten_timed.split
-        quantized_series = hash_mode ? {} : []
-
-        components.each do |component|
-          quantized_series[component] =
-              QUANTIZE(split[component],
-                       reference: reference[component],
-                       step: step[component],
-                       right_open: right_open[component],
-                       stops: true).instance
+          component_ids = (0 .. size-1).to_a
         end
+        extra_attribute_names = Set[*(first_value_sample.keys - [:time, :value])]
 
         last_positions = hash_mode ? {} : []
       end
 
       binder = SmartProcBinder.new(block)
 
-      _play_timed_step(hash_mode, components, quantized_series, position, last_positions, binder, control)
+      _play_timed_step(hash_mode, component_ids, extra_attribute_names, timed_serie,
+                       position, last_positions, binder, control)
     end
 
-
-    private def _play_timed_step(hash_mode, components, quantized_series, start_position, last_positions,
+    private def _play_timed_step(hash_mode,
+                                 component_ids, extra_attribute_names,
+                                 timed_serie,
+                                 start_position,
+                                 last_positions,
                                  binder, control)
 
-      affected_components_by_time = {}
-
-      components.each do |component|
-        if v = quantized_series[component].peek_next_value
+      source_next_value = timed_serie.next_value
 
-          debug "_play_timed_step: quantized_series[#{component}].peek_next_value #{v}"
-          time = v[:time]
-
-          affected_components_by_time[time] ||= []
-          affected_components_by_time[time] << component
-        end
-      end
+      affected_components = component_ids.select { |_| !source_next_value[:value][_].nil? } if source_next_value
 
-      if affected_components_by_time.any?
-        time = affected_components_by_time.keys.sort.first
+      if affected_components && affected_components.any?
+        time = source_next_value[:time]
 
         values = hash_mode ? {} : []
-        next_values = hash_mode ? {} : []
-        durations = hash_mode ? {} : []
-        q_durations = hash_mode ? {} : []
+        extra_attributes = extra_attribute_names.collect { |_| [_, hash_mode ? {} : []] }.to_h
         started_ago = hash_mode ? {} : []
 
-        affected_components_by_time[time].each do |component|
-          value = quantized_series[component].next_value
-
-          values[component] = value[:value]
-          durations[component] = value[:duration]
-
-          q_durations[component] =
-              _quantize_position(time + durations[component], warn: false) -
-              _quantize_position(time, warn: false)
+        affected_components.each do |component|
+          values[component] = source_next_value[:value][component]
 
-          nv = quantized_series[component].peek_next_value
-          next_values[component] = (nv && nv[:value] != values[component]) ? nv[:value] : nil
+          extra_attribute_names.each do |attribute_name|
+            extra_attributes[attribute_name][component] = source_next_value[attribute_name][component]
+          end
 
           last_positions[component] = _quantize_position(time, warn: false)
         end
 
-        components.each do |component|
+        component_ids.each do |component|
           if last_positions[component] && last_positions[component] != time
             sa = _quantize_position(time, warn: false) - last_positions[component]
             started_ago[component] = (sa == 0) ? nil : sa
           end
         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,
+        _numeric_at _quantize_position(start_position + time, warn: true), control do
+          binder.call(values,
+                      **extra_attributes,
+                      time: start_position + time,
                       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