coltrane 1.0.26 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a61ddd2b2b38b4b0432cbe36b72aa0247f3ff438f2a0069fa89684c33251c9e3
-  data.tar.gz: 28d33ca354479eb0bb183b2d70266a6b4950de79cdfac7b71fc76efbe250526a
+  metadata.gz: 9c5035abfa591229d5cb00c1a55f95cbb7904fe4cb6fb02c3da0147ddb28713b
+  data.tar.gz: c9d0b5de4c65af3f8bcb59b202720eb84c8ad16ce8f422b03536c6382db4e606
 SHA512:
-  metadata.gz: f0f3ccd130860eb0ceed09ff135cde9e4e51d3327650121a263203fc4a4c374c40db38416fff38432b3ee8afe939cdff1aeff6f3fc0e3a1c60cf6063ddb21749
-  data.tar.gz: 3b717105ee23549585989bd926e6e34ec5b18f0e9863f9dfb110b48b7f7e41adaf7f156c7befc1ddc9a8585bafad692646d30956ce7dd598b07c83fd8bad468c
+  metadata.gz: 62c750bd90a06738d6e1cbae6cfd15a2c1b45e0b0771f888aaad11a34a48234d28338315a62cf664afb5ba364589e609c77390f3fe1905c721845ad5e1f686d1
+  data.tar.gz: 2dc63fb47d4f39df88daf56b24f0d0e229f274fe2807f57295461c4a26f05659932d5b8599f3285073a2a88cbf2fd4e1c3c6ae49d268900b2f643c7aa6645c13

data/CHANGELOG.md

@@ -10,12 +10,38 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - Refactor notes and add pitch frequencies, pitch classes
 
 
-## [1.1.25]
+## [1.1.0]
+
+### Changes
+- The qualities are now more procedural, less hardcoded as possible. The refactor
+  has caused the chord list shorter. That may be an issue for some users, and if
+  so, it should be addressed in next versions. However, I believe that reduces
+  the spam, since we are focusing on the more relevant chords, as they're the
+  basis for building more "exotic" chords.
+
+- Intervals are now registered and displayed in the english language order.
+  Ex: Minor Third was `3m` and now is `m3`.
+
+### Adds
+- A lot of helper methods for obtaining interval information! `Interval` has
+  methods like `#minor_third?`, `#major_second?`, which are pretty self-explanatory.
+  `#full_name` and `#full_names` are also added, the latter returning intervals that
+  are pretty much the same, such as Major Second and Major Ninth.
+  Interval sequences have methods like `#has_minor_third?` and `#third`, which will
+  return the third it has, no matter if its major, or minor.
+
+- Roman Chords and Chord Progressions are finally here! It's a bit experimental yet,
+  the latter definitely needs more specs.
+
+### Fixes
+- The changelog
+
+## [1.0.25]
 
 ### Fixes
 - Ruby version on the gemspec
 
-## [1.1.25]
+## [1.0.25]
 
 ### Removes
 - Caching, as after some refactoring it made no sense anymore
@@ -24,7 +50,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - Progressions and Roman Chords
 - Adds Progression command to the CLI
 
-## [1.1.24]
+## [1.0.24]
 
 ### Adds
 - Some coloring on guitar output
@@ -37,7 +63,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - Removes Natural sign ~padding~ for guitar instruments
 
 
-## [1.1.23]
+## [1.0.23]
 
 ### Adds
 - A changelog

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    coltrane (1.0.25)
+    coltrane (1.1.0)
       color (~> 1.8)
       facets (~> 3.1)
       mercenary (~> 0.3)

data/bin/console

@@ -3,12 +3,7 @@
 require "bundler/setup"
 require "coltrane"
 
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
+require "pry"
 
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start(__FILE__)
+include Coltrane
+Pry.start

data/data/qualities.yml

@@ -0,0 +1,83 @@
+# NOTE: suspended chords are added programatically
+
+Perfect Unison:
+  Minor Third:
+    Diminished Fifth:
+      name: dim
+      Diminished Seventh:
+        name: dim7
+        Minor Ninth:
+          name: dim9
+        Major Ninth:
+          name: dim(b9)
+      Minor Seventh:
+        name: m7b5
+        Minor Ninth:
+          name: m7b5b9
+          Perfect Eleventh:
+            name: m7b5b11
+            Major Thirteenth:
+              name: m7b5b13
+        Major Ninth:
+          name: m7b5(9)
+    Perfect Fifth:
+      name: m
+      Major Sixth:
+        name: m6
+      Minor Seventh:
+        name: m7
+        Minor Ninth:
+          name: m9
+          Perfect Eleventh:
+            name: m11
+      Major Seventh:
+        name: m(M7)
+        Major Ninth:
+          name: m(M9)
+          Perfect Eleventh:
+            name: m(M11)
+            Major Thirteenth:
+              name: m(M13)
+  Major Third:
+    Perfect Fifth:
+      name: M
+      Major Sixth:
+        name: M6
+        Major Ninth:
+          name: 6/9
+          Perfect Eleventh:
+            name: 6/9(add11)
+      Minor Seventh:
+        name: "7"
+        Major Ninth:
+          name: "9"
+          Perfect Eleventh:
+            name: "11"
+            Major Thirteenth:
+              name: "13"
+      Major Seventh:
+        name: M7
+        Major Ninth:
+          name: M9
+          Perfect Eleventh:
+            name: M11
+            Major Thirteenth:
+              name: M13
+    Augmented Fifth:
+      name: +
+      Minor Seventh:
+        name: "+7"
+        Major Ninth:
+          name: "+9"
+          Perfect Eleventh:
+            name: "+11"
+            Major Thirteenth:
+              name: "+13"
+      Major Seventh:
+        name: +M7
+        Major Ninth:
+          name: +M9
+          Perfect Eleventh:
+            name: +M11
+            Major Thirteenth:
+              name: +M13

data/lib/cli/chord.rb

@@ -17,7 +17,6 @@ module Coltrane
           end
 
         @chords.each do |chord|
-          raise ChordNotFoundError unless chord.named?
           desc = "#{chord.name} chord:"
           Coltrane::Cli::Notes.new chord.notes, on: on,
                                                 desc: desc,

data/lib/coltrane.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'yaml'
 
 require 'forwardable'
 require 'facets/multiton'
@@ -16,7 +17,6 @@ require 'coltrane/note_set'
 require 'coltrane/interval'
 require 'coltrane/interval_sequence'
 
-require 'coltrane/qualities'
 require 'coltrane/chord_quality'
 
 require 'coltrane/chord'

data/lib/coltrane/chord.rb

@@ -24,21 +24,15 @@ module Coltrane
     end
 
     def name
-      return @notes.names.join('/') unless named?
-      "#{root_note.name}#{quality.name}"
+      "#{root_note}#{quality}"
     end
 
+    alias to_s name
+
     def pretty_name
-      return @notes.names.join('/') unless named?
       "#{root_note.pretty_name}#{quality.name}"
     end
 
-    def named?
-      notes.size >= 3 &&
-        !root_note.nil? &&
-        !quality&.name.nil?
-    end
-
     def intervals
       IntervalSequence.new(NoteSet.new(notes))
     end

data/lib/coltrane/chord_quality.rb

@@ -4,19 +4,108 @@ module Coltrane
   # It describe the quality of a chord, like maj7 or dim.
   class ChordQuality < IntervalSequence
     attr_reader :name
-    include Qualities
+
+    private
+
+    def self.chord_trie
+      trie = YAML.load_file(
+        File.expand_path("#{'../'*3}data/qualities.yml", __FILE__)
+      )
+
+      trie.clone_values from_keys: ['Perfect Unison', 'Major Third'],
+                        to_keys: ['Perfect Unison', 'Major Second'],
+                        suffix: 'sus2'
+
+      trie.clone_values from_keys: ['Perfect Unison', 'Major Third'],
+                        to_keys: ['Perfect Unison', 'Perfect Fourth'],
+                        suffix: 'sus4'
+      trie.deep_dup
+    end
+
+    def self.intervals_per_name(quality_names: {}, intervals: [], hash: nil)
+      hash ||= chord_trie
+      return quality_names if hash.empty?
+      if hash['name']
+        quality_names.merge! hash.delete('name') => intervals.map {|n| Interval[n] }
+      end
+      hash.reduce(quality_names) do |memo, (interval, values)|
+        memo.merge intervals_per_name(hash:  values,
+                                      quality_names: quality_names,
+                                      intervals: intervals + [interval])
+      end
+    end
+
+    NAMES = intervals_per_name
+
+    def find_chord(given_interval_names, trie: self.class.chord_trie, last_name: nil)
+      return if trie.nil?
+      if given_interval_names.empty?
+        @found = true
+        return trie['name']
+      end
+      interval = given_interval_names.shift
+      new_trie = trie[interval]
+      find_chord given_interval_names, last_name: (trie['name'] || last_name),
+                                       trie: new_trie
+    end
+
+    def normal_sequence
+      %i[unison third! fifth sixth! seventh ninth eleventh! thirteenth]
+    end
+
+    def sus2_sequence
+      %i[unison second! fifth sixth! seventh ninth eleventh! thirteenth]
+    end
+
+    def sus4_sequence
+      %i[unison fourth! fifth sixth! seventh ninth eleventh! thirteenth]
+    end
+
+    def retrieve_chord_intervals(chord_sequence = normal_sequence)
+      ints = IntervalSequence.new(intervals: self)
+      chord_sequence.map do |int_sym|
+        next unless interval_name = ints.public_send(int_sym)
+        ints.delete(Interval[interval_name])
+        interval_name
+      end
+    end
+
+    public
+
+    def get_name
+      if result = find_chord([*retrieve_chord_intervals].compact)
+        return result
+      elsif result = find_chord([*retrieve_chord_intervals(sus2_sequence)].compact)
+        return result
+      elsif result = find_chord([*retrieve_chord_intervals(sus4_sequence)].compact)
+        return result
+      else
+        binding.pry
+        raise ChordNotFoundError
+      end
+    end
+
+
+    def suspension_type
+      if has_major_second?
+        'sus2'
+      else has_fourth?
+        'sus4'
+      end
+    end
 
     def initialize(name: nil, notes: nil)
       if !name.nil?
-        raise ChordNotFoundError unless (intervals = CHORD_QUALITIES[name])
         @name = name
-        super(intervals: intervals)
+        super(intervals: NAMES[name])
       elsif !notes.nil?
         super(notes: notes)
-        @name = CHORD_QUALITIES.key(intervals_semitones)
+        @name = get_name
       else
         raise WrongKeywordsError, '[name:] || [notes:]'
       end
     end
+
+    alias to_s name
   end
 end

data/lib/coltrane/classic_scales.rb

@@ -47,6 +47,11 @@ module Coltrane
       SCALES.keys
     end
 
+    # All but the chromatic
+    def standard_scales
+      SCALES.reject { |k,v| k == 'Chromatic' }
+    end
+
     def fetch(name, tone = nil)
       Coltrane::Scale.public_send(name, tone)
     end
@@ -71,7 +76,7 @@ module Coltrane
     def having_notes(notes)
       format = { scales: [], results: {} }
       OpenStruct.new(
-        SCALES.each_with_object(format) do |(name, intervals), output|
+        standard_scales.each_with_object(format) do |(name, intervals), output|
           Note.all.each.map do |tone|
             scale = new(*intervals, tone: tone, name: scale)
             output[:results][name] ||= {}

data/lib/coltrane/errors.rb

@@ -56,6 +56,15 @@ module Coltrane
             "\n\nA tip tho: always include the letter M for major"
     end
   end
+
+  class IntervalNotFoundError < ColtraneError
+    def initialize(arg)
+      super "The interval \"#{arg}\" that was provided wasn't found. "\
+            "If you're sure this interval exists, "\
+            "would you mind to suggest it's inclusion here: "\
+            'https://github.com/pedrozath/coltrane/issues '\
+    end
+  end
 end
 
 # rubocop:enable Style/Documentation

data/lib/coltrane/interval.rb

@@ -3,40 +3,111 @@
 module Coltrane
   # It describes a interval between 2 pitches
   class Interval
+    include Multiton
     attr_reader :semitones
 
-    NAMES = %w[
-      1P
-      2m
-      2M
-      3m
-      3M
-      4P
-      4A
-      5P
-      6m
-      6M
-      7m
-      7M
+    INTERVALS = %w[
+      P1
+      m2
+      M2
+      m3
+      M3
+      P4
+      A4
+      P5
+      m6
+      M6
+      m7
+      M7
     ].freeze
 
-    def initialize(arg)
-      @semitones = (case arg
-                    when Interval then arg.semitones
-                    when String   then NAMES.index(arg)
-                    when Numeric  then arg
-                    end) % 12
+    def self.split(interval)
+      interval.scan(/(\w)(\d\d?)/)[0]
     end
 
+    def self.full_name(interval)
+      q,n = split(interval)
+      "#{q.interval_quality} #{n.to_i.interval_name}"
+    end
+
+    # Create full names and methods such as major_third? minor_seventh?
+    # TODO: It's a mess and it really needs a refactor one day
+    NAMES = INTERVALS.each_with_index.reduce({}) do |memo, (interval, index)|
+      memo[interval] ||= []
+      2.times do |o|
+        q,i = split(interval)
+        num = o * 7 + i.to_i
+        prev_q = split(INTERVALS[(index - 1) % 12])[0]
+        next_q = split(INTERVALS[(index + 1) % 12])[0]
+        memo[interval] << full_name("#{q}#{num}")
+        memo[interval] << full_name("d#{(num - 1 + 1) % 14 + 1}") if next_q.match? /m|P/
+        next if q == 'A'
+        memo[interval] << full_name("A#{(num - 1 - 1) % 14 + 1}") if prev_q.match? /M|P/
+      end
+      memo
+    end
+
+    def self.[](arg)
+      new(case arg
+          when Interval then arg.semitones
+          when String   then INTERVALS.index(arg) || interval_by_full_name(arg)
+          when Numeric  then arg
+          end % 12)
+    end
+
+    ALL_FULL_NAMES = NAMES.values.flatten
+
+    NAMES.each do |interval_name, full_names|
+      full_names.each do |the_full_name|
+        define_method "#{the_full_name.underscore}?" do
+          name == interval_name
+        end
+        self.class.define_method "#{the_full_name.underscore}" do
+          self[interval_name]
+        end
+      end
+    end
+
+    def initialize(semitones)
+      @semitones = semitones
+    end
+
+    private_class_method :new
+
+    def all_full_names
+      ALL_FULL_NAMES
+    end
+
+
+
     def name
-      NAMES[semitones]
+      INTERVALS[semitones]
+    end
+
+    def full_name
+      self.class.full_name(name)
+    end
+
+    def full_names
+      NAMES[name]
     end
 
     def +(other)
       case other
-      when Numeric then Interval.new(semitones + other)
-      when Interval then Interval.new(semitones + other.semitones)
+      when Numeric then Interval[semitones + other]
+      when Interval then Interval[semitones + other.semitones]
+      end
+    end
+
+    private
+
+    def self.interval_by_full_name(arg)
+      NAMES.invert.each do |full_names, interval_name|
+        if full_names.include?(arg)
+          return INTERVALS.index(interval_name)
+        end
       end
+      raise IntervalNotFoundError, arg
     end
   end
 end

data/lib/coltrane/interval_sequence.rb

@@ -6,14 +6,50 @@ module Coltrane
     extend Forwardable
     attr_reader :intervals
 
-    def_delegators :@intervals, :map, :each, :[], :size, :reduce
+    def_delegators :@intervals, :map, :each, :[], :size,
+                   :reduce, :delete
+
+    Interval::ALL_FULL_NAMES.each do |full_name|
+      define_method "has_#{full_name.underscore}?" do
+        !!(intervals.detect {|i| i.public_send("#{full_name.underscore}?")})
+      end
+    end
+
+    (1..15).each do |i|
+      # defines methods like :fifth, :third, eleventh:
+      define_method i.interval_name.underscore do
+        priority = send("#{i.interval_name.underscore}!")
+        return priority unless priority.nil?
+        @intervals.each do |ix|
+          ix.full_names.detect do |ixx|
+            return ixx if ixx.match(/#{i.interval_name}/)
+          end
+        end
+        nil
+      end
+
+      define_method "#{i.interval_name.underscore}!" do
+        @intervals.each do |ix|
+          ix.full_names.detect do |ixx|
+            next if ixx.match(/Diminished|Augmented/)
+            return ixx if ixx.match? /#{i.interval_name}/
+          end
+        end
+        nil
+      end
+
+      # defines methods like :has_fifth?, :has_third?, has_eleventh?:
+      define_method "has_#{i.interval_name.underscore}?" do
+        !!@intervals.detect {|ix| ix.full_name.match(/#{i.interval_name}/) }
+      end
+    end
 
     def initialize(notes: nil, intervals: nil, distances: nil)
       if !notes.nil?
         notes = NoteSet[*notes] if notes.is_a?(Array)
         @intervals = intervals_from_notes(notes)
       elsif !intervals.nil?
-        @intervals = intervals.map { |i| Interval.new(i) }
+        @intervals = intervals.map { |i| Interval[i] }
       elsif !distances.nil?
         @distances = distances
         @intervals = intervals_from_distances(distances)
@@ -32,6 +68,16 @@ module Coltrane
       end + [12 - intervals_semitones.last]
     end
 
+    def names
+      intervals.map(&:name)
+    end
+
+    def has?(interval_name)
+      @intervals.include?(Interval[interval_name])
+    end
+
+    alias interval_names names
+
     def all
       intervals
     end
@@ -68,8 +114,6 @@ module Coltrane
       end
     end
 
-    def quality; end
-
     def intervals_semitones
       map(&:semitones)
     end
@@ -78,6 +122,10 @@ module Coltrane
       map(&:name)
     end
 
+    def full_names
+      map(&:full_name)
+    end
+
     def notes_for(root_note)
       NoteSet[
         *intervals.reduce([]) do |memo, interval|
@@ -86,10 +134,17 @@ module Coltrane
       ]
     end
 
+    def &(other)
+      case other
+      when Array then intervals & other
+      when IntervalSequence then intervals & other.semitones
+      end
+    end
+
     private
 
     def intervals_from_distances(distances)
-      distances[0..-2].reduce([Interval.new(0)]) do |memo, d|
+      distances[0..-2].reduce([Interval[0]]) do |memo, d|
         memo + [memo.last + d]
       end
     end

data/lib/coltrane/note.rb

@@ -7,6 +7,7 @@ module Coltrane
 
     attr_reader :name, :number
     alias id number
+    alias to_s name
 
     NOTES = {
       'C'  => 0,
@@ -78,7 +79,7 @@ module Coltrane
     def -(other)
       case other
       when Numeric then Note[number - other]
-      when Note    then Interval.new(other.number - number)
+      when Note    then Interval[other.number - number]
       end
     end
 

data/lib/coltrane/note_set.rb

@@ -21,7 +21,7 @@ module Coltrane
       @notes =
         case arg
         when NoteSet then arg.notes
-        when Array   then arg.map { |n| n.is_a?(Note) ? n : Note[n] }
+        when Array   then arg.map { |n| n.is_a?(Note) ? n : Note[n] }.uniq
         else raise InvalidNotesError, arg
         end
     end
@@ -46,6 +46,10 @@ module Coltrane
       map(&:name)
     end
 
+    def numbers
+      map(&:number)
+    end
+
     def transpose_to(note_name)
       transpose_by(root_note.interval_to(note_name).number)
     end

data/lib/coltrane/progression.rb

@@ -6,12 +6,54 @@ module Coltrane
   # Ex: Progression.new('I-IV-V', key: 'Am')
   class Progression
     extend ClassicProgressions
-    attr_reader :scale, :chords
+    attr_reader :scale, :chords, :notation
+
+    def self.find(*chords)
+      # chords.map! { |c| Chord.new(name: c) } if chords[0].is_a?(String)
+      # scales = Scale.having_chords(*chords).scales.map(&:pretty_name)
+      # scales.reduce([]) do |memo, scale|
+      #   memo
+      # end
+    end
+
+    def initialize(notation=nil, chords: nil, roman_chords: nil, key: nil, scale: nil)
+      if notation.nil? && chords.nil? && roman_chords.nil? || key.nil? && scale.nil?
+        raise WrongKeywordsError,
+          '[chords:, [scale: || key:]] '\
+          '[roman_chords:, [scale: || key:]] '\
+          '[notation:, [scale: || key:]] '\
+      end
 
-    def initialize(roman_notation, roman_chords: [], key: nil, scale: nil)
       @scale  = scale || Scale.from_key(key)
-      rchords = roman_chords.any? ? roman_chords : roman_notation.split('-')
-      @chords = rchords.map {|c| RomanChord.new(c, scale: @scale).chord }
+      @chords =
+        if !chords.nil?
+          chords
+        elsif !roman_chords.nil?
+          roman_chords.map(&:chord)
+        elsif !notation.nil?
+          @notation = notation
+          notation.split('-').map {|c| RomanChord.new(c, scale: @scale).chord }
+        end
+    end
+
+    def interval_sequence
+      @interval_sequence ||= IntervalSequence(notes: @root_notes)
+    end
+
+    def root_notes
+      @root_notes ||= @chords.map(&:root_note)
+    end
+
+    def roman_chords
+      @roman_chords ||= RomanChord.new()
+    end
+
+    def notation
+      @notation || @scale
+    end
+
+    def rotate
+
     end
   end
 end

data/lib/coltrane/roman_chord.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 module Coltrane
-  attr_reader :degree, :quality
-
   # This class deals with chords in roman notation. Ex: IVº.
   class RomanChord
     DIGITS = %w[I II III IV V VI VII].freeze
@@ -17,52 +15,92 @@ module Coltrane
       %w[ø m7b5]
     ]
 
-    def initialize(notation, key: nil, scale: nil)
-      @scale   = scale || Scale.from_key(key)
-      notation = notation.match(NOTATION_REGEX).named_captures
-      notation['quality'] =
-        NOTATION_SUBSTITUTIONS.reduce(notation['quality']) do |memo, subs|
-          break memo if memo.empty?
-          memo.gsub(*subs)
-        end
-
-      @notation = notation
+    def initialize(notation=nil, chord: nil, key: nil, scale: nil)
+      if notation.nil? && chord.nil? || key.nil? && scale.nil?
+        raise WrongKeywordsError,
+          '[notation, [scale: || key:]] '\
+          '[chord:, [scale: || key:]] '\
+      end
+      @scale = scale || Scale.from_key(key)
+      if !notation.nil?
+        @notation = notation
+      elsif !chord.nil?
+        @chord = chord.is_a?(String) ? Chord.new(name: chord) : chord
+      end
     end
 
     def degree
-      d      = @notation['degree']
+      return @scale.degree_of_note(root_note) unless @chord.nil?
+      d      = regexed_notation['degree']
       @flats = d.count('b')
       d      = d.delete('b')
       @degree ||= DIGITS.index(d.upcase) + 1
     end
 
-    def quality_name
-      [
-        minor_notation,
-        @notation['quality']
-      ].join
-    end
-
-    def minor_notation
-      return 'm' if !@notation['quality'].match?((/dim|m7b5/)) && !upcase?
+    def roman_numeral
+      r = DIGITS[degree]
+      minor? ? r.downcase : r
     end
 
     def upcase?
-      !!(@notation['degree'][0].match /[[:upper:]]/)
+      !!(regexed_notation['degree'][0].match /[[:upper:]]/)
     end
 
     def chord
-      Chord.new root_note: root_note,
-                quality: quality
+      @chord ||= Chord.new root_note: root_note,
+                           quality: quality
+    end
+
+    def minor?
+      quality.has_minor_third?
+    end
+
+    def major?
+      quality.has_major_third?
+    end
+
+    def quality_name
+      return @chord.quality.name unless @chord.nil?
+      q     = normalize_quality_name(regexed_notation['quality'])
+      minor = 'm' if !q.match?((/dim|m7b5/)) && !upcase?
+      q     = [minor, q].join
+      q.empty? ? 'M' : q
     end
 
     def quality
-      q = quality_name
-      ChordQuality.new(name: (q.size.zero? ? 'M' : q))
+      return @chord.quality unless @chord.nil?
+      ChordQuality.new(name: quality_name) if quality_name
     end
 
     def root_note
+      return @chord.root_note unless @chord.nil?
       @scale[degree] - @flats
     end
+
+    def notation
+      q = case quality_name
+      when 'm', 'M' then ''
+      when 'm7', 'M' then '7'
+      else quality_name
+      end
+
+      @notation ||= [
+        roman_numeral,
+        q,
+      ].join
+    end
+
+    private
+
+    def regexed_notation
+      @regexed_notation ||= @notation.match(NOTATION_REGEX).named_captures
+    end
+
+    def normalize_quality_name(quality_name)
+      NOTATION_SUBSTITUTIONS.reduce(quality_name) do |memo, subs|
+        break memo if memo.empty?
+        memo.gsub(*subs)
+      end
+    end
   end
 end

data/lib/coltrane/scale.rb

@@ -59,8 +59,7 @@ module Coltrane
     end
 
     def degree_of_note(note)
-      note = notes.map(&:name).index(note.name)
-      return note + 1 unless note.nil?
+      notes.index(note)
     end
 
     def &(other)
@@ -90,8 +89,13 @@ module Coltrane
     def tertians(n = 3)
       degrees.size.times.reduce([]) do |memo, d|
         ns = NoteSet[ *Array.new(n) { |i| notes[(d + (i * 2)) % size] } ]
-        chord = Chord.new(notes: ns)
-        chord.named? ? memo + [chord] : memo
+        begin
+          chord = Chord.new(notes: ns)
+        rescue ChordNotFoundError
+          memo
+        else
+          memo + [chord]
+        end
       end
     end
 
@@ -112,16 +116,17 @@ module Coltrane
     end
 
     def all_chords
-      (3..size).reduce([]) { |memo, s| memo + chords(s) }
+      chords
     end
 
-    def chords(size)
+    def chords(size = 3..12)
+      size = (size..size) if size.is_a?(Integer)
       included_names = []
-      scale_rotations = interval_sequence.inversions.map(&:intervals_semitones)
-      ChordQuality::CHORD_QUALITIES.reduce([]) do |memo1, (qname, qintervals)|
-        next memo1 if qintervals.size != size
+      scale_rotations = interval_sequence.inversions
+      ChordQuality.intervals_per_name.reduce([]) do |memo1, (qname, qintervals)|
+        next memo1 unless size.include?(qintervals.size)
         memo1 + scale_rotations.each_with_index.reduce([]) do |memo2, (rot, index)|
-          if (rot & qintervals).size == size
+          if (rot & qintervals).size == qintervals.size
             memo2 + [ Chord.new(root_note: degree(index+1),
                                 quality: ChordQuality.new(name: qname)) ]
           else

data/lib/coltrane/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Coltrane
-  VERSION = '1.0.26'
+  VERSION = '1.1.0'
 end

data/lib/core_ext.rb

@@ -12,4 +12,91 @@ class String
     word.downcase!
     word
   end
+
+  def interval_quality
+    {
+      'P' => 'Perfect',
+      'm' => 'Minor',
+      'M' => 'Major',
+      'A' => 'Augmented',
+      'd' => 'Diminished'
+    }[self]
+  end
+end
+
+class Integer
+  def interval_name
+    {
+      1   => 'Unison',
+      2   => 'Second',
+      3   => 'Third',
+      4   => 'Fourth',
+      5   => 'Fifth',
+      6   => 'Sixth',
+      7   => 'Seventh',
+      8   => 'Octave',
+      9   => 'Ninth',
+      10  => 'Tenth',
+      11  => 'Eleventh',
+      12  => 'Twelfth',
+      13  => 'Thirteenth',
+      14  => 'Fourteenth',
+      15  => 'Double Octave'
+    }[self % 16]
+  end
 end
+
+class Hash
+  def clone_values(from_keys: nil, to_keys: nil, suffix: nil, branch_a: nil, branch_b: nil)
+    branch_a ||= self.dig(*from_keys)
+    if branch_b.nil?
+      self.create_branch!(*to_keys)
+      branch_b = self.dig(*to_keys)
+    end
+
+    branch_a.each do |key, val|
+      if val.is_a?(Hash)
+        clone_values branch_a: branch_a[key],
+                     branch_b: (branch_b[key] ||= {}),
+                     suffix: suffix
+      else
+        branch_b[key] = "#{val.dup}#{suffix}"
+      end
+    end
+  end
+
+  def create_branch!(*keys)
+    return nil if keys.empty?
+    key = keys.shift
+    (self[key] ||= {}).create_branch!(*keys)
+  end
+
+  def deep_dup
+    dup_hash = {}
+    self.each do |k,v|
+      if v.is_a?(Hash)
+        dup_hash[k] = v.deep_dup
+      else
+        dup_hash[k] = v.dup
+      end
+    end
+    dup_hash
+  end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: coltrane
 version: !ruby/object:Gem::Version
-  version: 1.0.26
+  version: 1.1.0
 platform: ruby
 authors:
 - Pedro Maciel
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-02-08 00:00:00.000000000 Z
+date: 2018-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: facets
@@ -146,6 +146,7 @@ files:
 - bin/thor
 - bin/tilt
 - coltrane.gemspec
+- data/qualities.yml
 - db/cache.sqlite3
 - db/cache_test.sqlite3
 - db/config.yml
@@ -189,7 +190,6 @@ files:
 - lib/coltrane/piano_representation.rb
 - lib/coltrane/pitch.rb
 - lib/coltrane/progression.rb
-- lib/coltrane/qualities.rb
 - lib/coltrane/roman_chord.rb
 - lib/coltrane/scale.rb
 - lib/coltrane/version.rb

data/lib/coltrane/qualities.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  module Qualities
-    CHORD_QUALITIES = {
-      '5'          => [0, 7],
-      'Msus2'      => [0, 2, 7],
-      'dim'        => [0, 3, 6],
-      'm'          => [0, 3, 7],
-      'm#5'        => [0, 3, 8],
-      'Mb5'        => [0, 4, 6],
-      'M'          => [0, 4, 7],
-      'M#5'        => [0, 4, 8],
-      'Mb6'        => [0, 4, 8],
-      '7ndim5'     => [0, 4, 10],
-      'Msus4'      => [0, 5, 7],
-      'mb6b9'      => [0, 1, 3, 8],
-      'addb9'      => [0, 1, 4, 7],
-      'madd9'      => [0, 2, 3, 7],
-      'Madd9'      => [0, 2, 4, 7],
-      'sus24'      => [0, 2, 5, 7],
-      'M#5add9'    => [0, 2, 4, 8],
-      '9ndim5'     => [0, 2, 4, 10],
-      '+add#9'     => [0, 3, 4, 8],
-      'madd4'      => [0, 3, 5, 7],
-      '4'          => [0, 3, 5, 10],
-      'dim7'       => [0, 3, 6, 9],
-      'm7'         => [0, 3, 7, 10],
-      'mM7'        => [0, 3, 7, 11],
-      'm7#5'       => [0, 3, 8, 10],
-      '7b5'        => [0, 4, 6, 10],
-      '7'          => [0, 4, 7, 10],
-      '7#5'        => [0, 4, 8, 10],
-      '7b13'       => [0, 4, 8, 10],
-      'M7#5'       => [0, 4, 8, 11],
-      'M7b6'       => [0, 4, 8, 11],
-      'M7b5'       => [0, 4, 6, 11],
-      'M7#5sus4'   => [0, 5, 8, 11],
-      '7sus4'      => [0, 5, 7, 10],
-      '7#5sus4'    => [0, 5, 8, 10],
-      'M7sus4'     => [0, 5, 7, 11],
-      'M6'         => [0, 4, 7, 9],
-      'm7b5'       => [0, 3, 6, 10],
-      'M7'         => [0, 4, 7, 11],
-      'maj7'       => [0, 4, 7, 11],
-      'mb6M7'      => [0, 3, 8, 11],
-      'dimM7'      => [0, 3, 6, 11],
-      'm6'         => [0, 3, 5, 7, 9],
-      'm6/9'       => [0, 2, 3, 7, 9],
-      'M6/9'       => [0, 2, 4, 7, 9],
-      'M6#11'      => [0, 4, 6, 7, 9],
-      'm7add11'    => [0, 3, 5, 7, 10],
-      'dim7M7'     => [0, 3, 6, 9, 11],
-      'm9'         => [0, 2, 3, 7, 10],
-      'm9#5'       => [0, 2, 3, 8, 10],
-      'm9b5'       => [0, 2, 3, 6, 10],
-      'mM7b6'      => [0, 3, 7, 8, 11],
-      'mM9'        => [0, 2, 3, 7, 11],
-      'M7b9'       => [0, 1, 4, 7, 11],
-      'M9'         => [0, 2, 4, 7, 11],
-      'M9#5'       => [0, 2, 4, 8, 11],
-      'M9#5sus4'   => [0, 2, 5, 8, 11],
-      'M9b5'       => [0, 2, 4, 6, 11],
-      'M9sus4'     => [0, 2, 5, 7, 11],
-      'M7#11'      => [0, 4, 6, 7, 11],
-      '7#9'        => [0, 3, 4, 7, 10],
-      '7#11'       => [0, 4, 6, 7, 10],
-      '11'         => [0, 2, 5, 7, 10],
-      '11b9'       => [0, 1, 5, 7, 10],
-      '13ndim5'    => [0, 2, 4, 9, 10],
-      '7#5#9'      => [0, 3, 4, 8, 10],
-      '7#5b9'      => [0, 1, 4, 8, 10],
-      '7add6'      => [0, 4, 7, 9, 10],
-      '7b6'        => [0, 4, 7, 8, 10],
-      '7b9'        => [0, 1, 4, 7, 10],
-      '7sus4b9'    => [0, 1, 5, 7, 10],
-      '9'          => [0, 2, 4, 7, 10],
-      '9#5'        => [0, 2, 4, 8, 10],
-      '9b13'       => [0, 2, 4, 8, 10],
-      '9b5'        => [0, 2, 4, 6, 10],
-      '9sus4'      => [0, 2, 5, 7, 10],
-      'M6/9#11'    => [0, 2, 4, 6, 7, 9],
-      '6/9#11'     => [0, 2, 4, 6, 7, 9],
-      '9#5#11'     => [0, 2, 4, 6, 8, 10],
-      'Blues'      => [0, 3, 5, 6, 7, 10],
-      'm11'        => [0, 2, 3, 5, 7, 10],
-      'm11#5'      => [0, 2, 3, 5, 8, 10],
-      'm11b5'      => [0, 2, 3, 5, 6, 10],
-      '13b5'       => [0, 2, 4, 6, 9, 10],
-      '13b9'       => [0, 1, 4, 7, 9, 10],
-      '13sus4'     => [0, 2, 5, 7, 9, 10],
-      '7#11b13'    => [0, 4, 6, 7, 8, 10],
-      '7#5b9#11'   => [0, 1, 4, 6, 8, 10],
-      '7#9#11'     => [0, 3, 4, 6, 7, 10],
-      '7#9b13'     => [0, 3, 4, 7, 8, 10],
-      '13#9'       => [0, 3, 4, 7, 9, 10],
-      '13'         => [0, 2, 4, 7, 9, 10],
-      '7b9#11'     => [0, 1, 4, 6, 7, 10],
-      '7b9#9'      => [0, 1, 3, 4, 7, 10],
-      '7b9b13'     => [0, 1, 4, 7, 8, 10],
-      '7sus4b9b13' => [0, 1, 5, 7, 8, 10],
-      '9#11'       => [0, 2, 4, 6, 7, 10],
-      'M13'        => [0, 2, 4, 7, 9, 11],
-      'M7#9#11'    => [0, 3, 4, 6, 7, 11],
-      'M7add13'    => [0, 2, 4, 7, 9, 11],
-      'M9#11'      => [0, 2, 4, 6, 7, 11],
-      'mM9b6'      => [0, 2, 3, 7, 8, 11],
-      '7b9b13#11'  => [0, 1, 4, 6, 7, 8, 10],
-      '13b9#11'    => [0, 1, 4, 6, 7, 9, 10],
-      '9#11b13'    => [0, 2, 4, 6, 7, 8, 10],
-      '13#11'      => [0, 2, 4, 6, 7, 9, 10],
-      'M13#11'     => [0, 2, 4, 6, 7, 9, 11],
-      'm13'        => [0, 2, 3, 5, 7, 9, 10],
-      '13#9#11'    => [0, 3, 4, 6, 7, 9, 10],
-      '7#9#11b13'  => [0, 3, 4, 6, 7, 8, 10]
-    }.freeze
-  end
-end