musa-dsl 0.21.1 → 0.22.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6666b6d9729d138be960000a3dd86a517f9ed94031d74a6eab25b76052d45c5
-  data.tar.gz: a6806869e3f06e54bc5596f71c35cfff8a9513504653a889e57287d227990419
+  metadata.gz: 4498538210551ab83a9f167c0e9d8656c9c5b70c9bc51f97e99e540109e5de7e
+  data.tar.gz: 9957a89a6db2ed2a4e0d75900f2eb3e1051c6dfc3fcc25c40ed5da1ba8fb6957
 SHA512:
-  metadata.gz: 531fbb701e5774e11a1a1dc373308fada1f777c6b8c7981e8a27ffd1ddb3c242bc1e5723555553010d4ff10259c7c69cd2e2428b9d0eab65ef96ae8b13b14f7b
-  data.tar.gz: c2db1fae44b49ee11fd8dd5d764dee4c7416c4b7fb6ce075213f84207d54cd7b5cc6301f59a74a723b467a103c74c779f68f9a946c0fcdd92fefbe77d26758c0
+  metadata.gz: 6c2bbea949c5c22dba0247a6f2ce050f515383ddf23aedf1c0b5755d8d94ddf355ebc2beedee3b6c03aea758da905d393db4fd559f26bb52a667bc9f82cf023e
+  data.tar.gz: da8bf0de7ba0cc96d5e96188293b901135bd4f052218ead671783620cf294c40eed37f89a46220d2eefd32f3cc1e03634c392783efac9164e725635e70b0e1c4

data/lib/musa-dsl.rb

@@ -1,5 +1,5 @@
 module Musa
-  VERSION = '0.21.1'
+  VERSION = '0.22.1'
 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,37 @@ 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, base_duration: nil)
+      time_start ||= 0r
+      base_duration ||= 1/4r # TODO review incoherence between neumalang 1/4r base duration for quarter notes and general 1r size of bar
 
-      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?
+      # 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
 
-      raise ArgumentError,
-            "'sequencer' parameter should not be used when 'beats_per_bar' and 'ticks_per_beat' parameters are used" \
-            if sequencer && beats_per_bar
+      Musa::Series::E(clone, base_duration, context: { time: time_start }) do |p, base_duration, context: |
+        value = p.shift
 
-      run_sequencer = sequencer.nil?
+        if value
+          r = { time: context[:time], value: value } if !value.nil?
 
-      score ||= Musa::Datasets::Score.new
+          delta_time = p.shift
+          context[:time] += delta_time * base_duration if delta_time
 
-      sequencer ||= Sequencer.new(beats_per_bar, ticks_per_beat, do_log: do_log)
-
-      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

@@ -3,13 +3,14 @@ require 'logger'
 module Musa; module Logger
   class Logger < ::Logger
     def initialize(sequencer: nil, position_format: nil)
-      super STDERR
+      super STDERR, level: WARN
 
       @sequencer = sequencer
       @position_format = position_format || 3.3
 
+
       self.formatter = proc do |severity, time, progname, msg|
-        level = "[#{severity}]" unless severity == 'DEBUG'
+        level = "[#{severity}] " unless severity == 'DEBUG'
 
         if msg
           position = if @sequencer
@@ -21,7 +22,7 @@ module Musa; module Logger
 
           progname = "[#{progname}]" if progname
 
-          "#{position}#{level}#{progname}#{msg}\n"
+          "#{position}#{level}#{progname} #{msg}\n"
         else
           "\n"
         end

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

@@ -70,7 +70,6 @@ module Musa
         include Musa::Datasets
 
         def to_p(time_dimension, keep_time: nil)
-
           decompose(self.to_a, time_dimension).collect do |points|
             line = []
 
@@ -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