musa-dsl 0.26.5 → 0.26.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d9154434fb485380e87cf24b6efa8ebdbaee0a223a94c2ad1988ae808b0a691
-  data.tar.gz: 6323750820c35c1ef1e8b2220d4f511bba9fafaf504dacadce14aba33ee647f2
+  metadata.gz: 33fe7c69b6b470b2563a5bb631744c7d39c7adb83c21fa612d630b212e63d99b
+  data.tar.gz: 18bd3611f80fcb47af81c4afc377f827bb18aa60702b491eb8e2d5edb4f70c16
 SHA512:
-  metadata.gz: 91e4c3067db836ae8eac4f0242bb4ac1dd6ee48da8959bb4f06b8133e49065260bf316d04dc893c1e2e9cd7f1cbf57b882167868ca3f27072869f15de9962424
-  data.tar.gz: d0df67a8d02ce6ab12764cfd2478de3322a3006ada484bbbe32cef0e885eac35be2d157fda16ee7453db7b314bb93f81cb46bf83409b218b6936e673c1e4dc2a
+  metadata.gz: 35c3e1131b02666ee0f7db1dc596946a9b472738499b50139aea90fa1ecd468ff900378ce862fe6e9b31958dd94fbd8e1209cb23894a800ec8a1c888acb1cdd0
+  data.tar.gz: 6b2c952e9388f77ceb296b008ed572420f0621a0d05ebb617cc7254d18b4b5e3cbd9c81dee87b22deecf864d953a99f1cf4353e40b0ce3fb072a67ef93baada1

data/lib/musa-dsl/generative/{backboner.rb → rules.rb}

@@ -1,21 +1,22 @@
 require_relative '../core-ext/smart-proc-binder'
 require_relative '../core-ext/with'
 
-# TODO hacer que pueda funcionar en tiempo real? le vas suministrando seeds y le vas diciendo qué opción has elegido (p.ej. para hacer un armonizador en tiempo real)
-# TODO esto mismo sería aplicable en otros generadores? variatio/darwin? generative-grammar? markov?
+# TODO: hacer que pueda funcionar en tiempo real? le vas suministrando seeds y le vas diciendo qué opción has elegido (p.ej. para hacer un armonizador en tiempo real)
+# TODO: esto mismo sería aplicable en otros generadores? variatio/darwin? generative-grammar? markov?
+# TODO: optimizar la llamada a .with que internamente genera cada vez un SmartProcBinder; podría generarse sólo una vez por cada &block
 
 module Musa
-  module Backboner
+  module Rules
     using Musa::Extension::Arrayfy
 
-    class Backboner
+    class Rules
       include Musa::Extension::With
 
       def initialize(&block)
         @dsl = RulesEvalContext.new(&block)
       end
 
-      def generate_possibilities(object, confirmed_node = nil, node = nil, grow_rules = nil)
+      def generate_possibilities(object, confirmed_node = nil, node = nil, grow_rules = nil, **parameters)
         node ||= Node.new
         grow_rules ||= @dsl._grow_rules
 
@@ -26,11 +27,15 @@ module Musa
         grow_rule = grow_rules.shift
 
         if grow_rule
-          grow_rule.generate_possibilities(object, history).each do |new_object|
+          grow_rule.generate_possibilities(object, history, **parameters).each do |new_object|
             new_node = Node.new new_object, node
-            new_node.mark_as_ended! if @dsl._ended? new_object
+            if @dsl._has_ending? && @dsl._ended?(new_object, history, **parameters) ||
+              !@dsl._has_ending? && grow_rules.empty?
 
-            rejection = @dsl._cut_rules.find { |cut_rule| cut_rule.rejects?(new_object, history) }
+              new_node.mark_as_ended!
+            end
+
+            rejection = @dsl._cut_rules.find { |cut_rule| cut_rule.rejects?(new_object, history, **parameters) }
             # TODO: include rejection secondary reasons in rejection message
 
             new_node.reject! rejection if rejection
@@ -41,14 +46,14 @@ module Musa
 
         unless grow_rules.empty?
           node.children.each do |node|
-            generate_possibilities node.object, confirmed_node, node, grow_rules unless node.rejected || node.ended?
+            generate_possibilities node.object, confirmed_node, node, grow_rules, **parameters unless node.rejected || node.ended?
           end
         end
 
         node
       end
 
-      def apply(object_or_list, node = nil)
+      def apply(object_or_list, node = nil, **parameters)
         list = object_or_list.arrayfy.clone
 
         node ||= Node.new
@@ -56,7 +61,7 @@ module Musa
         seed = list.shift
 
         if seed
-          result = generate_possibilities seed, node
+          result = generate_possibilities seed, node, **parameters
 
           fished = result.fish
 
@@ -64,7 +69,7 @@ module Musa
 
           fished.each do |object|
             subnode = node.add(object).mark_as_ended!
-            apply list, subnode
+            apply list, subnode, **parameters
           end
         end
 
@@ -77,11 +82,12 @@ module Musa
         attr_reader :_grow_rules, :_ended_when, :_cut_rules
 
         def initialize(&block)
+          @_grow_rules = []
+          @_cut_rules = []
           with &block
         end
 
         def grow(name, &block)
-          @_grow_rules ||= []
           @_grow_rules << GrowRule.new(name, &block)
           self
         end
@@ -92,13 +98,20 @@ module Musa
         end
 
         def cut(reason, &block)
-          @_cut_rules ||= []
           @_cut_rules << CutRule.new(reason, &block)
           self
         end
 
-        def _ended?(object)
-          instance_exec object, &@_ended_when
+        def _has_ending?
+          !@_ended_when.nil?
+        end
+
+        def _ended?(object, history, **parameters)
+          if @_ended_when
+            with object, history, **parameters, &@_ended_when
+          else
+            false
+          end
         end
 
         class GrowRule
@@ -109,10 +122,10 @@ module Musa
             @block = block
           end
 
-          def generate_possibilities(object, history)
+          def generate_possibilities(object, history, **parameters)
             # TODO: optimize context using only one instance for all genereate_possibilities calls
             context = GrowRuleEvalContext.new
-            context.with object, history, &@block
+            context.with object, history, **parameters, &@block
 
             context._branches
           end
@@ -145,10 +158,10 @@ module Musa
             @block = block
           end
 
-          def rejects?(object, history)
+          def rejects?(object, history, **parameters)
             # TODO: optimize context using only one instance for all rejects? checks
             context = CutRuleEvalContext.new
-            context.with object, history, &@block
+            context.with object, history, **parameters, &@block
 
             reasons = context._secondary_reasons.collect { |_| ("#{@reason} (#{_})" if _) || @reason }
 
@@ -203,7 +216,7 @@ module Musa
           @children.each(&:update_rejection_by_children!)
 
           if !@children.empty? && !@children.find { |n| !n.rejected }
-            reject! "Node rejected because all children are rejected"
+            reject! 'Node rejected because all children are rejected'
           end
 
           @ended = true

data/lib/musa-dsl/generative.rb

@@ -1,5 +1,5 @@
 require_relative 'generative/variatio'
 require_relative 'generative/darwin'
-require_relative 'generative/backboner'
+require_relative 'generative/rules'
 require_relative 'generative/markov'
 require_relative 'generative/generative-grammar'

data/lib/musa-dsl/music/chord-definition.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 module Musa
   module Chords
     class ChordDefinition
@@ -6,7 +8,7 @@ module Musa
       end
 
       def self.register(name, offsets:, **features)
-        definition = ChordDefinition.new(name, offsets: offsets, **features).freeze
+        definition = ChordDefinition.new(name, offsets: offsets, **features)
 
         @definitions ||= {}
         @definitions[definition.name] = definition
@@ -14,6 +16,9 @@ module Musa
         @features_by_value ||= {}
         definition.features.each { |k, v| @features_by_value[v] = k }
 
+        @feature_keys ||= Set[]
+        features.keys.each { |feature_name| @feature_keys << feature_name }
+
         self
       end
 
@@ -44,11 +49,16 @@ module Musa
         @features_by_value.keys
       end
 
+      def self.feature_keys
+        @feature_keys
+      end
+
       def initialize(name, offsets:, **features)
-        @name = name
-        @features = features.clone.freeze
-        @pitch_offsets = offsets.clone.freeze
-        @pitch_names = offsets.collect { |k, v| [v, k] }.to_h
+        @name = name.freeze
+        @features = features.transform_values(&:dup).transform_values(&:freeze).freeze
+        @pitch_offsets = offsets.dup.freeze
+        @pitch_names = offsets.collect { |k, v| [v, k] }.to_h.freeze
+        freeze
       end
 
       attr_reader :name, :features, :pitch_offsets, :pitch_names
@@ -57,6 +67,10 @@ module Musa
         @pitch_offsets.values.collect { |offset| root_pitch + offset }
       end
 
+      def in_scale?(scale, chord_root_pitch:)
+        !pitches(chord_root_pitch).find { |chord_pitch| scale.note_of_pitch(chord_pitch).nil? }
+      end
+
       def named_pitches(elements_or_pitches, &block)
         pitches = elements_or_pitches.collect do |element_or_pitch|
           [if block_given?
@@ -93,7 +107,7 @@ module Musa
 
       alias to_s inspect
 
-      protected
+      private
 
       def octave_reduce(pitches)
         pitches.collect { |p| p % 12 }

data/lib/musa-dsl/music/chord-definitions.rb

@@ -1,15 +1,23 @@
 require_relative 'chord-definition'
 
+# TODO trasladar los acordes de https://en.wikipedia.org/wiki/Chord_notation
+
 Musa::Chords::ChordDefinition.register :maj, quality: :major, size: :triad, offsets: { root: 0, third: 4, fifth: 7 }
 Musa::Chords::ChordDefinition.register :min, quality: :minor, size: :triad, offsets: { root: 0, third: 3, fifth: 7 }
+Musa::Chords::ChordDefinition.register :dim, quality: :diminished, size: :triad, offsets: { root: 0, third: 3, fifth: 3 }
+Musa::Chords::ChordDefinition.register :aug, quality: :augmented, size: :triad, offsets: { root: 0, third: 4, fifth: 8 }
 
 Musa::Chords::ChordDefinition.register :maj7, quality: :major, size: :seventh, offsets: { root: 0, third: 4, fifth: 7, seventh: 11 }
-Musa::Chords::ChordDefinition.register :maj7, quality: :major, size: :seventh, dominant: :dominant , offsets: { root: 0, third: 4, fifth: 7, seventh: 10 }
-
 Musa::Chords::ChordDefinition.register :min7, quality: :minor, size: :seventh, offsets: { root: 0, third: 3, fifth: 7, seventh: 11 }
 
+Musa::Chords::ChordDefinition.register :dom7, quality: :dominant, size: :seventh, offsets: { root: 0, third: 4, fifth: 7, seventh: 10 }
+
 Musa::Chords::ChordDefinition.register :maj9, quality: :major, size: :ninth, offsets: { root: 0, third: 4, fifth: 7, seventh: 11, ninth: 14 }
 Musa::Chords::ChordDefinition.register :min9, quality: :minor, size: :ninth, offsets: { root: 0, third: 3, fifth: 7, seventh: 11, ninth: 14 }
+Musa::Chords::ChordDefinition.register :dom9, quality: :dominant, size: :ninth, offsets: { root: 0, third: 4, fifth: 7, seventh: 10, ninth: 14 }
 
 Musa::Chords::ChordDefinition.register :maj11, quality: :major, size: :eleventh, offsets: { root: 0, third: 4, fifth: 7, seventh: 11, ninth: 14, eleventh: 17 }
 Musa::Chords::ChordDefinition.register :min11, quality: :minor, size: :eleventh, offsets: { root: 0, third: 3, fifth: 7, seventh: 11, ninth: 14, eleventh: 17 }
+
+Musa::Chords::ChordDefinition.register :maj13, quality: :major, size: :eleventh, offsets: { root: 0, third: 4, fifth: 7, seventh: 11, ninth: 14, eleventh: 17 }
+Musa::Chords::ChordDefinition.register :min13, quality: :minor, size: :eleventh, offsets: { root: 0, third: 3, fifth: 7, seventh: 11, ninth: 14, eleventh: 17 }

data/lib/musa-dsl/music/chords.rb

@@ -3,319 +3,213 @@ require_relative 'chord-definition'
 
 module Musa
   module Chords
-    using Musa::Extension::Arrayfy
-
     class Chord
-      def initialize(name_or_notes_or_pitches = nil, # name | [notes] | [pitches]
-                     # definitory
-                     name: nil,
-                     root: nil, root_grade: nil,
-                     notes: nil, pitches: nil,
-                     features: nil,
-                     # target scale (or scale reference)
-                     scale: nil,
-                     allow_chromatic: nil,
-                     # operations
-                     inversion: nil, state: nil,
-                     position: nil,
-                     move: nil,
-                     duplicate: nil,
-                     add: nil,
-                     drop: nil,
-                     #
-                     _source: nil)
-
-        # Preparing notes and pitches Arrays: they will we used to collect further notes and pitches
-        #
-        if notes
-          notes = notes.collect do |n|
-            case n
-            when Scales::NoteInScale
-              n
-            when Numeric, Symbol
-              scale[n]
+
+      using Musa::Extension::Arrayfy
+
+      def self.with_root(root_note_or_pitch_or_symbol, scale: nil, allow_chromatic: false, name: nil, move: nil, duplicate: nil, **features)
+        root =
+          case root_note_or_pitch_or_symbol
+          when Scales::NoteInScale
+            root_note_or_pitch_or_symbol
+          when Numeric
+            if scale
+              scale.note_of_pitch(root_note_or_pitch_or_symbol, allow_chromatic: allow_chromatic)
             else
-              raise ArgumentError, "Can't recognize #{n} in notes list #{notes}"
+              scale = Musa::Scales::Scales.default_system.default_tuning[root_note_or_pitch_or_symbol].major
+              scale.note_of_pitch(root_note_or_pitch_or_symbol)
             end
+          when Symbol
+            raise ArgumentError, "Missing scale parameter to calculate root note for #{root_note_or_pitch_or_symbol}" unless scale
+
+            scale[root_note_or_pitch_or_symbol]
+          else
+            raise ArgumentError, "Unexpected #{root_note_or_pitch_or_symbol}"
           end
-        end
 
-        pitches = pitches.clone if pitches
+        scale ||= root.scale
 
-        # Preparing root_pitch
-        #
+        if name
+          raise ArgumentError, "Received name parameter with value #{name}: features parameter is not allowed" if features.any?
 
-        root_pitch = nil
+          chord_definition = ChordDefinition[name]
 
-        raise ArgumentError, "Duplicate parameter: root: #{root} and root_grade: #{root_grade}" if root && root_grade
+        elsif features.any?
+          chord_definition = Helper.find_definition_by_features(root.pitch, features, scale, allow_chromatic: allow_chromatic)
 
-        allow_chromatic ||= scale.nil?
+        else
+          raise ArgumentError, "Don't know how to find a chord definition without name or features parameters"
+        end
 
-        if root&.is_a?(Scales::NoteInScale)
-          root_pitch = root.pitch
-          scale ||= root.scale
+        unless chord_definition
+          raise ArgumentError,
+                "Unable to find chord definition for root #{root}" \
+                "#{" with name #{name}" if name}" \
+                "#{" with features #{features}" if features.any?}"
         end
 
-        raise ArgumentError, "Don't know how to recognize root_grade #{root_grade}: scale is not provided" if root_grade && !scale
+        source_notes_map = Helper.compute_source_notes_map(root, chord_definition, scale)
+
+        Chord.new(root, scale, chord_definition, move, duplicate, source_notes_map)
+      end
 
-        root_pitch = scale[root_grade].pitch if root_grade && scale
+      class Helper
+        def self.compute_source_notes_map(root, chord_definition, scale)
+          chord_definition.pitch_offsets.transform_values do |offset|
+            pitch = root.pitch + offset
+            [scale.note_of_pitch(pitch) || scale.chromatic.note_of_pitch(pitch)]
+          end.tap { |_| _.values.each(&:freeze) }.freeze
+        end
 
-        # Parse name_or_notes_or_pitches to name, notes, pitches
-        #
-        #
-        case name_or_notes_or_pitches
-        when Symbol
-          raise ArgumentError, "Duplicate parameter #{name_or_notes_or_pitches} and name: #{name}" if name
-
-          name = name_or_notes_or_pitches
-
-        when Array
-          name_or_notes_or_pitches.each do |note_or_pitch|
-            case note_or_pitch
-            when Scales::NoteInScale
-              notes ||= [] << note_or_pitch
-            when Numeric
-              if scale
-                notes ||= [] << scale[note_or_pitch]
-              else
-                pitches ||= [] << note_or_pitch
-              end
-            when Symbol
-              raise ArgumentError, "Don't know how to recognize #{note_or_pitch} in parameter list #{name_or_notes_or_pitches}: it's a symbol but the scale is not provided" unless scale
-
-              notes ||= [] << scale[note_or_pitch]
-            else
-              raise ArgumentError, "Can't recognize #{note_or_pitch} in parameter list #{name_or_notes_or_pitches}"
+        def self.find_definition_by_features(root_pitch, features, scale, allow_chromatic:)
+          featured_chord_definitions = ChordDefinition.find_by_features(**features)
+
+          unless allow_chromatic
+            featured_chord_definitions.reject! do |chord_definition|
+              chord_definition.pitches(root_pitch).find { |chord_pitch| scale.note_of_pitch(chord_pitch).nil? }
             end
           end
 
-        when nil
-          # nothing happens
-        else
-          raise ArgumentError, "Can't recognize #{name_or_notes_or_pitches}"
+          featured_chord_definitions.first
         end
+      end
 
-        # Eval definitory atributes
-        #
-
-        @notes = if _source.nil?
-                   compute_notes(name, root_pitch, scale, notes, pitches, features, allow_chromatic)
-                 else
-                   compute_notes_from_source(_source, name, root_pitch, scale, notes, pitches, features, allow_chromatic)
-                 end
+      private_constant :Helper
 
-        # Eval adding / droping operations
-        #
+      ChordGradeNote = Struct.new(:grade, :note, keyword_init: true)
 
-        add&.each do |to_add|
-          case to_add
-          when NoteInScale
-            @notes << to_add
-          when Numeric # pitch increment
-            pitch = root_pitch + to_add
-            @notes << scale.note_of_pitch(pitch) || scale.chromatic.note_of_pitch(pitch)
-          when Symbol # interval name
-            pitch = root_pitch + scale.offset_of_interval(to_add)
-            @notes << scale.note_of_pitch(pitch)
-          else
-            raise ArgumentError, "Can't recognize element to add #{to_add}"
-          end
-        end
+      private_constant :ChordGradeNote
 
-        # TODO: Missing chord operations: drop, inversion, state, position
-        #
-        raise NotImplementedError, 'Missing chord operations: drop, inversion, state, position' if drop || inversion || state || position
+      private def initialize(root, scale, chord_definition, move, duplicate, source_notes_map)
+        @root = root
+        @scale = scale
+        @chord_definition = chord_definition
+        @move = move.dup.freeze || {}
+        # TODO: ojo esto implica que sólo se puede duplicar una vez cada grado! permitir múltiples?
+        @duplicate = duplicate.dup.freeze || {}
+        @source_notes_map = source_notes_map.dup.freeze
+        @notes_map = compute_moved_and_duplicated(source_notes_map, move, duplicate)
 
-        # Eval voice increment operations
+        # Calculate sorted notes: from lower to higher notes
         #
-
-        if move
-          raise ArgumentError, 'move: expected a Hash' unless move.is_a?(Hash)
-
-          move.each do |position, octave|
-            @notes[position][0] = @notes[position][0].octave(octave)
+        @sorted_notes = []
+        @notes_map.each_pair do |name, array_of_notes|
+          array_of_notes.each do |note|
+            @sorted_notes << ChordGradeNote.new(grade: name, note: note).freeze
           end
         end
 
-        if duplicate
-          raise ArgumentError, 'duplicate: expected a Hash' unless duplicate.is_a?(Hash)
+        @sorted_notes.sort_by! { |chord_grade_note| chord_grade_note.note.pitch }
+        @sorted_notes.freeze
 
-          duplicate.each do |position, octave|
-            octave.arrayfy.each do |octave|
-              @notes[position] << @notes[position][0].octave(octave)
+        # Add getters for grades
+        #
+        @notes_map.each_key do |chord_grade_name|
+          define_singleton_method chord_grade_name do |all: false|
+            if all
+              @notes_map[chord_grade_name]
+            else
+              @notes_map[chord_grade_name].first
             end
           end
         end
 
-        # Identify chord
+        # Add getters for the features values
         #
+        @chord_definition.features.each_key do |feature_name|
+          define_singleton_method feature_name do
+            @chord_definition.features[feature_name]
+          end
+        end
 
-        @notes.freeze
-
-        @chord_definition = ChordDefinition.find_by_pitches(@notes.values.flatten(1).collect(&:pitch))
-
-        ChordDefinition.feature_values.each do |name|
-          define_singleton_method name do
-            featuring(name)
+        # Add navigation methods to other chords based on changing a feature
+        #
+        ChordDefinition.feature_keys.each do |feature_name|
+          define_singleton_method "with_#{feature_name}".to_sym do |feature_value, allow_chromatic: true|
+            featuring(allow_chromatic: allow_chromatic, **{ feature_name => feature_value })
           end
         end
       end
 
-      attr_reader :notes, :chord_definition
+      attr_reader :scale, :chord_definition, :move, :duplicate
 
-      def name(name = nil)
-        if name.nil?
-          @chord_definition&.name
-        else
-          Chord.new(_source: self, name: name)
-        end
+      def notes
+        @sorted_notes
       end
 
-      def features
-        @chord_definition&.features
+      def pitches(*grades)
+        grades = @notes_map.keys if grades.empty?
+        @sorted_notes.select { |_| grades.include?(_.grade) }.collect { |_| _.note.pitch }
       end
 
-      def featuring(*values, allow_chromatic: nil, **hash)
-        features = @chord_definition.features.dup if @chord_definition
-        features ||= {}
+      def features
+        @chord_definition.features
+      end
 
+      def featuring(*values, allow_chromatic: false, **hash)
+        # create a new list of features based on current features but
+        # replacing the values for the new ones and adding the new features
+        #
+        features = @chord_definition.features.dup
         ChordDefinition.features_from(values, hash).each { |k, v| features[k] = v }
 
-        Chord.new(_source: self, allow_chromatic: allow_chromatic, features: features)
-      end
+        chord_definition = Helper.find_definition_by_features(@root.pitch, features, @scale, allow_chromatic: allow_chromatic)
 
-      def root(root = nil)
-        if root.nil?
-          @notes[:root]
-        else
-          Chord.new(_source: self, root: root)
-        end
-      end
-
-      def [](position)
-        case position
-        when Numeric
-          @notes.values[position]
-        when Symbol
-          @notes[position]
-        end
-      end
+        raise ArgumentError, "Unable to find a chord definition for #{features}" unless chord_definition
 
-      def move(**octaves)
-        Chord.new(_source: self, move: octaves)
-      end
+        source_notes_map = Helper.compute_source_notes_map(@root, chord_definition, @scale)
 
-      def duplicate(**octaves)
-        Chord.new(_source: self, duplicate: octaves)
+        Chord.new(@root,
+                  (@scale if chord_definition.in_scale?(@scale, chord_root_pitch: @root.pitch)),
+                  chord_definition,
+                  @move, @duplicate,
+                  source_notes_map)
       end
 
-      def scale
-        scales = @notes.values.flatten(1).collect(&:scale).uniq
-        scales.first if scales.size == 1
-      end
+      def octave(octave)
+        source_notes_map = @source_notes_map.transform_values do |notes|
+          notes.collect { |note| note.octave(octave) }.freeze
+        end.freeze
 
-      # Converts the chord to a specific scale with the notes in the chord
-      def as_scale
+        Chord.new(@root.octave(octave), @scale, chord_definition, @move, @duplicate, source_notes_map)
       end
 
-      def project_on_all(*scales, allow_chromatic: nil)
-        # TODO add match to other chords... what does it means?
-        allow_chromatic ||= false
-
-        note_sets = {}
-        scales.each do |scale|
-          note_sets[scale] = if allow_chromatic
-            @notes.values.flatten(1).collect { |n| n.on(scale) || n.on(scale.chromatic) }
-          else
-            @notes.values.flatten(1).collect { |n| n.on(scale) }
-                             end
-        end
-
-        note_sets_in_scale = note_sets.values.reject { |notes| notes.include?(nil) }
-        note_sets_in_scale.collect { |notes| Chord.new(notes: notes) }
+      def move(**octaves)
+        Chord.new(@root, @scale, @chord_definition, @move.merge(octaves), @duplicate, @source_notes_map)
       end
 
-      def project_on(*scales, allow_chromatic: nil)
-        allow_chromatic ||= false
-        project_on_all(*scales, allow_chromatic: allow_chromatic).first
+      def duplicate(**octaves)
+        Chord.new(@root, @scale, @chord_definition, @move, @duplicate.merge(octaves), @source_notes_map)
       end
 
       def ==(other)
-        self.class == other.class && @notes == other.notes
+        self.class == other.class &&
+          @sorted_notes == other.notes &&
+          @chord_definition == other.chord_definition
       end
 
       def inspect
-        "<Chord: notes = #{@notes}>"
+        "<Chord #{@name} root #{@root} notes #{@sorted_notes.collect { |_| "#{_.grade}=#{_.note.grade}|#{_.note.pitch} "} }>"
       end
 
       alias to_s inspect
 
-      private
-
-      def compute_notes(name, root_pitch, scale, notes, pitches, features, allow_chromatic)
-        if name && root_pitch && scale && !(notes || pitches || features)
-
-          chord_definition = ChordDefinition[name]
-
-          raise ArgumentError, "Unrecognized #{name} chord" unless chord_definition
-
-          chord_definition.pitch_offsets.transform_values do |offset|
-            pitch = root_pitch + offset
-            [scale.note_of_pitch(pitch) || scale.chromatic.note_of_pitch(pitch)]
-          end
-
-        elsif root_pitch && features && scale && !(name || notes || pitches)
+      private def compute_moved_and_duplicated(notes_map, moved, duplicated)
+        notes_map = notes_map.transform_values(&:dup)
 
-          chord_definitions = ChordDefinition.find_by_features(**features)
-
-          unless allow_chromatic
-            chord_definitions.reject! do |chord_definition|
-              chord_definition.pitches(root_pitch).find { |chord_pitch| scale.note_of_pitch(chord_pitch).nil? }
-            end
-          end
-
-          selected = chord_definitions.first
-
-          unless selected
-            raise ArgumentError, "Don't know how to create a chord with root pitch #{root_pitch}"\
-            " and features #{features} based on scale #{scale.kind.class} with root on #{scale.root}: "\
-            " no suitable definition found (allow_chromatic is #{allow_chromatic})"
-          end
+        moved&.each do |position, octave|
+          notes_map[position][0] = notes_map[position][0].octave(octave)
+        end
 
-          selected.pitch_offsets.transform_values do |offset|
-            pitch = root_pitch + offset
-            [scale.note_of_pitch(pitch) || scale.chromatic.note_of_pitch(pitch)]
+        duplicated&.each do |position, octave|
+          octave.arrayfy.each do |octave|
+            notes_map[position] << notes_map[position][0].octave(octave)
           end
-
-        elsif (notes || pitches && scale) && !(name || root_pitch || features)
-
-          notes ||= []
-
-          notes += pitches.collect { |p| scale.note_of_pitch(p) } if pitches
-
-          chord_definition = ChordDefinition.find_by_pitches(notes.collect(&:pitch))
-
-          raise "Can't find a chord definition for pitches #{pitches} on scale #{scale.kind.id} based on #{scale.root}" unless chord_definition
-
-          chord_definition.named_pitches(notes, &:pitch)
-        else
-          pattern = { name: name, root: root_pitch, scale: scale, notes: notes, pitches: pitches, features: features, allow_chromatic: allow_chromatic }
-          raise ArgumentError, "Can't understand chord definition pattern #{pattern}"
         end
-      end
 
-      def compute_notes_from_source(source, name, root_pitch, scale, notes, pitches, features, allow_chromatic)
-        if !(name || root_pitch || scale || notes || pitches || features)
-          source.notes
-
-        elsif features && !(name || root_pitch || scale || notes || pitches)
-          compute_notes(nil, source.root.first.pitch, source.root.first.scale, nil, nil, features, allow_chromatic)
-
-        else
-          pattern = { name: name, root: root_pitch, scale: scale, notes: notes, pitches: pitches, features: features, allow_chromatic: allow_chromatic }
-          raise ArgumentError, "Can't understand chord definition pattern #{pattern}"
-        end
+        notes_map.tap { |_| _.values.each(&:freeze) }.freeze
       end
     end
   end
 end
+

data/lib/musa-dsl/music/equally-tempered-12-tone-scale-system.rb

@@ -70,31 +70,31 @@ module Musa
     class MajorScaleKind < ScaleKind
       class << self
         @@pitches =
-            [{ functions: %i[I _1 tonic],
+            [{ functions: %i[I _1 tonic first],
                pitch: 0 },
-             { functions: %i[II _2 supertonic],
+             { functions: %i[II _2 supertonic second],
                pitch: 2 },
-             { functions: %i[III _3 mediant],
+             { functions: %i[III _3 mediant third],
                pitch: 4 },
-             { functions: %i[IV _4 subdominant],
+             { functions: %i[IV _4 subdominant fourth],
                pitch: 5 },
-             { functions: %i[V _5 dominant],
+             { functions: %i[V _5 dominant fifth],
                pitch: 7 },
-             { functions: %i[VI _6 submediant relative relative_minor],
+             { functions: %i[VI _6 submediant relative relative_minor sixth],
                pitch: 9 },
-             { functions: %i[VII _7 leading],
+             { functions: %i[VII _7 leading seventh],
                pitch: 11 },
-             { functions: %i[VIII _8],
+             { functions: %i[VIII _8 eighth],
                pitch: 12 },
-             { functions: %i[IX _9],
+             { functions: %i[IX _9 ninth],
                pitch: 12 + 2 },
-             { functions: %i[X _10],
+             { functions: %i[X _10 tenth],
                pitch: 12 + 4 },
-             { functions: %i[XI _11],
+             { functions: %i[XI _11 eleventh],
                pitch: 12 + 5 },
-             { functions: %i[XII _12],
+             { functions: %i[XII _12 twelfth],
                pitch: 12 + 7 },
-             { functions: %i[XIII _13],
+             { functions: %i[XIII _13 thirteenth],
                pitch: 12 + 9 }].freeze
 
         def pitches
@@ -113,34 +113,34 @@ module Musa
       EquallyTempered12ToneScaleSystem.register MajorScaleKind
     end
 
-    class MinorScaleKind < ScaleKind
+    class MinorNaturalScaleKind < ScaleKind
       class << self
         @@pitches =
-            [{ functions: %i[i _1 tonic],
+            [{ functions: %i[i _1 tonic first],
                pitch: 0 },
-             { functions: %i[ii _2 supertonic],
+             { functions: %i[ii _2 supertonic second],
                pitch: 2 },
-             { functions: %i[iii _3 mediant relative relative_major],
+             { functions: %i[iii _3 mediant relative relative_major third],
                pitch: 3 },
-             { functions: %i[iv _4 subdominant],
+             { functions: %i[iv _4 subdominant fourth],
                pitch: 5 },
-             { functions: %i[v _5 dominant],
+             { functions: %i[v _5 dominant fifth],
                pitch: 7 },
-             { functions: %i[vi _6 submediant],
+             { functions: %i[vi _6 submediant sixth],
                pitch: 8 },
-             { functions: %i[vii _7],
+             { functions: %i[vii _7 seventh],
                pitch: 10 },
-             { functions: %i[viii _8],
+             { functions: %i[viii _8 eighth],
                pitch: 12 },
-             { functions: %i[ix _9],
+             { functions: %i[ix _9 ninth],
                pitch: 12 + 2 },
-             { functions: %i[x _10],
+             { functions: %i[x _10 tenth],
                pitch: 12 + 3 },
-             { functions: %i[xi _11],
+             { functions: %i[xi _11 eleventh],
                pitch: 12 + 5 },
-             { functions: %i[xii _12],
+             { functions: %i[xii _12 twelfth],
                pitch: 12 + 7 },
-             { functions: %i[xiii _13],
+             { functions: %i[xiii _13 thirteenth],
                pitch: 12 + 8 }].freeze
 
         def pitches
@@ -156,7 +156,7 @@ module Musa
         end
       end
 
-      EquallyTempered12ToneScaleSystem.register MinorScaleKind
+      EquallyTempered12ToneScaleSystem.register MinorNaturalScaleKind
     end
 
     class MinorHarmonicScaleKind < ScaleKind

data/lib/musa-dsl/music/scales.rb

@@ -1,3 +1,5 @@
+require_relative 'chords'
+
 module Musa
   module Scales
     module Scales
@@ -180,8 +182,6 @@ module Musa
     end
 
     class ScaleKind
-      extend Forwardable
-
       def initialize(tuning)
         @tuning = tuning
         @scales = {}
@@ -194,6 +194,10 @@ module Musa
         @scales[root_pitch]
       end
 
+      def default_root
+        self[60]
+      end
+
       def absolut
         self[0]
       end
@@ -277,6 +281,7 @@ module Musa
           end
         end
 
+        freeze
       end
 
       def_delegators :@kind, :a_tuning
@@ -406,10 +411,6 @@ module Musa
         @kind.tuning.offset_of_interval(interval_name)
       end
 
-      def chord_of(*grades_or_symbols)
-        Chord.new(notes: grades_or_symbols.collect { |g| self[g] })
-      end
-
       def ==(other)
         self.class == other.class &&
             @kind == other.kind &&
@@ -454,13 +455,13 @@ module Musa
         @scale.kind.class.pitches[grade][:functions]
       end
 
-      def octave(octave = nil)
+      def octave(octave = nil, absolute: false)
         if octave.nil?
           @octave
         else
           raise ArgumentError, "#{octave} is not integer" unless octave == octave.to_i
 
-          @scale[@grade + (@octave + octave) * @scale.kind.class.grades]
+          @scale[@grade + ((absolute ? 0 : @octave) + octave) * @scale.kind.class.grades]
         end
       end
 
@@ -558,11 +559,20 @@ module Musa
         scale.note_of_pitch @pitch
       end
 
-      def chord(*feature_values, allow_chromatic: nil, **features_hash)
+      def chord(*feature_values,
+                allow_chromatic: nil,
+                move: nil,
+                duplicate: nil,
+                **features_hash)
+
         features = { size: :triad } if feature_values.empty? && features_hash.empty?
-        features ||= ChordDefinition.features_from(feature_values, features_hash)
+        features ||= Musa::Chords::ChordDefinition.features_from(feature_values, features_hash)
 
-        Musa::Chords::Chord.new(root: self, allow_chromatic: allow_chromatic, features: features)
+        Musa::Chords::Chord.with_root(self,
+                                      allow_chromatic: allow_chromatic,
+                                      move: move,
+                                      duplicate: duplicate,
+                                      **features)
       end
 
       def ==(other)

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

@@ -113,9 +113,11 @@ module Musa
         @client_threads.clear
       end
 
-      def puts(message)
+      def puts(*messages)
         if @connection
-          send output: @connection, content: message&.to_s
+          messages.each do |message|
+            send output: @connection, content: message&.to_s
+          end
         else
           @logger.warn('REPL') { "trying to print a message in Atom client but the client is not connected. Ignoring message \'#{message} \'." }
         end

data/lib/musa-dsl/sequencer/base-sequencer-implementation-play.rb

@@ -45,7 +45,12 @@ module Musa::Sequencer
         case operation[:current_operation]
         when :none
         when :block
-          __play_eval.block_procedure_binder.call operation[:current_parameter], control: control
+          # duplicating parameters as direct object value (operation[:current_parameter])
+          # and key_passed parameters (**operation[:current_parameter])
+          #
+          __play_eval.block_procedure_binder.call operation[:current_parameter],
+                                                  **operation[:current_parameter],
+                                                  control: control
 
         when :event
           control._launch operation[:current_event],

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

@@ -41,7 +41,7 @@ module Musa
                                          do_error_log: do_error_log,
                                          log_position_format: log_position_format
 
-        # dsl_context_class ||= DSLContext
+        dsl_context_class ||= DSLContext
 
         @dsl = dsl_context_class.new @sequencer, keep_block_context: keep_block_context
 

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

@@ -21,10 +21,12 @@ module Musa
           @logger.debug! if do_log
         end
 
+        @time_table = []
         @midi_parser = MIDIParser.new
       end
 
       attr_reader :input
+      attr_reader :time_table
 
       def input=(input_midi_port)
         @input = input_midi_port
@@ -121,6 +123,7 @@ module Musa
         case m.name
         when 'Start'
           process_start
+          @time_table.clear
 
         when 'Stop'
           @logger.debug('InputMidiClock') { 'processing Stop...' }
@@ -135,7 +138,15 @@ module Musa
           @logger.debug('InputMidiClock') { 'processing Continue... done' }
 
         when 'Clock'
-          yield if block_given? && @started
+          if block_given? && @started
+            start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+            yield
+            finish_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+
+            duration = finish_time - start_time
+            @time_table[duration] ||= 0
+            @time_table[duration] += 1
+          end
 
         when 'Song Position Pointer'
           new_position_in_midi_beats = m.data[0] & 0x7F | ((m.data[1] & 0x7F) << 7)

data/lib/musa-dsl.rb

@@ -1,5 +1,5 @@
 module Musa
-  VERSION = '0.26.5'.freeze
+  VERSION = '0.26.6.wip'.freeze
 end
 
 require_relative 'musa-dsl/core-ext'
@@ -54,7 +54,7 @@ module Musa::All
 
   include Musa::Darwin
   include Musa::Markov
-  include Musa::Backboner
+  include Musa::Rules
   include Musa::Variatio
 
   include Musa::MIDIRecorder

data/musa-dsl.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name        = 'musa-dsl'
-  s.version     = '0.26.5'
-  s.date        = '2022-02-25'
+  s.version     = '0.26.6'
+  s.date        = '2022-02-26'
   s.summary     = 'A simple Ruby DSL for making complex music'
   s.description = 'Musa-DSL: A Ruby framework and DSL for algorithmic sound and musical thinking and composition'
   s.authors     = ['Javier Sánchez Yeste']

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: musa-dsl
 version: !ruby/object:Gem::Version
-  version: 0.26.5
+  version: 0.26.6
 platform: ruby
 authors:
 - Javier Sánchez Yeste
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-25 00:00:00.000000000 Z
+date: 2022-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -161,10 +161,10 @@ files:
 - lib/musa-dsl/datasets/score/to-mxml/to-mxml.rb
 - lib/musa-dsl/datasets/v.rb
 - lib/musa-dsl/generative.rb
-- lib/musa-dsl/generative/backboner.rb
 - lib/musa-dsl/generative/darwin.rb
 - lib/musa-dsl/generative/generative-grammar.rb
 - lib/musa-dsl/generative/markov.rb
+- lib/musa-dsl/generative/rules.rb
 - lib/musa-dsl/generative/variatio.rb
 - lib/musa-dsl/logger.rb
 - lib/musa-dsl/logger/logger.rb