coltrane 1.2.4 → 2.0.0

data/lib/cli/guitar.rb

@@ -24,7 +24,7 @@ module Coltrane
           string_note = Note[string]
           Array.new(@frets + 2) do |i|
             if i.zero?
-              Paint[string, HSL.new(140 + str_i * 20,50,50).html]
+              Paint[string, HSL.new(140 + str_i * 20, 50, 50).html]
             else
               fret = i - 1
               note = string_note + fret
@@ -37,14 +37,14 @@ module Coltrane
 
       def render_special_frets
         '  ' +
-        Array.new(@frets + 2) do |fret|
-          m = SPECIAL_FRETS.include?(fret) ? fret.to_s.rjust(2, 0.to_s) : '  '
-          "#{m}#{'  ' if fret.zero?}"
-        end.join(' ')
+          Array.new(@frets + 2) do |fret|
+            m = SPECIAL_FRETS.include?(fret) ? fret.to_s.rjust(2, 0.to_s) : '  '
+            "#{m}#{'  ' if fret.zero?}"
+          end.join(' ')
       end
 
       def place_empty(str_i)
-        Paint['--', HSL.new(180 + str_i * 3,50,30).html]
+        Paint['--', HSL.new(180 + str_i * 3, 50, 30).html]
       end
 
       def place_mark(note)
@@ -57,7 +57,7 @@ module Coltrane
           else raise WrongFlavorError
           end
 
-        base_hue = (180 + note.number * 10) % 360 # + 260
+        base_hue = (180 + note.integer * 10) % 360 # + 260
         Paint[
           mark,
           HSL.new(0, 0, 100).html,

data/lib/cli/representation.rb

@@ -31,7 +31,7 @@ module Coltrane
 
       def hint
         case @flavor
-        when :marks     then ''
+        when :marks then ''
         # when :notes     then "(\u266E means the note is natural, not flat nor sharp)"
         when :intervals
           <<~DESC

data/lib/coltrane.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'yaml'
 
 require 'forwardable'
@@ -10,11 +11,15 @@ require 'coltrane/version'
 require 'coltrane/errors'
 require 'coltrane/cadence'
 
-require 'coltrane/note'
+require 'coltrane/frequency'
 require 'coltrane/pitch'
+require 'coltrane/pitch_class'
+require 'coltrane/note'
 require 'coltrane/note_set'
 
 require 'coltrane/interval'
+require 'coltrane/interval_class'
+require 'coltrane/unordered_interval_class'
 require 'coltrane/interval_sequence'
 
 require 'coltrane/chord_quality'
@@ -31,3 +36,19 @@ require 'coltrane/changes'
 require 'coltrane/progression'
 
 require 'coltrane/mode'
+
+# The main module for working with Music Theory
+module Coltrane
+  BASE_OCTAVE = 4
+  BASE_PITCH_INTEGER = 9
+
+  def self.tuning=(f)
+    @base_tuning = Frequency[f].octave(-4)
+  end
+
+  def self.base_tuning
+    @base_tuning
+  end
+
+  @base_tuning = Frequency[440].octave(-4)
+end

data/lib/coltrane/cadence.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 module Coltrane
-
   # Not done yet
   class Cadence
   end

data/lib/coltrane/changes.rb

@@ -1,9 +1,7 @@
-module Changes
-  def coltrane_changes
-
-  end
+# frozen_string_literal: true
 
-  def bird_changes
+module Changes
+  def coltrane_changes; end
 
-  end
-end
+  def bird_changes; end
+end

data/lib/coltrane/chord.rb

@@ -8,19 +8,19 @@ module Coltrane
     include ChordSubstitutions
 
     def initialize(notes: nil, root_note: nil, quality: nil, name: nil)
-      if !notes.nil?
+      if notes
         notes      = NoteSet[*notes] if notes.is_a?(Array)
         @notes     = notes
         @root_note = notes.first
         @quality   = ChordQuality.new(notes: notes)
-      elsif !root_note.nil? && !quality.nil?
+      elsif root_note && quality
         @notes     = quality.notes_for(root_note)
         @root_note = root_note
         @quality   = quality
-      elsif !name.nil?
+      elsif name
         @root_note, @quality, @notes = parse_from_name(name)
       else
-      raise WrongKeywordsError,
+        raise WrongKeywordsError,
               '[notes:] || [root_note:, quality:] || [name:]'
       end
     end
@@ -76,13 +76,13 @@ module Coltrane
     protected
 
     def parse_from_name(name)
-      chord_name, bass = name.split('/')
-      chord_regex = %r{([A-Z](?:#|b)?)(.*)}
+      chord_name, bass = name.match?(/\/9/) ? [name, nil] : name.split('/')
+      chord_regex = /([A-Z](?:#|b)?)(.*)/
       _, root_name, quality_name = chord_name.match(chord_regex).to_a
       root    = Note[root_name]
       quality = ChordQuality.new(name: quality_name, bass: bass)
       notes   = quality.notes_for(root)
-      notes  << Note[bass] unless bass.nil?
+      notes << Note[bass] unless bass.nil?
       [root, quality, notes]
     end
   end

data/lib/coltrane/chord_quality.rb

@@ -9,7 +9,7 @@ module Coltrane
 
     def self.chord_trie
       trie = YAML.load_file(
-        File.expand_path("#{'../'*3}data/qualities.yml", __FILE__)
+        File.expand_path("#{'../' * 3}data/qualities.yml", __FILE__)
       )
 
       trie.clone_values from_keys: ['Perfect Unison', 'Major Third'],
@@ -26,7 +26,7 @@ module Coltrane
       hash ||= chord_trie
       return quality_names if hash.empty?
       if hash['name']
-        quality_names.merge! hash.delete('name') => intervals.map {|n| Interval[n] }
+        quality_names[hash.delete('name')] = intervals.map { |n| IntervalClass.new(n) }
       end
       hash.reduce(quality_names) do |memo, (interval, values)|
         memo.merge intervals_per_name(hash:  values,
@@ -65,7 +65,7 @@ module Coltrane
       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])
+        ints.delete_if { |i| i.cents == IntervalClass.new(interval_name).cents }
         interval_name
       end
     end
@@ -73,31 +73,25 @@ module Coltrane
     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
-        raise ChordNotFoundError
-      end
+      find_chord(retrieve_chord_intervals.compact) ||
+        find_chord(retrieve_chord_intervals(sus2_sequence).compact) ||
+        find_chord(retrieve_chord_intervals(sus4_sequence).compact) ||
+        raise(ChordNotFoundError)
     end
 
-
     def suspension_type
       if has_major_second?
         'sus2'
       else has_fourth?
-        'sus4'
+           'sus4'
       end
     end
 
     def initialize(name: nil, notes: nil, bass: nil)
-      if !name.nil?
+      if name
         @name = bass.nil? ? name : [name, bass].join('/')
-        super(intervals: NAMES[name])
-      elsif !notes.nil?
+        super(intervals: intervals_from_name(name))
+      elsif notes
         super(notes: notes)
         @name = get_name
       else
@@ -106,5 +100,11 @@ module Coltrane
     end
 
     alias to_s name
+
+    private
+
+    def intervals_from_name(name)
+      NAMES[name] || NAMES["M#{name}"] || raise(ChordNotFoundError)
+    end
   end
 end

data/lib/coltrane/chord_substitutions.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module Coltrane
   module ChordSubstitutions
     def tritone_substitution
       self + Interval.augmented_fourth
     end
   end
-end
+end

data/lib/coltrane/classic_scales.rb

@@ -14,7 +14,7 @@ module Coltrane
       'Blues Minor'      => [3, 2, 1, 1, 3, 2],
       'Whole Tone'       => [2, 2, 2, 2, 2, 2],
       'Flamenco'         => [1, 3, 1, 2, 1, 2, 2],
-      'Chromatic'        => [1]*12
+      'Chromatic'        => [1] * 12
     }.freeze
 
     MODES = {
@@ -49,7 +49,7 @@ module Coltrane
 
     # All but the chromatic
     def standard_scales
-      SCALES.reject { |k,v| k == 'Chromatic' }
+      SCALES.reject { |k, _v| k == 'Chromatic' }
     end
 
     def fetch(name, tone = nil)
@@ -75,17 +75,17 @@ module Coltrane
 
     def having_notes(notes)
       format = { scales: [], results: {} }
-      OpenStruct.new(
+      OpenStruct.new begin
         standard_scales.each_with_object(format) do |(name, intervals), output|
-          Note.all.each.map do |tone|
+          PitchClass.all.each.map do |tone|
             scale = new(*intervals, tone: tone, name: scale)
             output[:results][name] ||= {}
-            next if output[:results][name].key?(tone.number)
+            next if output[:results][name].key?(tone.integer)
             output[:scales] << scale if scale.include?(notes)
-            output[:results][name][tone.number] = scale.notes & notes
+            output[:results][name][tone.integer] = scale.notes & notes
           end
         end
-      )
+      end
     end
 
     def having_chords(*chords)

data/lib/coltrane/errors.rb

@@ -21,6 +21,12 @@ module Coltrane
     end
   end
 
+  class WrongArgumentsError < BadConstructorError
+    def initialize(_msg)
+      super 'Wrong argument(s).'
+    end
+  end
+
   class InvalidNoteError < BadConstructorError
     def initialize(note)
       super "#{note} is not a valid note"
@@ -35,7 +41,7 @@ module Coltrane
 
   class HasNoNotesError < BadConstructorError
     def initialize
-      super "The given object does not respond to :notes, "\
+      super 'The given object does not respond to :notes, '\
             "thereby it can't be used for this operation)"
     end
   end
@@ -65,6 +71,25 @@ module Coltrane
             'https://github.com/pedrozath/coltrane/issues '\
     end
   end
+
+  class InvalidPitchClassError < ColtraneError
+    def initialize(arg)
+      super "The given frequency(#{arg}) is not considered "\
+            'part of a pitch class'\
+    end
+  end
+
+  class InvalidNoteSymbolError < ColtraneError
+    def initialize(arg)
+      super "The musical notation included an unrecognizable symbol (#{arg})."
+    end
+  end
+
+  class InvalidNoteLetterError < ColtraneError
+    def initialize(arg)
+      super "The musical notation included an unrecognizable letter (#{arg})."
+    end
+  end
 end
 
 # rubocop:enable Style/Documentation

data/lib/coltrane/frequency.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Coltrane
+  class Frequency
+    attr_reader :frequency
+
+    def initialize(frequency)
+      @frequency = frequency.to_f
+    end
+
+    class << self
+      alias [] new
+    end
+
+    def to_s
+      "#{frequency}hz"
+    end
+
+    def to_f
+      frequency
+    end
+
+    def octave(n)
+      frequency * 2**n
+    end
+
+    def ==(other)
+      frequency == (other.is_a?(Frequency) ? other.frequency : other)
+    end
+
+    def octave_up(n = 1)
+      octave(n)
+    end
+
+    def octave_down(n = 1)
+      octave(-n)
+    end
+
+    def /(other)
+      case other
+      when Frequency then Interval[1200 * Math.log2(frequency / other.frequency)]
+      when Numeric then Frequency[frequency / other]
+      end
+    end
+
+    def method_missing(method, *args)
+      Frequency[frequency.send(method, args[0].to_f)]
+    end
+  end
+end

data/lib/coltrane/interval.rb

@@ -1,113 +1,50 @@
 # frozen_string_literal: true
 
 module Coltrane
-  # It describes a interval between 2 pitches
+  # Interval describe the logarithmic distance between 2 frequencies.
+  # It's measured in cents.
   class Interval
-    include Multiton
-    attr_reader :semitones
+    attr_reader :cents
 
-    INTERVALS = %w[
-      P1
-      m2
-      M2
-      m3
-      M3
-      P4
-      A4
-      P5
-      m6
-      M6
-      m7
-      M7
-    ].freeze
-
-    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)
+    class << self
+      alias [] new
     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
+    def initialize(cents)
+      @cents = cents.round
     end
 
-    def initialize(semitones)
-      @semitones = semitones
+    def semitones
+      (cents.to_f / 100).round
     end
 
-    private_class_method :new
-
-    def all_full_names
-      ALL_FULL_NAMES
+    def ascending?
+      cents < 0
     end
 
-
-
-    def name
-      INTERVALS[semitones]
+    def descending?
+      cents > 0
     end
 
-    def full_name
-      self.class.full_name(name)
+    def ==(other)
+      cents == other.cents
     end
 
-    def full_names
-      NAMES[name]
-    end
+    alias eql? ==
+    alias hash cents
 
     def +(other)
       case other
-      when Numeric then Interval[semitones + other]
-      when Interval then Interval[semitones + other.semitones]
+      when Numeric then Interval[cents + other]
+      when Interval then Interval[cents + other.cents]
       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
+    def -(other)
+      case other
+      when Numeric then Interval[cents - other]
+      when Interval then Interval[cents - other.cents]
       end
-      raise IntervalNotFoundError, arg
     end
   end
 end