musa-dsl 0.14.29 → 0.21.3

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

@@ -1,55 +1,59 @@
-require_relative 'send-nice'
-
-module DynamicProxyModule
-  def method_missing(method_name, *args, **key_args, &block)
-    if @receiver.respond_to? method_name
-      @receiver._send_nice method_name, args, key_args, &block
-    else
-      super
-    end
-  end
+module Musa
+  module Extension
+    module DynamicProxy
+      module DynamicProxyModule
+        def method_missing(method_name, *args, **key_args, &block)
+          if @receiver.respond_to? method_name
+            @receiver.send method_name, *args, **key_args, &block
+          else
+            super
+          end
+        end
 
-  def respond_to_missing?(method_name, include_private)
-    @receiver.respond_to?(method_name, include_private) || super
-  end
+        def respond_to_missing?(method_name, include_private)
+          @receiver.respond_to?(method_name, include_private) || super
+        end
 
-  alias _is_a? is_a?
+        alias _is_a? is_a?
 
-  def is_a?(klass)
-    _is_a?(klass) || @receiver.is_a?(klass)
-  end
+        def is_a?(klass)
+          _is_a?(klass) || @receiver.is_a?(klass)
+        end
 
-  alias _kind_of? kind_of?
+        alias _kind_of? kind_of?
 
-  def kind_of?(klass)
-    _kind_of?(klass) || @receiver.is_a?(klass)
-  end
+        def kind_of?(klass)
+          _kind_of?(klass) || @receiver.is_a?(klass)
+        end
 
-  alias _instance_of? instance_of?
+        alias _instance_of? instance_of?
 
-  def instance_of?(klass)
-    _instance_of?(klass) || @receiver.instance_of?(klass)
-  end
+        def instance_of?(klass)
+          _instance_of?(klass) || @receiver.instance_of?(klass)
+        end
 
-  alias _equalequal ==
+        alias _equalequal ==
 
-  def ==(object)
-    _equalequal(object) || @receiver.==(object)
-  end
+        def ==(object)
+          _equalequal(object) || @receiver.==(object)
+        end
 
-  alias _eql? eql?
+        alias _eql? eql?
 
-  def eql?(object)
-    _eql?(object) || @receiver.eql?(object)
-  end
-end
+        def eql?(object)
+          _eql?(object) || @receiver.eql?(object)
+        end
+      end
 
-class DynamicProxy
-  include DynamicProxyModule
+      class DynamicProxy
+        include DynamicProxyModule
 
-  def initialize(receiver = nil)
-    @receiver = receiver
-  end
+        def initialize(receiver = nil)
+          @receiver = receiver
+        end
 
-  attr_accessor :receiver
+        attr_accessor :receiver
+      end
+    end
+  end
 end

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

@@ -1,28 +1,46 @@
-class Hash
-  def inspect
-    all = collect { |key, value| [', ', key.is_a?(Symbol) ? key.to_s + ': ' : key.to_s + ' => ', value.inspect] }.flatten
-    all.shift
-    '{ ' + all.join + ' }'
-  end
-end
+module Musa
+  module Extension
+    module InspectNice
+      refine Hash do
+        def inspect
+          all = collect { |key, value| [', ', key.is_a?(Symbol) ? key.to_s + ': ' : key.inspect + ' => ', value.inspect] }.flatten
+          all.shift
+          '{ ' + all.join + ' }'
+        end
 
-class Rational
-  def inspect
-    d = self - to_i
-    if d != 0
-      "#{to_i}(#{d.numerator}/#{d.denominator})"
-    else
-      to_i.to_s
-    end
-  end
+        alias _to_s to_s
+        alias to_s inspect
+      end
+
+      refine Rational do
+        def inspect(simple: nil)
+          value = self.abs
+          sign = negative? ? '-' : ''
+
+          if simple
+            if value.denominator == 1
+              "#{sign}#{value.numerator}"
+            else
+              "#{sign}#{value.numerator}/#{value.denominator}"
+            end
+          else
+            sign2 = negative? ? '-' : '+'
+
+            d = value - value.to_i
 
-  alias _to_s to_s
+            if d == 0
+              "#{sign}#{value.to_i.to_s}r"
+            else
+              i = "#{value.to_i}#{sign2}" if value.to_i != 0
+              "#{sign}#{i}#{d.numerator}/#{d.denominator}r"
+            end
+          end
+        end
 
-  def to_s
-    if to_i == self
-      to_i.to_s
-    else
-      _to_s
+        def to_s
+          inspect simple: true
+        end
+      end
     end
   end
 end

data/lib/musa-dsl/core-ext/smart-proc-binder.rb

@@ -0,0 +1,108 @@
+module Musa
+  module Extension
+    module SmartProcBinder
+      class SmartProcBinder
+        def initialize(procedure, on_rescue: nil)
+          @procedure = procedure
+          @on_rescue = on_rescue
+
+          @key_parameters = {}
+          @has_key_rest = false
+
+          @value_parameters_count = 0
+          @has_value_rest = false
+
+          procedure.parameters.each do |parameter|
+            @key_parameters[parameter[1]] = nil if parameter[0] == :key || parameter[0] == :keyreq
+            @has_key_rest = true if parameter[0] == :keyrest
+
+            @value_parameters_count += 1 if parameter[0] == :req || parameter[0] == :opt
+            @has_value_rest = true if parameter[0] == :rest
+          end
+        end
+
+        def parameters
+          @procedure.parameters
+        end
+
+        def call(*value_parameters, **key_parameters)
+          _call value_parameters, key_parameters
+        end
+
+        def _call(value_parameters, key_parameters)
+          if @on_rescue
+            begin
+              __call value_parameters, key_parameters
+            rescue StandardError, ScriptError => e
+              @on_rescue.call e
+            end
+          else
+            __call value_parameters, key_parameters
+          end
+        end
+
+        def __call(value_parameters, key_parameters)
+          effective_value_parameters, effective_key_parameters = apply(*value_parameters, **key_parameters)
+
+          if effective_key_parameters.empty?
+            if effective_value_parameters.empty?
+              @procedure.call
+            else
+              @procedure.call *effective_value_parameters
+            end
+          else
+            if effective_value_parameters.empty?
+              @procedure.call **effective_key_parameters
+            else
+              @procedure.call *effective_value_parameters, **effective_key_parameters
+            end
+          end
+        end
+
+        private :__call
+
+        def key?(key)
+          @has_key_rest || @key_parameters.include?(key)
+        end
+
+        alias_method :has_key?, :key?
+
+        def apply(*value_parameters, **key_parameters)
+          _apply(value_parameters, key_parameters)
+        end
+
+        def _apply(value_parameters, key_parameters)
+          value_parameters ||= []
+          key_parameters ||= {}
+
+          if @has_value_rest
+            values_result = value_parameters.clone
+          else
+            values_result = value_parameters.first(@value_parameters_count)
+            values_result += Array.new(@value_parameters_count - values_result.size)
+          end
+
+          hash_result = @key_parameters.clone
+
+          @key_parameters.each_key do |parameter_name|
+            hash_result[parameter_name] = key_parameters[parameter_name]
+          end
+
+          if @has_key_rest
+            key_parameters.each do |key, value|
+              hash_result[key] = value unless hash_result.key?(key)
+            end
+          end
+
+          return values_result, hash_result
+        end
+
+        def inspect
+          "KeyParametersProcedureBinder: parameters = #{@key_parameters} has_rest = #{@has_key_rest}"
+        end
+
+        alias to_s inspect
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require_relative 'smart-proc-binder'
+
+module Musa
+  module Extension
+    module With
+      def with(*value_parameters, **key_parameters, &block)
+        binder = Musa::Extension::SmartProcBinder::SmartProcBinder.new(block)
+
+        keep_block_context = binder.parameters[0][1] == :_ unless binder.parameters.empty?
+        keep_block_context ||= false
+
+        effective_value_parameters, effective_key_parameters = binder._apply(value_parameters, key_parameters)
+
+        if keep_block_context
+          binder.call(self, *effective_value_parameters, **effective_key_parameters)
+        else
+          if effective_value_parameters.empty? && effective_key_parameters.empty?
+            instance_eval &block
+          else
+            instance_exec *effective_value_parameters, **effective_key_parameters, &block
+          end
+        end
+      end
+    end
+  end
+end

data/lib/musa-dsl/datasets.rb

@@ -1,5 +1,10 @@
-require 'musa-dsl/datasets/gdv'
-require 'musa-dsl/datasets/gdv-decorators'
+require_relative 'datasets/gdv'
+require_relative 'datasets/gdvd'
+require_relative 'datasets/pdv'
 
-require 'musa-dsl/datasets/pdv'
+require_relative 'datasets/packed-v'
+require_relative 'datasets/v'
+require_relative 'datasets/p'
+require_relative 'datasets/ps'
 
+require_relative 'datasets/score'

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

@@ -0,0 +1,3 @@
+module Musa::Datasets
+  module Dataset; end
+end

data/lib/musa-dsl/datasets/delta-d.rb

@@ -0,0 +1,12 @@
+require_relative 'e'
+
+module Musa::Datasets
+  module DeltaD
+    include Delta
+
+    NaturalKeys = [:abs_duration, # absolute duration
+                   :delta_duration, # incremental duration
+                   :factor_duration # multiplicative factor duration
+    ].freeze
+  end
+end

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

@@ -0,0 +1,61 @@
+require_relative 'dataset'
+
+module Musa::Datasets
+  module E
+    include Dataset
+
+    NaturalKeys = [].freeze
+  end
+
+  module Abs
+    include E
+    def duration; 0; end
+  end
+
+  module Delta
+    include E
+  end
+
+  module AbsI
+    include Abs
+  end
+
+  module DeltaI
+    include Delta
+  end
+
+  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
+
+    def forward_duration
+      self[:forward_duration] || self[:duration]
+    end
+
+    def note_duration
+      self[:note_duration] || self[:duration]
+    end
+
+    def duration
+      self[:duration]
+    end
+
+    def self.is_compatible?(thing)
+      thing.is_a?(AbsD) || thing.is_a?(Hash) && thing.has_key?(:duration)
+    end
+
+    def self.to_AbsD(thing)
+      if thing.is_a?(AbsD)
+        thing
+      elsif thing.is_a?(Hash) && thing.has_key?(:duration)
+        thing.clone.extend(AbsD)
+      else
+        raise ArgumentError, "Cannot convert #{thing} to AbsD dataset"
+      end
+    end
+  end
+end

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

@@ -1,344 +1,28 @@
-require 'musa-dsl/neuma'
+require_relative 'e'
+require_relative 'gdvd'
+require_relative 'pdv'
 
-module Musa::Datasets
-  module GDVd
-    include Musa::Neumalang::Dataset
-
-    NaturalKeys = [:abs_grade, :abs_sharps, :abs_octave,
-                   :delta_grade, :delta_sharps, :delta_interval_sign, :delta_interval, :delta_octave,
-                   :abs_duration, :delta_duration, :factor_duration,
-                   :abs_velocity, :delta_velocity].freeze
-
-    attr_accessor :base_duration
-
-    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
-
-      (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(mode = nil)
-      mode ||= :dots # :parenthesis
-
-      @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
-
-      if include?(:abs_octave)
-        attributes[c += 1] = 'o' + positive_sign_of(self[:abs_octave]) + 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
-
-      if mode == :dots
-        if !attributes.empty?
-          attributes.join '.'
-        else
-          '.'
-        end
-
-      elsif mode == :parenthesis
-        '<' + attributes.join(', ') + '>'
-      else
-        attributes
-      end
-    end
-
-    module Parser
-      class << self
-        def parse(expression, base_duration: nil)
-          base_duration ||= Rational(1,4)
-
-          neuma = expression.clone
-
-          command = {}.extend GDVd
-          command.base_duration = base_duration
-
-          grade = neuma.shift
-
-          if grade && !grade.empty?
-            if '+-#_'.include?(grade[0])
-              sign, interval, number, sharps = parse_grade(grade)
-
-              sign ||= 1
-
-              command[:delta_grade] = number * sign if number
-              command[:delta_sharps] = sharps * sign unless sharps.zero?
-
-              command[:delta_interval] = interval if interval
-              command[:delta_interval_sign] = sign if interval && sign && interval
-            else
-              _, name, number, sharps = parse_grade(grade)
+require_relative 'helper'
 
-              command[:abs_grade] = name || number
-              command[:abs_sharps] = sharps unless sharps.zero?
-            end
-          end
-
-          octave = neuma.reject {|a| a.is_a?(Hash)}.find { |a| /\A[+-]?o[+-]?[0-9]+\Z/x.match a }
-
-          if octave
-            if (octave[0] == '+' || octave[0] == '-') && octave[1] == 'o'
-              command[:delta_octave] = (octave[0] + octave[2..-1]).to_i
-            elsif octave[0] == 'o'
-              command[:abs_octave] = octave[1..-1].to_i
-            end
-
-            neuma.delete octave
-          end
-
-          to_delete = velocity = neuma.select {|a| a.is_a?(Hash)}.find { |a| /\A(mp | mf | (\+|\-)?(p+|f+))\Z/x.match a[:modifier] }
-          velocity = velocity[:modifier].to_s if velocity
-
-          velocity ||= to_delete = neuma.reject {|a| a.is_a?(Hash)}.find { |a| /\A(mp | mf | (\+|\-)?(p+|f+))\Z/x.match a }
-
-          if velocity
-            if velocity[0] == '+' || velocity[0] == '-'
-              command[:delta_velocity] = (velocity[1] == 'f' ? 1 : -1) * (velocity.length - 1) * (velocity[0] + '1').to_i
-            elsif velocity[0] == 'm'
-              command[:abs_velocity] = velocity[1] == 'f' ? 1 : 0
-            else
-              command[:abs_velocity] = velocity.length * (velocity[0] == 'f' ? 1 : -1) + (velocity[0] == 'f' ? 1 : 0)
-            end
-
-            neuma.delete to_delete
-          end
-
-          duration = neuma.reject {|a| a.is_a?(Hash)}.first
-
-          if duration && !duration.empty?
-            if duration[0] == '+' || duration[0] == '-'
-              command[:delta_duration] = (duration[0] == '-' ? -1 : 1) * eval_duration(duration[1..-1]) * base_duration
-
-            elsif /\A\/+·*\Z/x.match(duration)
-              command[:abs_duration] = eval_duration(duration) * base_duration
-
-            elsif duration[0] == '*'
-              command[:factor_duration] = eval_duration(duration[1..-1])
-
-            elsif duration[0] == '/'
-              command[:factor_duration] = Rational(1, eval_duration(duration[1..-1]))
-
-            else
-              command[:abs_duration] = eval_duration(duration) * base_duration
-            end
-          end
-
-          neuma.delete duration if duration
-
-          neuma.select {|a| a.is_a?(Hash)}.each do |a|
-            command[a[:modifier]] = a[:parameters] || true
-          end
-
-          raise EncodingError, "Neuma #{neuma} cannot be decoded" unless neuma.reject {|a| a.is_a?(Hash)}.size.zero?
-
-          command
-        end
-
-        def parse_grade(neuma_grade)
-          sign = name = wide_grade = nil
-          accidentals = 0
-
-          case neuma_grade
-          when Symbol, String
-            match = /\A(?<sign>[+|-]?)(?<name>[^[#|_]]*)(?<accidental_sharps>#*)(?<accidental_flats>_*)\Z/.match neuma_grade.to_s
-
-            if match
-              sign = (match[:sign] == '-' ? -1 : 1) unless match[:sign].empty?
-
-              if match[:name] == match[:name].to_i.to_s
-                wide_grade = match[:name].to_i
-              else
-                name = match[:name].to_sym unless match[:name].empty?
-              end
-              accidentals = match[:accidental_sharps].length - match[:accidental_flats].length
-            else
-              name = neuma_grade.to_sym unless (neuma_grade.nil? || neuma_grade.empty?)
-            end
-          when Numeric
-            wide_grade = neuma_grade.to_i
-
-          else
-            raise ArgumentError, "Cannot eval #{neuma_grade} as name or grade position."
-          end
-
-          return sign, name, wide_grade, accidentals
-        end
-
-        def eval_duration(string)
-          # format: ///···
-          #
-          if match = /\A(?<slashes>\/+)(?<dots>\·*)\Z/x.match(string)
-            base = Rational(1, 2**match[:slashes].length.to_r)
-            dots_extension = 0
-            match[:dots].length.times do |i|
-              dots_extension += Rational(base, 2**(i+1))
-            end
-
-            base + dots_extension
-
-            # format: 1··
-            #
-          elsif match = /\A(?<number>\d*\/?\d+?)(?<dots>\·*)\Z/x.match(string)
-            base = match[:number].to_r
-            dots_extension = 0
-            match[:dots].length.times do |i|
-              dots_extension += Rational(base, 2**(i+1))
-            end
-
-            base + dots_extension
-
-          else
-            string.to_r
-          end
-        end
-      end
-    end
-
-    class NeumaDifferentialDecoder < Musa::Neumalang::DifferentialDecoder # to get a GDVd
-      def initialize(base_duration: nil)
-        @base_duration = base_duration || Rational(1,4)
-      end
-
-      def parse(expression)
-        Parser.parse(expression, base_duration: @base_duration)
-      end
-    end
-  end
+using Musa::Extension::InspectNice
 
+module Musa::Datasets
   module GDV
-    include Musa::Neumalang::Dataset
+    include AbsD
+    include AbsI
+
+    include Helper
 
-    NaturalKeys = [:grade, :sharps, :octave, :duration, :velocity, :silence].freeze
+    NaturalKeys = (NaturalKeys + [:grade, :sharps, :octave, :velocity, :silence]).freeze
 
     attr_accessor :base_duration
 
     def to_pdv(scale)
-      r = {}.extend Musa::Datasets::PDV
-      r.base_duration = @base_duration
+      pdv = {}.extend PDV
+      pdv.base_duration = @base_duration
 
       if self[:grade]
-        r[:pitch] = if self[:silence]
+        pdv[:pitch] = if self[:silence]
                       :silence
                     else
                       scale[self[:grade]].sharp(self[:sharps] || 0).octave(self[:octave] || 0).pitch
@@ -346,22 +30,29 @@ module Musa::Datasets
       end
 
       if self[:duration]
-        r[:duration] = self[:duration]
+        pdv[:duration] = self[:duration]
+      end
+
+      if self[:note_duration]
+        pdv[:note_duration] = self[:note_duration]
+      end
+
+      if self[:forward_duration]
+        pdv[:forward_duration] = self[:forward_duration]
       end
 
       if self[:velocity]
-        # ppp = 16 ... fff = 127
-        r[:velocity] = [16, 32, 48, 64, 80, 96, 112, 127][self[:velocity] + 3]
+        # ppp = 16 ... fff = 127 (-5 ... 4) the standard used by Musescore 3 and others starts at ppp = 16
+        # TODO create a customizable MIDI velocity to score dynamics bidirectional conversor
+        pdv[:velocity] = [1, 8, 16, 33, 49, 64, 80, 96, 112, 127][self[:velocity] + 5]
       end
 
-      (keys - NaturalKeys).each { |k| r[k] = self[k] }
+      (keys - NaturalKeys).each { |k| pdv[k] = self[k] }
 
-      r
+      pdv
     end
 
-    def to_neuma(mode = nil)
-      mode ||= :dotted # :parenthesis
-
+    def to_neuma
       @base_duration ||= Rational(1,4)
 
       attributes = []
@@ -381,7 +72,9 @@ module Musa::Datasets
         end
       end
 
-      attributes[c += 1] = 'o' +  positive_sign_of(self[:octave]) + self[:octave].to_s if self[:octave]
+      attributes[c] = '.' if attributes[c].nil? || attributes[c].empty?
+
+      attributes[c += 1] = 'o' + self[:octave].to_s if self[:octave]
       attributes[c += 1] = (self[:duration] / @base_duration).to_s if self[:duration]
       attributes[c += 1] = velocity_of(self[:velocity]) if self[:velocity]
 
@@ -389,14 +82,7 @@ module Musa::Datasets
         attributes[c += 1] = modificator_string(k, self[k])
       end
 
-      if mode == :dotted
-        attributes.join '.'
-
-      elsif mode == :parenthesis
-        '(' + attributes.join(', ') + ')'
-      else
-        attributes
-      end
+      '(' + attributes.join(' ') + ')'
     end
 
     def velocity_of(x)
@@ -406,94 +92,48 @@ module Musa::Datasets
     private :velocity_of
 
     def to_gdvd(scale, previous: nil)
-      r = {}.extend Musa::Datasets::GDVd
-      r.base_duration = @base_duration
+      gdvd = {}.extend GDVd
+      gdvd.base_duration = @base_duration
 
       if previous
 
         if include?(:silence)
-          r[:abs_grade] = :silence
+          gdvd[:abs_grade] = :silence
 
         elsif include?(:grade) && !previous.include?(:grade)
-          r[:abs_grade] = self[:grade]
-          r[:abs_sharps] = self[:sharps]
+          gdvd[:abs_grade] = self[:grade]
+          gdvd[:abs_sharps] = self[:sharps]
 
         elsif include?(:grade) && previous.include?(:grade)
           if self[:grade] != previous[:grade] ||
             (self[:sharps] || 0) != (previous[:sharps] || 0)
 
-            r[:delta_grade] = scale[self[:grade]].octave(self[:octave]).wide_grade - scale[previous[:grade]].octave(previous[:octave]).wide_grade
-            r[:delta_sharps] = (self[:sharps] || 0) - (previous[:sharps] || 0)
+            gdvd[:delta_grade] =
+                scale[self[:grade]].octave(self[:octave]).wide_grade -
+                scale[previous[:grade]].octave(previous[:octave]).wide_grade
+
+            gdvd[:delta_sharps] = (self[:sharps] || 0) - (previous[:sharps] || 0)
           end
         elsif include?(:sharps)
-          r[:delta_sharps] = self[:sharps] - (previous[:sharps] || 0)
+          gdvd[:delta_sharps] = self[:sharps] - (previous[:sharps] || 0)
         end
 
         if self[:duration] && previous[:duration] && (self[:duration] != previous[:duration])
-          r[:delta_duration] = (self[:duration] - previous[:duration])
+          gdvd[:delta_duration] = (self[:duration] - previous[:duration])
         end
 
         if self[:velocity] && previous[:velocity] && (self[:velocity] != previous[:velocity])
-          r[:delta_velocity] = self[:velocity] - previous[:velocity]
+          gdvd[:delta_velocity] = self[:velocity] - previous[:velocity]
         end
       else
-        r[:abs_grade] = self[:grade] if self[:grade]
-        r[:abs_duration] = self[:duration] if self[:duration]
-        r[:abs_velocity] = self[:velocity] if self[:velocity]
-      end
-
-      (keys - NaturalKeys).each { |k| r[k] = self[k] }
-
-      r
-    end
-
-    class NeumaDecoder < Musa::Neumalang::Decoder # to get a GDV
-      def initialize(scale, base_duration: nil, processor: nil, **base)
-        @base_duration = base_duration || Rational(1,4)
-
-        base = { grade: 0, octave: 0, duration: @base_duration, velocity: 1 } if base.empty?
-
-        @scale = scale
-
-        super base, processor: processor
-      end
-
-      attr_accessor :scale, :base_duration
-
-      def parse(expression)
-        expression = expression.clone
-
-        appogiatura_neuma = expression.find { |_| _.is_a?(Hash) && _[:appogiatura] }
-        expression.delete appogiatura_neuma if appogiatura_neuma
-
-        parsed = GDVd::Parser.parse(expression, base_duration: @base_duration)
-
-        if appogiatura_neuma
-          appogiatura = GDVd::Parser.parse(appogiatura_neuma[:appogiatura], base_duration: @base_duration)
-          parsed[:appogiatura] = appogiatura
-        end
-
-        parsed
+        gdvd[:abs_grade] = self[:grade] if self[:grade]
+        gdvd[:abs_duration] = self[:duration] if self[:duration]
+        gdvd[:abs_velocity] = self[:velocity] if self[:velocity]
       end
 
-      def subcontext
-        NeumaDecoder.new @scale, base_duration: @base_duration, processor: @processor, **@last
-      end
-
-      def apply(action, on:)
-        gdv = action.to_gdv @scale, previous: on
-
-        appogiatura_action = action[:appogiatura]
-        gdv[:appogiatura] = appogiatura_action.to_gdv @scale, previous: on if appogiatura_action
-
-        gdv
-      end
-
-      def inspect
-        "GDV NeumaDecoder: @last = #{@last}"
-      end
+      (keys - NaturalKeys).each { |k| gdvd[k] = self[k] }
 
-      alias to_s inspect
+      gdvd
     end
   end
 end