musa-dsl 0.26.5 → 0.26.8

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,9 +281,10 @@ module Musa
           end
         end
 
+        freeze
       end
 
-      def_delegators :@kind, :a_tuning
+      def_delegators :@kind, :tuning
 
       attr_reader :kind, :root_pitch
 
@@ -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)