musa-dsl 0.21.5 → 0.22.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46172601ed5c7fc82111b9ef5d669006f581e9ea4ebb0c36ef6c7108c9e0107e
-  data.tar.gz: aff0114b7c5a87e5e158eb5ff88882e0adfe4e39a8b7531f8aff323425e133f4
+  metadata.gz: fe8d0a64e4ba5518c7ed0fe4b75fffbf059217ef65e83025889a21d1c830a6e7
+  data.tar.gz: a78c43004243d81a9411c42e34338ecfe4ca7ef17322417dc2e8eb9a953b9abd
 SHA512:
-  metadata.gz: 113e51f155961205cf92897802108124b1f953e7d2d690fcf11582d014c828af3ab13880ac6f69eefbd6fbdfca8d2eb9c96dfd507cd0bf42be87cdb654781753
-  data.tar.gz: b8a67793161526eff6a8be4dcd412da2d093228ff95b88c039973a5857da431b93e714b3e6d0d895462e6488a9368564c39b01ebaa6098c36ce7046269b20549
+  metadata.gz: 6bf51f55471c9a753ec648cb1c223ef0564307d2807ec0c569a144856ef330ca7567e8ed4f8f0f651e1808ea42712c02c686ac123424d0feaa90955e2f6d77fe
+  data.tar.gz: 2bd503000a0d7cd2bd0e74f9790cbf5533335bc7d74cc6846cb60ea3bad4f1fd3fb24e74ed0bd1c6955b476d45274f51047202c89e12582e5fd642753d34144e

data/lib/musa-dsl.rb

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

data/lib/musa-dsl/core-ext.rb

@@ -1,5 +1,6 @@
 require_relative 'core-ext/array-explode-ranges'
 require_relative 'core-ext/arrayfy'
+require_relative 'core-ext/hashify'
 require_relative 'core-ext/deep-copy'
 require_relative 'core-ext/smart-proc-binder'
 require_relative 'core-ext/inspect-nice'

data/lib/musa-dsl/core-ext/arrayfy.rb

@@ -4,28 +4,28 @@ module Musa
   module Extension
     module Arrayfy
       refine Object do
-        def arrayfy(size: nil)
+        def arrayfy(size: nil, default: nil)
           if size
-            size.times.collect { self }
-          else
-            if nil?
-              []
-            else
-              [self]
+            size.times.collect do
+              nil? ? default : self
             end
+          else
+            nil? ? [] : [self]
           end
         end
       end
 
+      # TODO add a refinement for Hash? Should receive a list parameter with the ordered keys
+
       refine Array do
-        def arrayfy(size: nil)
+        def arrayfy(size: nil, default: nil)
           if size
             DeepCopy::DeepCopy.copy_singleton_class_modules(
                 self,
                 (self * (size / self.size + ((size % self.size).zero? ? 0 : 1) )).take(size))
           else
             self.clone
-          end
+          end.map! { |value| value.nil? ? default : value }
         end
       end
     end

data/lib/musa-dsl/core-ext/hashify.rb

@@ -0,0 +1,42 @@
+require_relative 'deep-copy'
+
+module Musa
+  module Extension
+    module Hashify
+      refine Object do
+        def hashify(keys:, default: nil)
+          keys.collect do |key|
+            [ key,
+              if nil?
+                default
+              else
+                self
+              end ]
+          end.to_h
+        end
+      end
+
+      refine Array do
+        def hashify(keys:, default: nil)
+          values = clone
+          keys.collect do |key|
+            value = values.shift
+            [ key,
+              value.nil? ? default : value ]
+          end.to_hash
+        end
+      end
+
+      refine Hash do
+        def hashify(keys:, default: nil)
+          keys.collect do |key|
+            value = self[key]
+            [ key,
+              value.nil? ? default : value ]
+          end.to_h
+              .tap {|_| DeepCopy::DeepCopy.copy_singleton_class_modules(self, _) }
+        end
+      end
+    end
+  end
+end

data/lib/musa-dsl/core-ext/inspect-nice.rb

@@ -12,6 +12,11 @@ module Musa
         alias to_s inspect
       end
 
+
+      refine Rational.singleton_class do
+        attr_accessor :to_s_as_inspect
+      end
+
       refine Rational do
         def inspect(simple: nil)
           value = self.abs
@@ -38,7 +43,7 @@ module Musa
         end
 
         def to_s
-          inspect simple: true
+          inspect simple: true # !Rational.to_s_as_inspect
         end
       end
     end

data/lib/musa-dsl/datasets/e.rb

@@ -5,11 +5,21 @@ module Musa::Datasets
     include Dataset
 
     NaturalKeys = [].freeze
+
+    # TODO implement valid? in all 'subclasses'. This implies recollecting from other places where validations are done and refactoring
+    # TODO should valid? and validate! be on Dataset instead of E? P dataset inherits from Dataset but probably it could be validated
+    #
+    def valid?
+      true
+    end
+
+    def validate!
+      raise RuntimeError, "Invalid dataset #{self}" unless valid?
+    end
   end
 
   module Abs
     include E
-    def duration; 0; end
   end
 
   module Delta
@@ -20,6 +30,12 @@ module Musa::Datasets
     include Abs
   end
 
+  module AbsTimed
+    include Abs
+
+    NaturalKeys = (NaturalKeys + [:time]).freeze
+  end
+
   module DeltaI
     include Delta
   end
@@ -27,10 +43,11 @@ module Musa::Datasets
   module AbsD
     include Abs
 
-    NaturalKeys = [:duration, # duration of the process (note reproduction, dynamics evolution, etc)
-                   :note_duration, # duration of the note (a staccato note is effectvely shorter than elapsed duration until next note)
-                   :forward_duration # duration to wait until next event (if 0 means the next event should be executed at the same time than this one)
-    ].freeze
+    NaturalKeys = (NaturalKeys +
+                   [:duration, # duration of the process (note reproduction, dynamics evolution, etc)
+                    :note_duration, # duration of the note (a staccato note is effectvely shorter than elapsed duration until next note)
+                    :forward_duration # duration to wait until next event (if 0 means the next event should be executed at the same time than this one)
+                   ]).freeze
 
     def forward_duration
       self[:forward_duration] || self[:duration]

data/lib/musa-dsl/datasets/gdv.rb

@@ -9,7 +9,6 @@ using Musa::Extension::InspectNice
 module Musa::Datasets
   module GDV
     include AbsD
-    include AbsI
 
     include Helper
 

data/lib/musa-dsl/datasets/p.rb

@@ -1,18 +1,19 @@
 require_relative 'dataset'
 require_relative 'ps'
 
+require_relative '../series'
 require_relative '../sequencer'
 
 module Musa::Datasets
   module P
     include Dataset
 
-    def to_ps_serie(base_duration = nil)
-      base_duration ||= 1/4r
+    def to_ps_serie(base_duration: nil)
+      base_duration ||= 1/4r # TODO review incoherence between neumalang 1/4r base duration for quarter notes and general 1r size of bar
 
-      p = clone
+      # TODO if instead of using clone (needed because of p.shift) we use index counter the P elements would be evaluated on the last moment
 
-      Musa::Series::E() do
+      Musa::Series::E(clone, base_duration) do |p, base_duration|
         (p.size >= 3) ?
           { from: p.shift,
             duration: p.shift * base_duration,
@@ -21,47 +22,39 @@ module Musa::Datasets
       end
     end
 
-    def to_score(score: nil,
-                 mapper: nil,
-                 position: nil,
-                 sequencer: nil,
-                 beats_per_bar: nil, ticks_per_beat: nil,
-                 right_open: nil,
-                 do_log: nil,
-                 &block)
+    def to_timed_serie(time_start: nil, time_start_component: nil, base_duration: nil)
+      time_start ||= 0r
+      time_start += self.first[time_start_component] if time_start_component
 
-      raise ArgumentError,
-            "'beats_per_bar' and 'ticks_per_beat' parameters should be both nil or both have values" \
-              unless beats_per_bar && ticks_per_beat || beats_per_bar.nil? && ticks_per_beat.nil?
+      base_duration ||= 1/4r # TODO review incoherence between neumalang 1/4r base duration for quarter notes and general 1r size of bar
 
-      raise ArgumentError,
-            "'sequencer' parameter should not be used when 'beats_per_bar' and 'ticks_per_beat' parameters are used" \
-            if sequencer && beats_per_bar
+      # TODO if instead of using clone (needed because of p.shift) we use index counter the P elements would be evaluated on the last moment
 
-      run_sequencer = sequencer.nil?
+      Musa::Series::E(clone, base_duration, context: { time: time_start }) do |p, base_duration, context: |
+        value = p.shift
 
-      score ||= Musa::Datasets::Score.new
+        if value
+          r = { time: context[:time], value: value } if !value.nil?
 
-      sequencer ||= Sequencer.new(beats_per_bar, ticks_per_beat, do_log: do_log)
+          delta_time = p.shift
+          context[:time] += delta_time * base_duration if delta_time
 
-      sequencer.at(position || 1r) do |_|
-
-          _.play to_ps_serie do |_, line|
-
-            line.to_score(sequencer: _,
-                          score: score,
-                          mapper: mapper,
-                          position: _.position,
-                          right_open: right_open,
-                          &block)
+          r&.extend(AbsTimed)
         end
       end
+    end
 
-      if run_sequencer
-        sequencer.run
-        score
-      else
-        nil
+    def map(&block)
+      i = 0
+      clone.map! do |element|
+        # Process with block only the values (values are the alternating elements because P
+        # structure is <value> <duration> <value> <duration> <value>)
+        #
+        if (i += 1) % 2 == 1
+          block.call(element)
+        else
+          element
+        end
       end
     end
   end

data/lib/musa-dsl/datasets/pdv.rb

@@ -6,7 +6,6 @@ require_relative 'helper'
 module Musa::Datasets
   module PDV
     include AbsD
-    include AbsI
 
     include Helper
 

data/lib/musa-dsl/datasets/ps.rb

@@ -29,85 +29,17 @@ module Musa::Datasets
       # TODO ?????
     end
 
-    def to_score(score: nil,
-                 mapper: nil,
-                 position: nil,
-                 sequencer: nil,
-                 beats_per_bar: nil, ticks_per_beat: nil,
-                 right_open: nil,
-                 do_log: nil,
-                 &block)
-
-      raise ArgumentError,
-            "'beats_per_bar' and 'ticks_per_beat' parameters should be both nil or both have values" \
-              unless beats_per_bar && ticks_per_beat || beats_per_bar.nil? && ticks_per_beat.nil?
-
-      raise ArgumentError,
-            "'sequencer' parameter should not be used when 'beats_per_bar' and 'ticks_per_beat' parameters are used" \
-            if sequencer && beats_per_bar
-
-      run_sequencer = sequencer.nil?
-
-      binder = Musa::Extension::SmartProcBinder::SmartProcBinder.new(block)
-
-      score ||= Musa::Datasets::Score.new
-
-      sequencer ||= Musa::Sequencer::Sequencer.new(beats_per_bar, ticks_per_beat, do_log: do_log)
-
-      ticks_per_bar = sequencer.ticks_per_bar
-
-      from = mapper && self[:from].is_a?(V) ? self[:from].to_packed_V(mapper) : self[:from]
-      to = mapper && self[:to].is_a?(V) ? self[:to].to_packed_V(mapper) : self[:to]
-
-      if right_open.is_a?(Array)
-        right_open = right_open.collect do |v|
-          v.is_a?(Symbol) ? v : mapper[v]
-        end
-      end
-
-      # TODO sequencer step should be 1????
-      #
-      sequencer.at(position || 1r) do |_|
-        _.move from: from,
-               to: to,
-               right_open: right_open,
-               duration: _quantize(self[:duration], ticks_per_bar),
-               step: 1 do
-          | _,
-            value, next_value,
-            duration:,
-            quantized_duration:,
-            position_jitter:, duration_jitter:,
-            started_ago:|
-
-          binder.call value, next_value,
-                      position: _.position,
-                      duration: duration,
-                      quantized_duration: quantized_duration,
-                      position_jitter: position_jitter,
-                      duration_jitter: duration_jitter,
-                      started_ago: started_ago,
-                      score: score,
-                      logger: _.logger
-        end
-      end
-
-      if run_sequencer
-        sequencer.run
-        score
-      else
-        nil
-      end
-    end
-
-    private
-
-    def _quantize(duration, ticks_per_bar)
-      if ticks_per_bar &.< Float::INFINITY
-        ((duration.rationalize * ticks_per_bar).round / ticks_per_bar).to_r
+    def valid?
+      case self[:from]
+      when Array
+        self[:to].is_a?(Array) &&
+            self[:from].size == self[:to].size
+      when Hash
+        self[:to].is_a?(Hash) &&
+            self[:from].keys == self[:to].keys
       else
-        duration.rationalize
-      end
+        false
+      end && self[:duration].is_a?(Numeric) && self[:duration] > 0
     end
   end
 end

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

@@ -20,9 +20,9 @@ module Musa; module Logger
                        "%#{integer_digits + decimal_digits + 1}s: " % ("%.#{decimal_digits}f" % sequencer.position.to_f)
                      end
 
-          progname = "[#{progname}] " if progname
+          progname = "[#{progname}]" if progname
 
-          "#{position}#{level}#{progname}#{msg}\n"
+          "#{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,15 +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]
@@ -85,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
@@ -94,62 +93,6 @@ module Musa
           end
         end
 
-        def to_score(time_dimension,
-                     mapper: nil,
-                     score: nil,
-                     position: nil,
-                     sequencer: nil,
-                     beats_per_bar: nil, ticks_per_beat: nil,
-                     right_open: nil,
-                     do_log: nil,
-                     &block)
-
-          raise ArgumentError,
-                "'beats_per_bar' and 'ticks_per_beat' parameters should be both nil or both have values" \
-              unless beats_per_bar && ticks_per_beat ||
-                     beats_per_bar.nil? && ticks_per_beat.nil?
-
-          raise ArgumentError,
-                "'sequencer' parameter should not be used when 'beats_per_bar' and 'ticks_per_beat' parameters are used" \
-            if sequencer && beats_per_bar
-
-          raise ArgumentError,
-                "'time_dimension' parameter should be an index number if no 'mapping' is provided" \
-            unless time_dimension.is_a?(Symbol) && mapper&.include?(time_dimension) ||
-                   time_dimension.is_a?(Integer) && (0..self.column_size-1).include(time_dimension)
-
-          time_dimension = mapper&.find_index(time_dimension) if time_dimension.is_a?(Symbol)
-
-          mapper = mapper.clone.tap { |_| _.delete_at(time_dimension) } if mapper
-
-          run_sequencer = sequencer.nil?
-
-          score ||= Musa::Datasets::Score.new
-
-          sequencer ||= Sequencer::Sequencer.new(beats_per_bar, ticks_per_beat, do_log: do_log)
-
-          right_open = right_open.clone.tap { |_| _.delete_at(time_dimension) } if right_open&.is_a?(Array)
-
-          sequencer.at(position || 1r) do |_|
-            to_p(time_dimension).each do |p|
-              p.to_score(score: score,
-                         mapper: mapper,
-                         sequencer: _,
-                         position: _.position,
-                         right_open: right_open,
-                         do_log: do_log,
-                         &block)
-            end
-          end
-
-          if run_sequencer
-            sequencer.run
-            score
-          else
-            nil
-          end
-        end
-
         def _rows
           @rows
         end
@@ -164,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]
@@ -182,8 +126,9 @@ module Musa
 
                 directional_segments << a if a.size > 1
 
+                #
                 # y hacia el otro
-
+                #
                 i = index
                 xx = array[i][time_dimension]