coltrane 1.2.4 → 2.0.0

data/lib/coltrane/interval_class.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Coltrane
+  # Interval class here is not related to the Object Oriented Programming context
+  # but to the fact that there is a class of intervals that can all be categorized
+  # as having the same quality.
+  #
+  # This class in specific still takes into account the order of intervals.
+  # C to D is a major second, but D to C is a minor seventh.
+  class IntervalClass < Interval
+    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 someday
+    NAMES = INTERVALS.each_with_index.each_with_object({}) do |(interval, index), memo|
+      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
+    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
+        IntervalClass.class.define_method the_full_name.underscore.to_s do
+          IntervalClass.new(interval_name)
+        end
+      end
+    end
+
+    def initialize(arg)
+      super case arg
+            when Interval then arg.semitones
+            when String
+              INTERVALS.index(arg) || self.class.interval_by_full_name(arg)
+            when Numeric then arg
+            else raise WrongArgumentsError
+            end % 12 * 100
+    end
+
+    def self.[](semis)
+      new semis
+    end
+
+    def all_full_names
+      self.class.all_full_names
+    end
+
+    def self.all_full_names
+      ALL_FULL_NAMES
+    end
+
+    def ==(other)
+      (cents % 12) == (other.cents % 12)
+    end
+
+    def name
+      INTERVALS[semitones % 12]
+    end
+
+    def full_name
+      self.class.full_name(name)
+    end
+
+    def full_names
+      NAMES[name]
+    end
+
+    def +(other)
+      IntervalClass[semitones + other]
+    end
+
+    def -(other)
+      IntervalClass[semitones - other]
+    end
+
+    private
+
+    def self.interval_by_full_name(arg)
+      NAMES.invert.each do |full_names, interval_name|
+        return INTERVALS.index(interval_name) if full_names.include?(arg)
+      end
+      raise IntervalNotFoundError, arg
+    end
+  end
+end

data/lib/coltrane/interval_sequence.rb

@@ -7,11 +7,11 @@ module Coltrane
     attr_reader :intervals
 
     def_delegators :@intervals, :map, :each, :[], :size,
-                   :reduce, :delete
+                   :reduce, :delete, :reject!, :delete_if
 
-    Interval::ALL_FULL_NAMES.each do |full_name|
+    IntervalClass.all_full_names.each do |full_name|
       define_method "has_#{full_name.underscore}?" do
-        !!(intervals.detect {|i| i.public_send("#{full_name.underscore}?")})
+        !!(intervals.detect { |i| i.public_send("#{full_name.underscore}?") })
       end
     end
 
@@ -22,7 +22,7 @@ module Coltrane
         return priority unless priority.nil?
         @intervals.each do |ix|
           ix.full_names.detect do |ixx|
-            return ixx if ixx.match(/#{i.interval_name}/)
+            return ixx if ixx.match?(/#{i.interval_name}/)
           end
         end
         nil
@@ -31,7 +31,7 @@ module Coltrane
       define_method "#{i.interval_name.underscore}!" do
         @intervals.each do |ix|
           ix.full_names.detect do |ixx|
-            next if ixx.match(/Diminished|Augmented/)
+            next if ixx.match?(/Diminished|Augmented/)
             return ixx if ixx.match? /#{i.interval_name}/
           end
         end
@@ -40,20 +40,21 @@ module Coltrane
 
       # 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}/) }
+        !!@intervals.detect { |ix| ix.full_name.match(/#{i.interval_name}/) }
       end
     end
 
     def initialize(notes: nil, intervals: nil, distances: nil)
-      if !notes.nil?
+      if notes
         notes = NoteSet[*notes] if notes.is_a?(Array)
         @intervals = intervals_from_notes(notes)
-      elsif !intervals.nil?
-        @intervals = intervals.map { |i| Interval[i] }
-      elsif !distances.nil?
+      elsif intervals
+        @intervals = intervals.map { |i| IntervalClass[i] }
+      elsif distances
         @distances = distances
         @intervals = intervals_from_distances(distances)
       else
+        require 'pry'; binding.pry
         raise 'Provide: [notes:] || [intervals:] || [distances:]'
       end
     end
@@ -73,7 +74,7 @@ module Coltrane
     end
 
     def has?(interval_name)
-      @intervals.include?(Interval[interval_name])
+      @intervals.include?(IntervalClass[interval_name])
     end
 
     alias interval_names names
@@ -144,13 +145,13 @@ module Coltrane
     private
 
     def intervals_from_distances(distances)
-      distances[0..-2].reduce([Interval[0]]) do |memo, d|
+      distances[0..-2].reduce([IntervalClass[0]]) do |memo, d|
         memo + [memo.last + d]
       end
     end
 
     def intervals_from_notes(notes)
-      notes.map { |n| notes.root - n }.sort_by(&:semitones)
+      notes.map { |n| n - notes.root }.sort_by(&:semitones)
     end
   end
 end

data/lib/coltrane/notable_progressions.rb

@@ -1,7 +1,12 @@
+# frozen_string_literal: true
+
 module Coltrane
+
+  # This module takes care of adding to progressions knowledge that is more
+  # based on common standards and practices.
   module NotableProgressions
     PROGRESSIONS = {
-      'Pop'  =>       ['I-V-vi-IV',            :major],
+      'Pop' => ['I-V-vi-IV', :major],
       'Jazzy Pop' =>  ['IM7-V7-vi7-IVM7',      :major],
       'Jazz' =>       ['ii7-V7-I7',            :major],
       'Jazz Minor' => ['ii7-V7-i7',            :major],
@@ -10,7 +15,7 @@ module Coltrane
       'Fifties' =>    ['I-vi-IV-V',            :major],
       'Circle' =>     ['vi-ii-V-I',            :major],
       'Tune Up' =>    ['ii7-V7-IM7-i7-IV7-IVM7-VIIM7', :minor]
-    }
+    }.freeze
 
     PROGRESSIONS.each do |name, values|
       notation, scale_name = values
@@ -21,4 +26,4 @@ module Coltrane
       end
     end
   end
-end
+end

data/lib/coltrane/note.rb

@@ -1,98 +1,69 @@
 # frozen_string_literal: true
 
 module Coltrane
-  # Describes a musical note, independent of octave (that'd be pitch)
-  class Note
-    include Multiton
-
-    attr_reader :name, :number
-    alias id number
-    alias to_s name
-
-    NOTES = {
-      'C'  => 0,
-      'C#' => 1,
-      'Db' => 1,
-      'D'  => 2,
-      'D#' => 3,
-      'Eb' => 3,
-      'E'  => 4,
-      'F'  => 5,
-      'F#' => 6,
-      'Gb' => 6,
-      'G'  => 7,
-      'G#' => 8,
-      'Ab' => 8,
-      'A'  => 9,
-      'A#' => 10,
-      'Bb' => 10,
-      'B'  => 11
+  # Notes are different ways of calling pitch classes. In the context of equal
+  # tempered scales, they're more like a conceptual subject for
+  # matters of convention than an actual thing.
+  #
+  # Take for example A# and Bb. Those are different notes. Nevertheless, in the
+  # context of equal tempered scales they represent pretty much the same
+  # frequency.
+  #
+  # The theory of notes have changed too much in the course of time, which
+  # lead us with a lot of conventions and strategies when dealing with music.
+  # That's what this class is for.
+  class Note < PitchClass
+    attr_reader :alteration
+
+    ALTERATIONS = {
+      'b' => -1,
+      '#' => 1
     }.freeze
 
-    def initialize(name)
-      @name = name
-      @number = NOTES[name]
+    def initialize(arg)
+      note_name = case arg
+                  when String then arg
+                  when PitchClass then arg.true_notation
+                  when Numeric, Frequency then PitchClass.new(arg).true_notation
+                  else raise(WrongArgumentsError, arg)
+                  end
+
+      chars  = note_name.chars
+      letter = chars.shift
+      raise InvalidNoteError, arg unless ('A'..'G').cover?(letter)
+      @alteration = chars.reduce(0) do |alt, symbol|
+        raise InvalidNoteError, arg unless ALTERATIONS.include?(symbol)
+        alt + ALTERATIONS[symbol]
+      end
+      super((PitchClass[letter].integer + @alteration) % PitchClass.size)
     end
 
-    private_class_method :new
-
     def self.[](arg)
-      name =
-        case arg
-        when Note then return arg
-        when String then find_note(arg)
-        when Numeric then NOTES.key(arg % 12)
-        else
-          raise InvalidNoteError, "Wrong type: #{arg.class}"
-        end
-
-      new(name) || (raise InvalidNoteError, arg.to_s)
+      new(arg)
     end
 
-    def self.all
-      %w[C C# D D# E F F# G G# A A# B].map { |n| Note[n] }
+    def name
+      "#{base_pitch_class}#{accidents}".gsub(/#b|b#/, '')
     end
 
-    def self.find_note(str)
-      NOTES.each_key { |k, _v| return k if str.casecmp?(k) }
-      nil
+    def base_pitch_class
+      PitchClass[integer - alteration]
     end
 
-    def pretty_name
-      @name.tr('b', "\u266D").tr('#', "\u266F")
+    def alteration=(a)
+      @alteration = a unless PitchClass[integer - a].accidental?
     end
 
-    alias to_s name
-
-    def accident?
-      [1, 3, 6, 8, 10].include?(number)
+    def alter(x)
+      Note.new(name).tap { |n| n.alteration = x }
     end
 
-    def +(other)
-      case other
-      when Interval then Note[number + other.semitones]
-      when Numeric  then Note[number + other]
-      when Note     then Chord.new(number + other.number)
-      end
-    end
-
-    def -(other)
-      case other
-      when Numeric then Note[number - other]
-      when Interval then Note[number - other.semitones]
-      when Note    then Interval[other.number - number]
-      end
+    def accidents
+      (@alteration > 0 ? '#' : 'b') * alteration.abs
     end
 
     def interval_to(note_name)
       Note[note_name] - self
     end
-
-    def enharmonic?(other)
-      case other
-      when String then number == Note[other].number
-      when Note then number == other.number
-      end
-    end
   end
 end

data/lib/coltrane/note_set.rb

@@ -38,14 +38,14 @@ module Coltrane
       case other
       when Note then NoteSet[*(notes + [other])]
       when NoteSet then NoteSet[*notes, *other.notes]
-      when Interval then NoteSet[*notes.map {|n| n + other}]
+      when Interval then NoteSet[*notes.map { |n| n + other }]
       end
     end
 
     def -(other)
       case other
       when NoteSet then NoteSet[*(notes - other.notes)]
-      when Interval then NoteSet[*notes.map {|n| n - other}]
+      when Interval then NoteSet[*notes.map { |n| n - other }]
       end
     end
 
@@ -57,8 +57,8 @@ module Coltrane
       map(&:name)
     end
 
-    def numbers
-      map(&:number)
+    def integers
+      map(&:integer)
     end
 
     def interval_sequence

data/lib/coltrane/pitch.rb

@@ -3,35 +3,56 @@
 module Coltrane
   # It describes a pitch, like E4 or Bb5. It's like a note, but it has an octave
   class Pitch
-    attr_reader :number
-
-    def initialize(pitch)
-      case pitch
-      when String  then @number = number_from_name(pitch)
-      when Numeric then @number = pitch
-      when Pitch   then @number = pitch.number
-      end
-    end
+    attr_reader :pitch_class, :octave
 
-    def number_from_name(pitch_string)
-      _, note, octaves = pitch_string.match(/(.*)(\d)/).to_a
-      Note[note].number + 12 * octaves.to_i
-    end
+    def initialize(notation_arg = nil,
+                   pitch_class: nil,
+                   octave: nil,
+                   notation: nil,
+                   frequency: nil)
 
-    def name
-      "#{note.name}#{octave}"
+      @pitch_class, @octave =
+        if notation_arg || notation
+          pitch_class_and_octave_from_notation(notation_arg || notation)
+        elsif pitch_class && octave
+          [pitch_class, octave]
+        elsif frequency
+          pitch_class_and_octave_from_frequency(frequency)
+        else
+          raise InvalidArgumentsError
+        end
     end
 
-    def octave
-      number / 12
-    end
+    private
 
-    def note
-      Note[number]
+    def pitch_class_and_octave_from_notation(name)
+      pitch_class_notation, octaves = *name.match(/(.*)(\d)/)
+      [PitchClass.new(pitch_class_notation), octaves.to_f]
     end
 
-    def +(other)
-      Pitch.new(number + (other.is_a?(Pitch) ? other.number : other))
+    def pitch_class_and_octave_from_frequency(frequency)
+      [PitchClass[frequency], Math.log(f.to_f / TUNING, 2) / 12]
     end
+
+    #   def number_from_name(pitch_string)
+    #     Note[note].number + 12 * octaves.to_i
+    #   end
+
+    #   def name
+    #     "#{note.name}#{octave}"
+    #   end
+
+    #   def octave
+    #     number / 12
+    #   end
+
+    #   def note
+    #     Note[number]
+    #   end
+
+    #   def +(other)
+    #     Pitch.new(number + (other.is_a?(Pitch) ? other.number : other))
+    #   end
+    # end
   end
 end