coltrane 2.0.0 → 2.1.0

data/lib/coltrane/chord_quality.rb

@@ -3,14 +3,15 @@
 module Coltrane
   # It describe the quality of a chord, like maj7 or dim.
   class ChordQuality < IntervalSequence
+    include Qualities
     attr_reader :name
+    # QUALITIES_FILE  = File.expand_path("#{'../' * 3}data/qualities.json", __FILE__)
 
     private
 
     def self.chord_trie
-      trie = YAML.load_file(
-        File.expand_path("#{'../' * 3}data/qualities.yml", __FILE__)
-      )
+      File.expand_path("#{'../' * 3}data/qualities.json", __FILE__)
+      trie = QUALITIES
 
       trie.clone_values from_keys: ['Perfect Unison', 'Major Third'],
                         to_keys: ['Perfect Unison', 'Major Second'],

data/lib/coltrane/circle_of_fifths.rb

@@ -0,0 +1,29 @@
+module Coltrane
+  class CircleOfFifths
+    attr_reader :notes
+
+    LETTER_SEQUENCE = %w[C G D A E B F].freeze
+
+    def initialize(start_note = Note['C'], size = Float::INFINITY)
+      index  = letters.index(start_note.name[0])
+      @notes = fifths(note: start_note - Interval.perfect_fifth,
+                      size: size,
+                      index: (index - 1) % LETTER_SEQUENCE.size)
+    end
+
+    private
+
+    def fifths(note:, index: nil, notes: [], size:)
+      return notes if size == 0
+      return notes if notes.any? && note.as(letters(index)).name == notes.first.name
+      fifths note: note + Interval.perfect_fifth,
+             notes: notes + [note.as(letters(index))],
+             index: index + 1,
+             size:  size - 1
+    end
+
+    def letters(i=nil)
+      i.nil? ? LETTER_SEQUENCE : LETTER_SEQUENCE[i % LETTER_SEQUENCE.size]
+    end
+  end
+end

data/lib/coltrane/classic_scales.rb

@@ -4,10 +4,8 @@ module Coltrane
   # This module deals with well known scales on music
   module ClassicScales
     SCALES = {
-      'Major'            => [2, 2, 1, 2, 2, 2, 1],
       'Pentatonic Major' => [2, 2, 3, 2, 3],
       'Blues Major'      => [2, 1, 1, 3, 2, 3],
-      'Natural Minor'    => [2, 1, 2, 2, 1, 2, 2],
       'Harmonic Minor'   => [2, 1, 2, 2, 1, 3, 1],
       'Hungarian Minor'  => [2, 1, 2, 1, 1, 3, 1],
       'Pentatonic Minor' => [3, 2, 2, 3, 2],
@@ -17,9 +15,15 @@ module Coltrane
       'Chromatic'        => [1] * 12
     }.freeze
 
-    MODES = {
-      'Major' => %w[Ionian Dorian Phrygian Lydian Mixolydian Aeolian Locrian]
-    }.freeze
+    GREEK_MODES = %w[
+      Ionian
+      Dorian
+      Phrygian
+      Lydian
+      Mixolydian
+      Aeolian
+      Locrian
+    ].freeze
 
     # Creates factories for scales
     SCALES.each do |name, distances|
@@ -28,62 +32,51 @@ module Coltrane
       end
     end
 
-    # Creates factories for Greek Modes and possibly others
-    MODES.each do |scale, modes|
-      modes.each_with_index do |mode, index|
-        mode_name = mode
-        mode_n = index + 1
-        define_method mode.underscore do |tone = 'C'|
-          new(*SCALES[scale], tone: tone, mode: mode_n, name: mode_name)
-        end
+    # Creates factories for Greek Modes
+    GREEK_MODES.each_with_index do |mode, index|
+      mode_name = mode
+      mode_n = index + 1
+      define_method mode.underscore do |tone = 'C'|
+        new(notes: DiatonicScale.new(tone).notes.rotate(index))
       end
     end
 
-    alias minor natural_minor
+    # Factories for the diatonic scale
+    def major(note='C')
+      DiatonicScale.new(note)
+    end
+
+    def minor(note='A')
+      DiatonicScale.new(note, major: false)
+    end
+
+    alias diatonic major
+    alias natural_minor minor
     alias pentatonic pentatonic_major
     alias blues blues_major
 
     def known_scales
-      SCALES.keys
+      SCALES.keys + ['Major', 'Natural Minor']
     end
 
-    # All but the chromatic
+    # List of scales appropriate for search
     def standard_scales
-      SCALES.reject { |k, _v| k == 'Chromatic' }
+      known_scales - ['Chromatic']
     end
 
     def fetch(name, tone = nil)
       Coltrane::Scale.public_send(name, tone)
     end
 
-    def from_key(key)
-      key_regex = /([A-G][#b]?)([mM]?)/
-      _, note, s = *key.match(key_regex)
-      scale = s == 'm' ? :minor : :major
-      Scale.public_send(scale, note)
-    end
-
-    # Will output a OpenStruct like the following:
-    # {
-    #   scales: [array of scales]
-    #   results: {
-    #     scale_name: {
-    #       note_number => found_notes
-    #     }
-    #   }
-    # }
-
     def having_notes(notes)
       format = { scales: [], results: {} }
-      OpenStruct.new begin
-        standard_scales.each_with_object(format) do |(name, intervals), output|
-          PitchClass.all.each.map do |tone|
-            scale = new(*intervals, tone: tone, name: scale)
-            output[:results][name] ||= {}
-            next if output[:results][name].key?(tone.integer)
-            output[:scales] << scale if scale.include?(notes)
-            output[:results][name][tone.integer] = scale.notes & notes
-          end
+      standard_scales.each_with_object(format) do |name, output|
+        PitchClass.all.each.map do |tone|
+          scale = send(name.underscore, tone)
+          output[:results][name] ||= {}
+          next if output[:results][name].key?(tone.integer)
+          output[:scales] << scale if scale.include?(notes)
+          output[:results][name][tone.integer] = scale.notes & notes
         end
       end
     end

data/lib/coltrane/diatonic_scale.rb

@@ -0,0 +1,34 @@
+module Coltrane
+  class DiatonicScale < Scale
+    def initialize(tone, major: true)
+      @major = major
+      tone   = Note[tone]
+      notes  = CircleOfFifths.new(tone - (major? ? 0 : 9), 7).notes.sort
+      super notes: notes.rotate(notes.index(tone))
+    end
+
+    def name
+      major? ? 'Major' : 'Natural Minor'
+    end
+
+    def relative_minor
+      minor? ? self : self.class.new(@tone + 9, major: false)
+    end
+
+    def relative_major
+      major? ? self : self.class.new(@tone - 9, major: true)
+    end
+
+    def relative
+      major? ? relative_minor : relative_major
+    end
+
+    def major?
+      !!@major
+    end
+
+    def minor?
+      !@major
+    end
+  end
+end

data/lib/coltrane/frequency.rb

@@ -21,7 +21,7 @@ module Coltrane
     end
 
     def octave(n)
-      frequency * 2**n
+      Frequency[frequency * 2**n]
     end
 
     def ==(other)

data/lib/coltrane/interval.rb

@@ -4,10 +4,16 @@ module Coltrane
   # Interval describe the logarithmic distance between 2 frequencies.
   # It's measured in cents.
   class Interval
+    include Comparable
+
     attr_reader :cents
 
     class << self
       alias [] new
+
+      def method_missing(method, *args)
+        IntervalClass.send(method, *args)
+      end
     end
 
     def initialize(cents)
@@ -46,5 +52,13 @@ module Coltrane
       when Interval then Interval[cents - other.cents]
       end
     end
+
+    def -@
+      Interval[-cents]
+    end
+
+    def <=>(other)
+      cents <=> other.cents
+    end
   end
 end

data/lib/coltrane/interval_class.rb

@@ -19,6 +19,8 @@ module Coltrane
       "#{q.interval_quality} #{n.to_i.interval_name}"
     end
 
+    def self.method_missing; end
+
     # Create full names and methods such as major_third? minor_seventh?
     # TODO: It's a mess and it really needs a refactor someday
     NAMES = INTERVALS.each_with_index.each_with_object({}) do |(interval, index), memo|
@@ -94,6 +96,10 @@ module Coltrane
       IntervalClass[semitones - other]
     end
 
+    def -@
+      IntervalClass[-semitones]
+    end
+
     private
 
     def self.interval_by_full_name(arg)

data/lib/coltrane/interval_sequence.rb

@@ -54,7 +54,6 @@ module Coltrane
         @distances = distances
         @intervals = intervals_from_distances(distances)
       else
-        require 'pry'; binding.pry
         raise 'Provide: [notes:] || [intervals:] || [distances:]'
       end
     end

data/lib/coltrane/key.rb

@@ -0,0 +1,14 @@
+module Coltrane
+  class Key < DiatonicScale
+    KEY_REGEX = /([A-G][#b]?)([mM]?)/
+
+    def initialize(notation)
+      _, note, s = *notation.match(KEY_REGEX)
+      super(note, major: s != 'm')
+    end
+
+    def self.[](notation)
+      new(notation)
+    end
+  end
+end

data/lib/coltrane/note.rb

@@ -30,9 +30,9 @@ module Coltrane
 
       chars  = note_name.chars
       letter = chars.shift
-      raise InvalidNoteError, arg unless ('A'..'G').cover?(letter)
+      raise InvalidNoteLetterError, arg unless ('A'..'G').cover?(letter)
       @alteration = chars.reduce(0) do |alt, symbol|
-        raise InvalidNoteError, arg unless ALTERATIONS.include?(symbol)
+        raise InvalidNoteLetterError, arg unless ALTERATIONS.include?(symbol)
         alt + ALTERATIONS[symbol]
       end
       super((PitchClass[letter].integer + @alteration) % PitchClass.size)
@@ -58,12 +58,47 @@ module Coltrane
       Note.new(name).tap { |n| n.alteration = x }
     end
 
+    def sharp?
+      alteration == 1
+    end
+
+    def double_sharp?
+      alteration == 2
+    end
+
+    def flat?
+      alteration == -1
+    end
+
+    def double_flat?
+      alteration == -2
+    end
+
+    def natural?
+      alteration == 0
+    end
+
     def accidents
       (@alteration > 0 ? '#' : 'b') * alteration.abs
     end
 
+    def -(other)
+      result = super(other)
+      result.is_a?(Note) ? result.alter(alteration) : result
+    end
+
+    def +(other)
+      result = super(other)
+      result.is_a?(Note) ? result.alter(alteration) : result
+    end
+
     def interval_to(note_name)
       Note[note_name] - self
     end
+
+    def as(letter)
+      a = (self - Note[letter])
+      alter([a.semitones, -((-a).semitones)].min_by(&:abs))
+    end
   end
 end

data/lib/coltrane/note_set.rb

@@ -6,7 +6,8 @@ module Coltrane
     extend Forwardable
 
     def_delegators :@notes, :first, :each, :size, :map, :reduce, :index,
-                   :[], :index, :empty?, :permutation, :include?, :<<
+                   :[], :index, :empty?, :permutation, :include?, :<<, :any?,
+                   :count, :rotate
 
     attr_reader :notes
 
@@ -21,7 +22,7 @@ module Coltrane
       @notes =
         case arg
         when NoteSet then arg.notes
-        when Array   then arg.map { |n| n.is_a?(Note) ? n : Note[n] }.uniq
+        when Array   then arg.compact.map { |n| n.is_a?(PitchClass) ? n : Note[n] }.uniq
         else raise InvalidNotesError, arg
         end
     end
@@ -61,6 +62,26 @@ module Coltrane
       map(&:integer)
     end
 
+    def accidentals
+      count(&:accidental?)
+    end
+
+    def sharps
+      count(&:sharp?)
+    end
+
+    def flats
+      count(&:flat?)
+    end
+
+    def alter(alteration)
+      NoteSet[*map {|n| n.alter(alteration)}]
+    end
+
+    def alter_accidentals(alteration)
+      NoteSet[*map {|n| n.alter(alteration) if n.accidental?}]
+    end
+
     def interval_sequence
       IntervalSequence.new(notes: self)
     end

data/lib/coltrane/pitch.rb

@@ -3,56 +3,90 @@
 module Coltrane
   # It describes a pitch, like E4 or Bb5. It's like a note, but it has an octave
   class Pitch
-    attr_reader :pitch_class, :octave
+    attr_reader :integer
 
     def initialize(notation_arg = nil,
-                   pitch_class: nil,
+                   note: nil,
                    octave: nil,
                    notation: nil,
                    frequency: nil)
 
-      @pitch_class, @octave =
-        if notation_arg || notation
-          pitch_class_and_octave_from_notation(notation_arg || notation)
-        elsif pitch_class && octave
-          [pitch_class, octave]
+      @integer = begin
+        if (n = notation_arg || notation)
+          n.is_a?(Integer) ? n : integer_from_notation(n)
+        elsif note && octave
+          integer_from_note_and_octave(Note[note], octave)
         elsif frequency
-          pitch_class_and_octave_from_frequency(frequency)
+          integer_from_frequency(frequency)
         else
-          raise InvalidArgumentsError
+          raise(InvalidArgumentsError)
         end
+      end
     end
 
-    private
+    def self.[](*args)
+      new *args
+    end
+
+    def scientific_notation
+      "#{pitch_class}#{octave}"
+    end
+
+    def pitch_class
+      PitchClass[integer]
+    end
+
+    def octave
+      (integer / 12) - 1
+    end
+
+    alias notation scientific_notation
+    alias name     scientific_notation
+    alias to_s     scientific_notation
+
+    alias hash integer
+    alias midi integer
 
-    def pitch_class_and_octave_from_notation(name)
-      pitch_class_notation, octaves = *name.match(/(.*)(\d)/)
-      [PitchClass.new(pitch_class_notation), octaves.to_f]
+    def ==(other)
+      integer == other.integer
     end
 
-    def pitch_class_and_octave_from_frequency(frequency)
-      [PitchClass[frequency], Math.log(f.to_f / TUNING, 2) / 12]
+    def frequency
+      pitch_class.frequency.octave(octave)
     end
 
-    #   def number_from_name(pitch_string)
-    #     Note[note].number + 12 * octaves.to_i
-    #   end
+    alias eql? ==
+    alias eq ==
 
-    #   def name
-    #     "#{note.name}#{octave}"
-    #   end
+    def +(other)
+      case other
+      when Integer then Pitch[integer + other]
+      end
+    end
+
+    def -(other)
+      case other
+      when Integer then Pitch[integer - other]
+      end
+    end
+
+    private
 
-    #   def octave
-    #     number / 12
-    #   end
+    def integer_from_notation(the_notation)
+      _, n, o = *the_notation.match(/(\D+)(\d+)/)
+      integer_from_note_and_octave(Note[n], o)
+    end
 
-    #   def note
-    #     Note[number]
-    #   end
+    def integer_from_note_and_octave(p, o)
+      12 * (o.to_i + 1) + p.integer
+    end
 
-    #   def +(other)
-    #     Pitch.new(number + (other.is_a?(Pitch) ? other.number : other))
-    #   end
-    # end
+    def integer_from_frequency(f)
+      octave_from_frequency(f) * 12 + PitchClass.new(frequency: f).integer
+    end
+
+    def octave_from_frequency(f)
+      Math.log(f.to_f / PitchClass['C'].frequency.to_f, 2).ceil
+    end
   end
 end