musa-dsl 0.14.26 → 0.21.1

data/lib/musa-dsl/series/proxy-serie.rb

@@ -48,7 +48,7 @@ module Musa
 
       def method_missing(method_name, *args, **key_args, &block)
         if @target && @target.respond_to?(method_name)
-          @target.send_nice method_name, *args, **key_args, &block
+          @target.send method_name, *args, **key_args, &block
         else
           super
         end
@@ -58,12 +58,12 @@ module Musa
         @target && @target.respond_to?(method_name, include_private) # || super
       end
     end
-  end
 
-  module SerieOperations
-    # TODO add test case
-    def proxied
-      Series::ProxySerie.new self
+    module SerieOperations
+      # TODO add test case
+      def proxied
+        Series::ProxySerie.new self
+      end
     end
   end
 end

data/lib/musa-dsl/series/queue-serie.rb

@@ -74,7 +74,7 @@ module Musa
 
       def method_missing(method_name, *args, **key_args, &block)
         if @target && @target.respond_to?(method_name)
-          @target.send_nice method_name, *args, **key_args, &block
+          @target.send method_name, *args, **key_args, &block
         else
           super
         end
@@ -84,11 +84,11 @@ module Musa
         @target && @target.respond_to?(method_name, include_private) # || super
       end
     end
-  end
 
-  module SerieOperations
-    def queued
-      Series::QueueSerie.new [self]
+    module SerieOperations
+      def queued
+        Series::QueueSerie.new [self]
+      end
     end
   end
 end

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

@@ -6,3 +6,5 @@ require_relative 'hash-serie-splitter'
 require_relative 'holder-serie'
 require_relative 'proxy-serie'
 require_relative 'queue-serie'
+
+require_relative 'array-to-serie'

data/lib/musa-dsl/transcription.rb

@@ -0,0 +1,4 @@
+require_relative 'transcription/transcription'
+
+require_relative 'transcription/from-gdv-to-midi'
+require_relative 'transcription/from-gdv-to-musicxml'

data/lib/musa-dsl/transcription/from-gdv-to-midi.rb

@@ -0,0 +1,227 @@
+require_relative 'from-gdv'
+
+include Musa::Transcription
+
+module Musa::Transcriptors
+  module FromGDV
+    module ToMIDI
+      def self.transcription_set(duration_factor: nil)
+        [ Appogiatura.new,
+          Mordent.new(duration_factor: duration_factor),
+          Turn.new,
+          Trill.new(duration_factor: duration_factor),
+          Staccato.new,
+          Base.new ]
+      end
+
+      # Process: appogiatura (neuma)neuma
+      class Appogiatura < FeatureTranscriptor
+        def transcript(gdv, base_duration:, tick_duration:)
+          gdv_appogiatura = gdv.delete :appogiatura
+
+          if gdv_appogiatura
+            # TODO process with Decorators the gdv_appogiatura
+            # TODO implement also posterior appogiatura neuma(neuma)
+            # TODO implement also multiple appogiatura with several notes (neuma ... neuma)neuma or neuma(neuma ... neuma)
+
+            gdv[:duration] = gdv[:duration] - gdv_appogiatura[:duration]
+
+            super [ gdv_appogiatura, gdv ], base_duration: base_duration, tick_duration: tick_duration
+          else
+            super
+          end
+        end
+      end
+
+      # Process: .mor
+      class Mordent < FeatureTranscriptor
+        def initialize(duration_factor: nil)
+          @duration_factor = duration_factor || 1/4r
+        end
+
+        def transcript(gdv, base_duration:, tick_duration:)
+          mor = gdv.delete :mor
+
+          if mor
+            direction = :up
+
+            check(mor) do |mor|
+              case mor
+              when true, :up
+                direction = :up
+              when :down, :low
+                direction = :down
+              end
+            end
+
+            short_duration = [base_duration * @duration_factor, tick_duration].max
+
+            gdvs = []
+
+            gdvs << gdv.clone.tap { |gdv| gdv[:duration] = short_duration }
+
+            case direction
+            when :up
+              gdvs << gdv.clone.tap { |gdv| gdv[:grade] += 1; gdv[:duration] = short_duration }
+            when :down
+              gdvs << gdv.clone.tap { |gdv| gdv[:grade] -= 1; gdv[:duration] = short_duration }
+            end
+
+            gdvs << gdv.clone.tap { |gdv| gdv[:duration] -= 2 * short_duration }
+
+            super gdvs, base_duration: base_duration, tick_duration: tick_duration
+          else
+            super
+          end
+        end
+      end
+
+      # Process: .turn
+      class Turn < FeatureTranscriptor
+        def transcript(gdv, base_duration:, tick_duration:)
+          turn = gdv.delete :turn
+
+          if turn
+            start = :up
+
+            check(turn) do |turn|
+              case turn
+              when :true, :up
+                start = :up
+              when :down, :low
+                start = :down
+              end
+            end
+
+            duration = gdv[:duration] / 4r
+
+            gdvs = []
+
+            case start
+            when :up
+              gdvs << gdv.clone.tap { |gdv| gdv[:grade] += 1; gdv[:duration] = duration }
+              gdvs << gdv.clone.tap { |gdv| gdv[:grade] += 0; gdv[:duration] = duration }
+              gdvs << gdv.clone.tap { |gdv| gdv[:grade] += -1; gdv[:duration] = duration }
+              gdvs << gdv.clone.tap { |gdv| gdv[:grade] += 0; gdv[:duration] = duration }
+            when :down
+              gdvs << gdv.clone.tap { |gdv| gdv[:grade] += -1; gdv[:duration] = duration }
+              gdvs << gdv.clone.tap { |gdv| gdv[:grade] += 0; gdv[:duration] = duration }
+              gdvs << gdv.clone.tap { |gdv| gdv[:grade] += 1; gdv[:duration] = duration }
+              gdvs << gdv.clone.tap { |gdv| gdv[:grade] += 0; gdv[:duration] = duration }
+            end
+
+            super gdvs, base_duration: base_duration, tick_duration: tick_duration
+          else
+            super
+          end
+        end
+      end
+
+      # Process: .tr
+      class Trill < FeatureTranscriptor
+        def initialize(duration_factor: nil)
+          @duration_factor = duration_factor || 1/4r
+        end
+
+        def transcript(gdv, base_duration:, tick_duration:)
+          tr = gdv.delete :tr
+
+          if tr
+            note_duration = base_duration * @duration_factor
+
+            check(tr) do |tr|
+              case tr
+              when Numeric # duration factor
+                note_duration *= base_duration * tr.to_r
+              end
+            end
+
+            used_duration = 0r
+            last = nil
+
+            gdvs = []
+
+            check(tr) do |tr|
+              case tr
+              when :low # start with lower note
+                gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = -1); gdv[:duration] = note_duration }
+                gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 0); gdv[:duration] = note_duration }
+                used_duration += 2 * note_duration
+
+              when :low2 # start with upper note but go to lower note once
+                gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 1); gdv[:duration] = note_duration }
+                gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 0); gdv[:duration] = note_duration }
+                gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = -1); gdv[:duration] = note_duration }
+                gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 0); gdv[:duration] = note_duration }
+                used_duration += 4 * note_duration
+
+              when :same # start with the same note
+                gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 0); gdv[:duration] = note_duration }
+                used_duration += note_duration
+              end
+            end
+
+            2.times do
+              if used_duration + 2 * note_duration <= gdv[:duration]
+                gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 1); gdv[:duration] = note_duration }
+                gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 0); gdv[:duration] = note_duration }
+
+                used_duration += 2 * note_duration
+              end
+            end
+
+            while used_duration + 2 * note_duration * 2/3r <= gdv[:duration]
+              gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 1); gdv[:duration] = note_duration * 2/3r }
+              gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 0); gdv[:duration] = note_duration * 2/3r }
+
+              used_duration += 2 * note_duration * 2/3r
+            end
+
+            duration_diff = gdv[:duration] - used_duration
+            if duration_diff >= note_duration
+              gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 1); gdv[:duration] = duration_diff / 2 }
+              gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 0); gdv[:duration] = duration_diff / 2 }
+
+            elsif duration_diff > 0
+              gdvs[-1][:duration] += duration_diff / 2
+              gdvs[-2][:duration] += duration_diff / 2
+            end
+
+            super gdvs, base_duration: base_duration, tick_duration: tick_duration
+          else
+            super
+          end
+        end
+      end
+
+      # Process: .st .st(1) .st(2) .st(3): staccato level 1 2 3
+      class Staccato < FeatureTranscriptor
+        def initialize(min_duration_factor: nil)
+          @min_duration_factor = min_duration_factor || 1/8r
+        end
+
+        def transcript(gdv, base_duration:, tick_duration:)
+          st = gdv.delete :st
+
+          if st
+            calculated = 0
+
+            check(st) do |st|
+              case st
+              when true
+                calculated = gdv[:duration] / 2r
+              when Numeric
+                calculated = gdv[:duration] / 2**st if st >= 1
+              end
+            end
+
+            gdv[:note_duration] = [calculated, base_duration * @min_duration_factor].max
+          end
+
+          super
+        end
+      end
+
+    end
+  end
+end

data/lib/musa-dsl/transcription/from-gdv-to-musicxml.rb

@@ -0,0 +1,36 @@
+require_relative 'from-gdv'
+
+include Musa::Transcription
+
+module Musa::Transcriptors
+  module FromGDV
+    module ToMusicXML
+      def self.transcription_set
+        [ Appogiatura.new,
+          Base.new ]
+      end
+
+      # Process: appogiatura (neuma)neuma
+      class Appogiatura < FeatureTranscriptor
+        def transcript(gdv, base_duration:, tick_duration:)
+          if gdv_appogiatura = gdv[:appogiatura]
+            gdv.delete :appogiatura
+
+            # TODO process with Decorators the gdv_appogiatura
+            # TODO implement also posterior appogiatura neuma(neuma)
+            # TODO implement also multiple appogiatura with several notes (neuma ... neuma)neuma or neuma(neuma ... neuma)
+
+            gdv_appogiatura[:grace] = true
+            gdv[:graced] = true
+            gdv[:graced_by] = gdv_appogiatura
+
+            [ gdv_appogiatura, gdv ]
+          else
+            gdv
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/musa-dsl/transcription/from-gdv.rb

@@ -0,0 +1,17 @@
+require_relative 'transcription'
+
+include Musa::Transcription
+
+module Musa::Transcriptors
+  module FromGDV
+    # Process: .base .b
+    class Base < FeatureTranscriptor
+      def transcript(gdv, base_duration:, tick_duration:)
+        base = gdv.delete :base
+        base ||= gdv.delete :b
+
+        super base ? { duration: 0 }.extend(Musa::Datasets::AbsD) : gdv, base_duration: base_duration, tick_duration: tick_duration
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Musa
+  module Transcription
+    class Transcriptor
+      attr_reader :transcriptors
+
+      def initialize(transcriptors = nil, base_duration: nil, tick_duration: nil)
+        @transcriptors = transcriptors || []
+
+        @base_duration = base_duration || 1/4r
+        @tick_duration = tick_duration || 1/96r
+      end
+
+      def transcript(element)
+        @transcriptors.each do |transcriptor|
+          if element
+            if element.is_a?(Array)
+              element = element.collect { |element_i| transcriptor.transcript(element_i, base_duration: @base_duration, tick_duration: @tick_duration) }.flatten(1)
+            else
+              element = transcriptor.transcript(element, base_duration: @base_duration, tick_duration: @tick_duration)
+            end
+          end
+        end
+
+
+
+        element
+      end
+    end
+
+    class FeatureTranscriptor
+      def transcript(element, base_duration:, tick_duration:)
+        case element
+        when Hash
+          element.delete :modifiers if element[:modifiers]&.empty?
+        when Array
+          element.each { |_| _.delete :modifiers if _[:modifiers]&.empty? }
+        end
+
+        element
+      end
+
+      def check(value_or_array)
+        if block_given?
+          if value_or_array.is_a?(Array)
+            value_or_array.each { |value| yield value }
+          else
+            yield value_or_array
+          end
+        end
+      end
+    end
+  end
+
+  module Transcriptors; end
+end

data/lib/musa-dsl/transport.rb

@@ -1,9 +1,9 @@
-require 'musa-dsl/transport/transport'
+require_relative 'transport/transport'
 
-require 'musa-dsl/transport/timer'
+require_relative 'transport/timer'
 
-require 'musa-dsl/transport/input-midi-clock'
-require 'musa-dsl/transport/timer-clock'
-require 'musa-dsl/transport/dummy-clock'
-require 'musa-dsl/transport/external-tick-clock'
+require_relative 'transport/input-midi-clock'
+require_relative 'transport/timer-clock'
+require_relative 'transport/dummy-clock'
+require_relative 'transport/external-tick-clock'
 

data/lib/musa-dsl/transport/clock.rb

@@ -1,36 +1,36 @@
-require 'nibbler'
-
 module Musa
-  class Clock
-    def initialize
-      @run = nil
-      @on_start = []
-      @on_stop = []
-      @on_change_position = []
-    end
+  module Clock
+    class Clock
+      def initialize
+        @run = nil
+        @on_start = []
+        @on_stop = []
+        @on_change_position = []
+      end
 
-    def running?
-      @run
-    end
+      def running?
+        @run
+      end
 
-    def on_start(&block)
-      @on_start << block
-    end
+      def on_start(&block)
+        @on_start << block
+      end
 
-    def on_stop(&block)
-      @on_stop << block
-    end
+      def on_stop(&block)
+        @on_stop << block
+      end
 
-    def on_change_position(&block)
-      @on_change_position << block
-    end
+      def on_change_position(&block)
+        @on_change_position << block
+      end
 
-    def run
-      raise NotImplementedError
-    end
+      def run
+        raise NotImplementedError
+      end
 
-    def terminate
-      raise NotImplementedError
+      def terminate
+        raise NotImplementedError
+      end
     end
   end
 end