musa-dsl 0.14.32 → 0.21.0

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

@@ -0,0 +1,179 @@
+require_relative 'delta-d'
+require_relative 'gdv'
+
+require_relative 'helper'
+
+using Musa::Extension::InspectNice
+
+module Musa::Datasets
+  module GDVd
+    include DeltaD
+    include DeltaI
+
+    include Helper
+
+    NaturalKeys = (NaturalKeys +
+                    [:abs_grade, :abs_sharps, :abs_octave,
+                     :delta_grade, :delta_sharps, :delta_interval_sign, :delta_interval, :delta_octave,
+                     :abs_velocity, :delta_velocity,
+                     :modifiers]).freeze
+
+    attr_reader :base_duration
+
+    def base_duration=(value)
+      factor = value / (@base_duration || 1)
+      @base_duration = value
+
+      self[:abs_duration] *= factor if has_key?(:abs_duration)
+      self[:delta_duration] *= factor if has_key?(:delta_duration)
+    end
+
+    def to_gdv(scale, previous:)
+      r = previous.clone.delete_if {|k,_| !GDV::NaturalKeys.include?(k)}.extend GDV
+
+      r.base_duration = @base_duration
+
+      if include?(:abs_grade)
+        if self[:abs_grade] == :silence
+          r[:silence] = true
+        else
+          r.delete :silence
+          r.delete :sharps
+
+          r[:grade] = scale[self[:abs_grade]].wide_grade
+          r[:sharps] = self[:abs_sharps] if include?(:abs_sharps)
+        end
+
+      elsif include?(:delta_grade)
+        r.delete :silence
+
+        r[:grade], r[:sharps] =
+            normalize_to_scale(scale,
+                               scale[r[:grade]].wide_grade + self[:delta_grade],
+                               (r[:sharps] || 0) + (self[:delta_sharps] || 0))
+
+        r.delete :sharps if r[:sharps].zero?
+
+      elsif include?(:delta_interval)
+        r.delete :silence
+
+        sign = self[:delta_interval_sign] || 1
+
+        r[:grade], r[:sharps] =
+            normalize_to_scale scale,
+                               scale[r[:grade]].wide_grade,
+                               sign * scale.kind.tuning.scale_system.intervals[self[:delta_interval]]
+
+        r.delete :sharps if r[:sharps].zero?
+
+      elsif include?(:delta_sharps)
+        r.delete :silence
+
+        r[:grade], r[:sharps] =
+            normalize_to_scale scale,
+                               scale[r[:grade]].wide_grade,
+                               (r[:sharps] || 0) + self[:delta_sharps]
+
+        r.delete :sharps if r[:sharps].zero?
+      end
+
+      if include?(:abs_octave)
+        r[:octave] = self[:abs_octave]
+      elsif include?(:delta_octave)
+        r[:octave] += self[:delta_octave]
+      end
+
+      if include?(:abs_duration)
+        r[:duration] = self[:abs_duration]
+      elsif include?(:delta_duration)
+        r[:duration] += self[:delta_duration]
+      elsif include?(:factor_duration)
+        r[:duration] *= self[:factor_duration]
+      end
+
+      if include?(:abs_velocity)
+        r[:velocity] = self[:abs_velocity]
+      elsif include?(:delta_velocity)
+        r[:velocity] += self[:delta_velocity]
+      end
+
+      if include?(:modifiers)
+        self[:modifiers].each_pair do |k, v|
+          r[k] = v
+        end
+      end
+
+      (keys - NaturalKeys).each { |k| r[k] = self[k] }
+
+      r
+    end
+
+    def normalize_to_scale(scale, grade, sharps)
+      note = scale[grade].sharp(sharps)
+      background = note.background_note
+
+      if background
+        return background.wide_grade, note.background_sharps
+      else
+        return note.wide_grade, 0
+      end
+    end
+
+    def to_neuma
+      @base_duration ||= Rational(1,4)
+
+      attributes = []
+
+      c = 0
+
+      if include?(:abs_grade)
+        attributes[c] = self[:abs_grade].to_s
+
+      elsif include?(:delta_grade)
+        attributes[c] = positive_sign_of(self[:delta_grade]) + self[:delta_grade].to_s unless self[:delta_grade].zero?
+
+      elsif include?(:delta_interval)
+
+        attributes[c] = self[:delta_interval_sign] if include?(:delta_interval_sign)
+        attributes[c] ||= ''
+        attributes[c] += self[:delta_interval].to_s
+      end
+
+      if include?(:delta_sharps) && !self[:delta_sharps].zero?
+        char = self[:delta_sharps] > 0 ? '#' : '_'
+        sign = attributes[c].nil? ? positive_sign_of(self[:delta_sharps]) : ''
+
+        attributes[c] ||= ''
+        attributes[c] += sign + char * self[:delta_sharps].abs
+      end
+
+      attributes[c] = '.' if attributes[c].nil? || attributes[c].empty?
+
+      if include?(:abs_octave)
+        attributes[c += 1] = 'o' + self[:abs_octave].to_s
+      elsif include?(:delta_octave)
+        attributes[c += 1] = sign_of(self[:delta_octave]) + 'o' + self[:delta_octave].abs.to_s if self[:delta_octave] != 0
+      end
+
+      if include?(:abs_duration)
+        attributes[c += 1] = (self[:abs_duration] / @base_duration).to_s
+      elsif include?(:delta_duration)
+        attributes[c += 1] = positive_sign_of(self[:delta_duration]) + (self[:delta_duration] / @base_duration).to_s
+      elsif include?(:factor_duration)
+        attributes[c += 1] = '*' + self[:factor_duration].to_s
+      end
+
+      if include?(:abs_velocity)
+        attributes[c += 1] = velocity_of(self[:abs_velocity])
+      elsif include?(:delta_velocity)
+        attributes[c += 1] = sign_of(self[:delta_velocity]) + 'f' * self[:delta_velocity].abs
+      end
+
+      (keys - NaturalKeys).each do |k|
+        attributes[c += 1] = modificator_string(k, self[k])
+      end
+
+      '(' + attributes.join(' ') + ')'
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Musa::Datasets
+  module Helper
+    protected
+
+    def positive_sign_of(x)
+      x >= 0 ? '+' : ''
+    end
+
+    def sign_of(x)
+      '++-'[x <=> 0]
+    end
+
+    def velocity_of(x)
+      %w[ppp pp p mp mf f ff fff][x + 3]
+    end
+
+    def modificator_string(modificator, parameter_or_parameters)
+      case parameter_or_parameters
+      when true
+        modificator.to_s
+      when Array
+        "#{modificator.to_s}(#{parameter_or_parameters.collect { |p| parameter_to_string(p) }.join(', ')})"
+      else
+        "#{modificator.to_s}(#{parameter_to_string(parameter_or_parameters)})"
+      end
+    end
+
+    private
+
+    def parameter_to_string(parameter)
+      case parameter
+      when String
+        "\"#{parameter}\""
+      when Numeric
+        "#{parameter}"
+      when Symbol
+        "#{parameter}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require_relative 'dataset'
+require_relative 'ps'
+
+require_relative '../sequencer'
+
+module Musa::Datasets
+  module P
+    include Dataset
+
+    def to_ps_serie(base_duration = nil)
+      base_duration ||= 1/4r
+
+      p = clone
+
+      Musa::Series::E() do
+        (p.size >= 3) ?
+          { from: p.shift,
+            duration: p.shift * base_duration,
+            to: p.first,
+            right_open: (p.length > 1) }.extend(PS).tap { |_| _.base_duration = base_duration } : nil
+      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)
+
+      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?
+
+      score ||= Musa::Datasets::Score.new
+
+      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)
+        end
+      end
+
+      if run_sequencer
+        sequencer.run
+        score
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/musa-dsl/datasets/packed-v.rb

@@ -0,0 +1,19 @@
+require_relative 'e'
+require_relative 'v'
+
+module Musa::Datasets
+  module PackedV
+    include AbsI
+
+    def to_V(mapper)
+      case mapper
+      when Hash
+        mapper.collect { |key, default| self[key] || default }.extend(V)
+      when Array
+        mapper.collect { |key| self[key] }.extend(V)
+      else
+        raise ArgumentError, "Expected Hash or Array as mapper but got a #{mapper.class.name}"
+      end
+    end
+  end
+end

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

@@ -1,44 +1,51 @@
-require 'musa-dsl/neuma'
+require_relative 'e'
+require_relative 'gdv'
+
+require_relative 'helper'
 
 module Musa::Datasets
   module PDV
-    include Musa::Neumalang::Dataset
+    include AbsD
+    include AbsI
+
+    include Helper
 
-    NaturalKeys = [:pitch, :duration, :velocity].freeze
+    NaturalKeys = (NaturalKeys + [:pitch, :velocity]).freeze
 
     attr_accessor :base_duration
 
     def to_gdv(scale)
-      r = {}.extend Musa::Datasets::GDV
-      r.base_duration = @base_duration
+      gdv = {}.extend GDV
+      gdv.base_duration = @base_duration
 
       if self[:pitch]
         if self[:pitch] == :silence
-          r[:grade] = :silence
+          gdv[:grade] = :silence
         else
           note = scale.note_of_pitch(self[:pitch], allow_chromatic: true)
 
           if background_note = note.background_note
-            r[:grade] = background_note.grade
-            r[:octave] = background_note.octave
-            r[:sharps] = note.background_sharps
+            gdv[:grade] = background_note.grade
+            gdv[:octave] = background_note.octave
+            gdv[:sharps] = note.background_sharps
           else
-            r[:grade] = note.grade
-            r[:octave] = note.octave
+            gdv[:grade] = note.grade
+            gdv[:octave] = note.octave
           end
         end
       end
 
-      r[:duration] = self[:duration] if self[:duration]
+      gdv[:duration] = self[:duration] if self[:duration]
 
       if self[:velocity]
         # ppp = 16 ... fff = 127
-        r[:velocity] = [0..16, 17..32, 33..48, 49..64, 65..80, 81..96, 97..112, 113..127].index { |r| r.cover? self[:velocity] } - 3
+        # TODO create a customizable MIDI velocity to score dynamics bidirectional conversor
+        gdv[:velocity] = [1..1, 2..8, 9..16, 17..33, 34..49, 49..64, 65..80, 81..96, 97..112, 113..127].index { |r| r.cover? self[:velocity] } - 5
       end
 
-      (keys - NaturalKeys).each { |k| r[k] = self[k] }
+      (keys - NaturalKeys).each { |k| gdv[k] = self[k] }
 
-      r
+      gdv
     end
   end
 end

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

@@ -0,0 +1,113 @@
+require_relative 'e'
+require_relative 'score'
+
+require_relative '../sequencer'
+
+module Musa::Datasets
+  module PS
+    include AbsD
+
+    include Helper
+
+    NaturalKeys = (NaturalKeys + [:from, :to, :right_open]).freeze
+
+    attr_accessor :base_duration
+
+    def to_neuma
+      # TODO ???????
+    end
+
+    def to_pdv
+      # TODO ??????
+    end
+
+    def to_gdv
+      # TODO ?????
+    end
+
+    def to_absI
+      # 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
+      else
+        duration.rationalize
+      end
+    end
+  end
+end