musa-dsl 0.14.32 → 0.21.0

data/lib/musa-dsl/music.rb

@@ -1,6 +1,6 @@
-require 'musa-dsl/music/scales'
-require 'musa-dsl/music/equally-tempered-12-tone-scale-system'
+require_relative 'music/scales'
+require_relative 'music/equally-tempered-12-tone-scale-system'
 
-require 'musa-dsl/music/chord-definition'
-require 'musa-dsl/music/chords'
-require 'musa-dsl/music/chord-definitions'
+require_relative 'music/chord-definition'
+require_relative 'music/chords'
+require_relative 'music/chord-definitions'

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

@@ -1,11 +1,11 @@
 module Musa
-  class ChordDefinition
-    class << self
-      def [](name)
+  module Chords
+    class ChordDefinition
+      def self.[](name)
         @definitions[name]
       end
 
-      def register(name, offsets:, **features)
+      def self.register(name, offsets:, **features)
         definition = ChordDefinition.new(name, offsets: offsets, **features).freeze
 
         @definitions ||= {}
@@ -17,11 +17,11 @@ module Musa
         self
       end
 
-      def find_by_pitches(pitches)
+      def self.find_by_pitches(pitches)
         @definitions.values.find { |d| d.matches(pitches) }
       end
 
-      def features_from(values = nil, hash = nil)
+      def self.features_from(values = nil, hash = nil)
         values ||= []
         hash ||= {}
 
@@ -31,69 +31,73 @@ module Musa
         features
       end
 
-      def find_by_features(*values, **hash)
+      def self.find_by_features(*values, **hash)
         features = features_from(values, hash)
         @definitions.values.select { |d| features <= d.features }
       end
 
-      def feature_key_of(feature_value)
+      def self.feature_key_of(feature_value)
         @features_by_value[feature_value]
       end
-    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
-    end
+      def self.feature_values
+        @features_by_value.keys
+      end
 
-    attr_reader :name, :features, :pitch_offsets, :pitch_names
+      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
+      end
 
-    def pitches(root_pitch)
-      @pitch_offsets.values.collect { |offset| root_pitch + offset }
-    end
+      attr_reader :name, :features, :pitch_offsets, :pitch_names
 
-    def named_pitches(elements_or_pitches, &block)
-      pitches = elements_or_pitches.collect do |element_or_pitch|
-        [if block_given?
-           yield element_or_pitch
-         else
-           element_or_pitch
-         end,
-         element_or_pitch]
-      end.to_h
-
-      root_pitch = pitches.keys.find do |candidate_root_pitch|
-        candidate_pitches = pitches.keys.collect { |p| p - candidate_root_pitch }
-        octave_reduce(candidate_pitches).uniq == octave_reduce(@pitch_offsets.values).uniq
+      def pitches(root_pitch)
+        @pitch_offsets.values.collect { |offset| root_pitch + offset }
       end
 
-      # TODO: OJO: problema con las notas duplicadas, con la identificación de inversiones y con las notas a distancias de más de una octava
-
-      pitches.collect do |pitch, element|
-        [@pitch_names[pitch - root_pitch], [element]]
-      end.to_h
-    end
+      def named_pitches(elements_or_pitches, &block)
+        pitches = elements_or_pitches.collect do |element_or_pitch|
+          [if block_given?
+             yield element_or_pitch
+           else
+             element_or_pitch
+           end,
+           element_or_pitch]
+        end.to_h
+
+        root_pitch = pitches.keys.find do |candidate_root_pitch|
+          candidate_pitches = pitches.keys.collect { |p| p - candidate_root_pitch }
+          octave_reduce(candidate_pitches).uniq == octave_reduce(@pitch_offsets.values).uniq
+        end
+
+        # TODO: OJO: problema con las notas duplicadas, con la identificación de inversiones y con las notas a distancias de más de una octava
+
+        pitches.collect do |pitch, element|
+          [@pitch_names[pitch - root_pitch], [element]]
+        end.to_h
+      end
 
-    def matches(pitches)
-      reduced_pitches = octave_reduce(pitches).uniq
+      def matches(pitches)
+        reduced_pitches = octave_reduce(pitches).uniq
 
-      !!reduced_pitches.find do |candidate_root_pitch|
-        reduced_pitches.sort == octave_reduce(pitches(candidate_root_pitch)).uniq.sort
+        !!reduced_pitches.find do |candidate_root_pitch|
+          reduced_pitches.sort == octave_reduce(pitches(candidate_root_pitch)).uniq.sort
+        end
       end
-    end
 
-    def inspect
-      "<ChordDefinition: name = #{@name} features = #{@features} pitch_offsets = #{@pitch_offsets}>"
-    end
+      def inspect
+        "<ChordDefinition: name = #{@name} features = #{@features} pitch_offsets = #{@pitch_offsets}>"
+      end
 
-    alias to_s inspect
+      alias to_s inspect
 
-    protected
+      protected
 
-    def octave_reduce(pitches)
-      pitches.collect { |p| p % 12 }
+      def octave_reduce(pitches)
+        pitches.collect { |p| p % 12 }
+      end
     end
   end
 end

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

@@ -1,13 +1,17 @@
-Musa::ChordDefinition.register :maj, quality: :major, size: :triad, offsets: { root: 0, third: 4, fifth: 7 }
-Musa::ChordDefinition.register :min, quality: :minor, size: :triad, offsets: { root: 0, third: 3, fifth: 7 }
+require_relative 'chord-definition'
 
-Musa::ChordDefinition.register :maj7, quality: :major, size: :seventh, offsets: { root: 0, third: 4, fifth: 7, seventh: 11 }
-Musa::ChordDefinition.register :maj7, quality: :major, size: :seventh, dominant: :dominant , offsets: { root: 0, third: 4, fifth: 7, seventh: 10 }
+include Musa::Chords
 
-Musa::ChordDefinition.register :min7, quality: :minor, size: :seventh, offsets: { root: 0, third: 3, fifth: 7, seventh: 11 }
+ChordDefinition.register :maj, quality: :major, size: :triad, offsets: { root: 0, third: 4, fifth: 7 }
+ChordDefinition.register :min, quality: :minor, size: :triad, offsets: { root: 0, third: 3, fifth: 7 }
 
-Musa::ChordDefinition.register :maj9, quality: :major, size: :ninth, offsets: { root: 0, third: 4, fifth: 7, seventh: 11, ninth: 14 }
-Musa::ChordDefinition.register :min9, quality: :minor, size: :ninth, offsets: { root: 0, third: 3, fifth: 7, seventh: 11, ninth: 14 }
+ChordDefinition.register :maj7, quality: :major, size: :seventh, offsets: { root: 0, third: 4, fifth: 7, seventh: 11 }
+ChordDefinition.register :maj7, quality: :major, size: :seventh, dominant: :dominant , offsets: { root: 0, third: 4, fifth: 7, seventh: 10 }
 
-Musa::ChordDefinition.register :maj11, quality: :major, size: :eleventh, offsets: { root: 0, third: 4, fifth: 7, seventh: 11, ninth: 14, eleventh: 17 }
-Musa::ChordDefinition.register :min11, quality: :minor, size: :eleventh, offsets: { root: 0, third: 3, fifth: 7, seventh: 11, ninth: 14, eleventh: 17 }
+ChordDefinition.register :min7, quality: :minor, size: :seventh, offsets: { root: 0, third: 3, fifth: 7, seventh: 11 }
+
+ChordDefinition.register :maj9, quality: :major, size: :ninth, offsets: { root: 0, third: 4, fifth: 7, seventh: 11, ninth: 14 }
+ChordDefinition.register :min9, quality: :minor, size: :ninth, offsets: { root: 0, third: 3, fifth: 7, seventh: 11, ninth: 14 }
+
+ChordDefinition.register :maj11, quality: :major, size: :eleventh, offsets: { root: 0, third: 4, fifth: 7, seventh: 11, ninth: 14, eleventh: 17 }
+ChordDefinition.register :min11, quality: :minor, size: :eleventh, offsets: { root: 0, third: 3, fifth: 7, seventh: 11, ninth: 14, eleventh: 17 }

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

@@ -1,326 +1,324 @@
 require_relative 'scales'
 require_relative 'chord-definition'
 
+using Musa::Extension::Arrayfy
+
 module Musa
-  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 Musa::NoteInScale
-            n
-          when Numeric, Symbol
-            scale[n]
-          else
-            raise ArgumentError, "Can't recognize #{n} in notes list #{notes}"
+  module Chords
+    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]
+            else
+              raise ArgumentError, "Can't recognize #{n} in notes list #{notes}"
+            end
           end
         end
-      end
 
-      pitches = pitches.clone if pitches
+        pitches = pitches.clone if pitches
 
-      # Preparing root_pitch
-      #
+        # Preparing root_pitch
+        #
 
-      root_pitch = nil
+        root_pitch = nil
 
-      raise ArgumentError, "Duplicate parameter: root: #{root} and root_grade: #{root_grade}" if root && root_grade
+        raise ArgumentError, "Duplicate parameter: root: #{root} and root_grade: #{root_grade}" if root && root_grade
 
-      allow_chromatic ||= scale.nil?
+        allow_chromatic ||= scale.nil?
 
-      if root && root.is_a?(Musa::NoteInScale)
-        root_pitch = root.pitch
-        scale ||= root.scale
-      end
-
-      raise ArgumentError, "Don't know how to recognize root_grade #{root_grade}: scale is not provided" if root_grade && !scale
-
-      root_pitch = scale[root_grade].pitch if root_grade && scale
-
-      # 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
+        if root && root.is_a?(Scales::NoteInScale)
+          root_pitch = root.pitch
+          scale ||= root.scale
+        end
 
-        name = name_or_notes_or_pitches
+        raise ArgumentError, "Don't know how to recognize root_grade #{root_grade}: scale is not provided" if root_grade && !scale
+
+        root_pitch = scale[root_grade].pitch if root_grade && scale
+
+        # 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
 
-      when Array
-        name_or_notes_or_pitches.each do |note_or_pitch|
-          case note_or_pitch
-          when Musa::NoteInScale
-            notes ||= [] << note_or_pitch
-          when Numeric
-            if scale
               notes ||= [] << scale[note_or_pitch]
             else
-              pitches ||= [] << note_or_pitch
+              raise ArgumentError, "Can't recognize #{note_or_pitch} in parameter list #{name_or_notes_or_pitches}"
             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}"
           end
-        end
 
-      when nil
-        # nothing happens
-      else
-        raise ArgumentError, "Can't recognize #{name_or_notes_or_pitches}"
-      end
+        when nil
+          # nothing happens
+        else
+          raise ArgumentError, "Can't recognize #{name_or_notes_or_pitches}"
+        end
 
-      # Eval definitory atributes
-      #
+        # Eval definitory atributes
+        #
 
-      if _source.nil?
-        @notes = compute_notes(name, root_pitch, scale, notes, pitches, features, allow_chromatic)
-      else
-        @notes = compute_notes_from_source(_source, name, root_pitch, scale, notes, pitches, features, allow_chromatic)
-      end
+        if _source.nil?
+          @notes = compute_notes(name, root_pitch, scale, notes, pitches, features, allow_chromatic)
+        else
+          @notes = compute_notes_from_source(_source, name, root_pitch, scale, notes, pitches, features, allow_chromatic)
+        end
 
-      # Eval adding / droping operations
-      #
-
-      if add
-        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}"
+        # Eval adding / droping operations
+        #
+
+        if add
+          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
         end
-      end
 
-      # TODO: Missing chord operations: drop, inversion, state, position
-      #
-      raise NotImplementedError, 'Missing chord operations: drop, inversion, state, position' if drop || inversion || state || position
+        # TODO: Missing chord operations: drop, inversion, state, position
+        #
+        raise NotImplementedError, 'Missing chord operations: drop, inversion, state, position' if drop || inversion || state || position
 
-      # Eval voice increment operations
-      #
+        # Eval voice increment operations
+        #
 
-      if move
-        raise ArgumentError, 'move: expected a Hash' unless move.is_a?(Hash)
+        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)
+          move.each do |position, octave|
+            @notes[position][0] = @notes[position][0].octave(octave)
+          end
         end
-      end
 
-      if duplicate
-        raise ArgumentError, 'duplicate: expected a Hash' unless duplicate.is_a?(Hash)
+        if duplicate
+          raise ArgumentError, 'duplicate: expected a Hash' unless duplicate.is_a?(Hash)
 
-        duplicate.each do |position, octave|
-          octave.arrayfy.each do |octave|
-            @notes[position] << @notes[position][0].octave(octave)
+          duplicate.each do |position, octave|
+            octave.arrayfy.each do |octave|
+              @notes[position] << @notes[position][0].octave(octave)
+            end
           end
         end
-      end
 
-      # Identify chord
-      #
+        # Identify chord
+        #
 
-      @notes.freeze
+        @notes.freeze
 
-      @chord_definition = ChordDefinition.find_by_pitches(@notes.values.flatten(1).collect(&:pitch))
-    end
+        @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)
+          end
+        end
+      end
 
-    attr_reader :notes, :chord_definition
+      attr_reader :notes, :chord_definition
 
-    def name(name = nil)
-      if name.nil?
-        @chord_definition.name if @chord_definition
-      else
-        Chord.new(_source: self, name: name)
+      def name(name = nil)
+        if name.nil?
+          @chord_definition.name if @chord_definition
+        else
+          Chord.new(_source: self, name: name)
+        end
       end
-    end
 
-    def features
-      @chord_definition.features if @chord_definition
-    end
+      def features
+        @chord_definition.features if @chord_definition
+      end
 
-    def featuring(*values, allow_chromatic: nil, **hash)
-      features = @chord_definition.features.dup if @chord_definition
-      features ||= {}
+      def featuring(*values, allow_chromatic: nil, **hash)
+        features = @chord_definition.features.dup if @chord_definition
+        features ||= {}
 
-      ChordDefinition.features_from(values, hash).each { |k, v| features[k] = v }
+        ChordDefinition.features_from(values, hash).each { |k, v| features[k] = v }
 
-      Chord.new(_source: self, allow_chromatic: allow_chromatic, features: features)
-    end
+        Chord.new(_source: self, allow_chromatic: allow_chromatic, features: features)
+      end
 
-    def root(root = nil)
-      if root.nil?
-        @notes[:root]
-      else
-        Chord.new(_source: self, root: root)
+      def root(root = nil)
+        if root.nil?
+          @notes[:root]
+        else
+          Chord.new(_source: self, root: root)
+        end
       end
-    end
 
-    def [](position)
-      case position
-      when Numeric
-        @notes.values[position]
-      when Symbol
-        @notes[position]
+      def [](position)
+        case position
+        when Numeric
+          @notes.values[position]
+        when Symbol
+          @notes[position]
+        end
       end
-    end
 
-    def move(**octaves)
-      Chord.new(_source: self, move: octaves)
-    end
+      def move(**octaves)
+        Chord.new(_source: self, move: octaves)
+      end
 
-    def duplicate(**octaves)
-      Chord.new(_source: self, duplicate: octaves)
-    end
+      def duplicate(**octaves)
+        Chord.new(_source: self, duplicate: octaves)
+      end
 
-    def scale
-      scales = @notes.values.flatten(1).collect(&:scale).uniq
-      scales.first if scales.size == 1
-    end
+      def scale
+        scales = @notes.values.flatten(1).collect(&:scale).uniq
+        scales.first if scales.size == 1
+      end
 
-    # Converts the chord to a specific scale with the notes in the chord
-    def as_scale
-    end
+      # Converts the chord to a specific scale with the notes in the chord
+      def as_scale
+      end
 
 
-    def project_on_all(*scales, allow_chromatic: nil)
-      # TODO add match to other chords... what does it means?
-      allow_chromatic ||= false
+      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|
-        if allow_chromatic
-          note_sets[scale] = @notes.values.flatten(1).collect { |n| n.on(scale) || n.on(scale.chromatic) }
-        else
-          note_sets[scale] = @notes.values.flatten(1).collect { |n| n.on(scale) }
+        note_sets = {}
+        scales.each do |scale|
+          if allow_chromatic
+            note_sets[scale] = @notes.values.flatten(1).collect { |n| n.on(scale) || n.on(scale.chromatic) }
+          else
+            note_sets[scale] = @notes.values.flatten(1).collect { |n| n.on(scale) }
+          end
         end
-      end
 
-      note_sets_in_scale = note_sets.values.reject { |notes| notes.include?(nil) }
-      note_sets_in_scale.collect { |notes| Chord.new(notes: notes) }
-    end
+        note_sets_in_scale = note_sets.values.reject { |notes| notes.include?(nil) }
+        note_sets_in_scale.collect { |notes| Chord.new(notes: notes) }
+      end
 
-    def project_on(*scales, allow_chromatic: nil)
-      allow_chromatic ||= false
-      project_on_all(*scales, allow_chromatic: allow_chromatic).first
-    end
+      def project_on(*scales, allow_chromatic: nil)
+        allow_chromatic ||= false
+        project_on_all(*scales, allow_chromatic: allow_chromatic).first
+      end
 
-    def ==(other)
-      self.class == other.class && @notes == other.notes
-    end
+      def ==(other)
+        self.class == other.class && @notes == other.notes
+      end
 
-    def inspect
-      "<Chord: notes = #{@notes}>"
-    end
+      def inspect
+        "<Chord: notes = #{@notes}>"
+      end
 
-    alias to_s inspect
+      alias to_s inspect
 
-    private
+      private
 
-    def compute_notes(name, root_pitch, scale, notes, pitches, features, allow_chromatic)
-      if name && root_pitch && scale && !(notes || pitches || features)
+      def compute_notes(name, root_pitch, scale, notes, pitches, features, allow_chromatic)
+        if name && root_pitch && scale && !(notes || pitches || features)
 
-        chord_definition = ChordDefinition[name]
+          chord_definition = ChordDefinition[name]
 
-        raise ArgumentError, "Unrecognized #{name} chord" unless chord_definition
+          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
+          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)
+        elsif root_pitch && features && scale && !(name || notes || pitches)
 
-        chord_definitions = ChordDefinition.find_by_features(**features)
+          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? }
+          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
-        end
 
-        selected = chord_definitions.first
+          selected = chord_definitions.first
 
-        unless selected
-          raise ArgumentError, "Don't know how to create a chord with root pitch #{root_pitch}"\
+          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
+          end
 
-        selected.pitch_offsets.transform_values do |offset|
-          pitch = root_pitch + offset
-          [scale.note_of_pitch(pitch) || scale.chromatic.note_of_pitch(pitch)]
-        end
+          selected.pitch_offsets.transform_values do |offset|
+            pitch = root_pitch + offset
+            [scale.note_of_pitch(pitch) || scale.chromatic.note_of_pitch(pitch)]
+          end
 
-      elsif (notes || pitches && scale) && !(name || root_pitch || features)
+        elsif (notes || pitches && scale) && !(name || root_pitch || features)
 
-        notes ||= []
+          notes ||= []
 
-        notes += pitches.collect { |p| scale.note_of_pitch(p) } if pitches
+          notes += pitches.collect { |p| scale.note_of_pitch(p) } if pitches
 
-        chord_definition = ChordDefinition.find_by_pitches(notes.collect(&:pitch))
+          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
+          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}"
+          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
-    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
+      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
-    end
+        elsif features && !(name || root_pitch || scale || notes || pitches)
+          compute_notes(nil, source.root.first.pitch, source.root.first.scale, nil, nil, features, allow_chromatic)
 
-    def method_missing(method_name, *args, **key_args, &block)
-      if ChordDefinition.feature_key_of(method_name) && args.empty? && key_args.empty? && !block
-        featuring(method_name)
-      else
-        super
+        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
     end
-
-    def respond_to_missing?(method_name, include_private)
-      ChordDefinition.feature_key_of(method_name) || super
-    end
   end
 end