coltrane 0.0.2 → 1.0.0

data/lib/coltrane/chord_quality.rb

@@ -1,48 +1,23 @@
-
-
 module Coltrane
   # It describe the quality of a chord, like maj7 or dim.
-  class ChordQuality
+  class ChordQuality < IntervalSequence
     attr_reader :name
     include Qualities
 
-    def initialize(interval_sequence)
-      if interval_sequence.class != IntervalSequence
-        interval_sequence = IntervalSequence.new(interval_sequence)
+    def initialize(name: nil, notes: nil)
+      if !name.nil?
+        if(intervals = CHORD_QUALITIES[name])
+          @name = name
+          super(intervals: intervals)
+        else
+          raise ChordNotFoundError.new
+        end
+      elsif !notes.nil?
+        super(notes: notes)
+        @name = CHORD_QUALITIES.key(intervals_semitones)
+      else
+        raise WrongKeywords.new('[name:] || [notes:]')
       end
-      @name = find_chord_name(interval_sequence)
-    end
-
-    def self.new_from_notes(notes)
-      note_set = NoteSet.new(notes) unless notes.class == NoteSet
-      new(note_set.interval_sequence.reordered)
-    end
-
-    def self.new_from_pitches(*pitches)
-      notes = pitches.sort_by(&:number)
-                     .collect(&:note)
-                     .collect(&:name)
-                     .uniq
-
-      new_from_notes(notes)
-    end
-
-    def self.new_from_string(quality_string)
-      new(CHORD_QUALITIES[quality_string])
-    end
-
-    def intervals
-      CHORD_QUALITIES[name]
-    end
-
-    protected
-
-    def find_chord_name(note_intervals, inversion = 0)
-      inversion >= note_intervals.all.size && return
-      CHORD_QUALITIES.key(note_intervals.numbers) ||
-        CHORD_QUALITIES.key(note_intervals.numbers.sort) ||
-        find_chord_name(note_intervals.next_inversion, inversion + 1) ||
-        nil
     end
   end
 end

data/lib/coltrane/classic_progressions.rb

@@ -0,0 +1,37 @@
+module Coltrane
+  module ClassicProgressions
+    PROGRESSIONS = {
+      pop:        [:major, [1,5,6,4]],
+      fifties:    [:major, [1,6,4,5]],
+      blues:      [:major, [1,4,1,5,4,1]],
+      jazz:       [:major, [2,5,1]],
+      jazz_minor: [:minor, [2,5,1]],
+      andalusian: [:minor, [1,7,6,5]]
+    }
+
+    def pop(tone)
+      scale, degrees = PROGRESSIONS[:pop]
+      Scale.public_send(scale, tone).progression(*degrees)
+    end
+
+    def fifties(tone)
+      scale, degrees = PROGRESSIONS[:fifties]
+      Scale.public_send(scale, tone).progression(*degrees)
+    end
+
+    def blues(tone)
+      scale, degrees = PROGRESSIONS[:blues]
+      Scale.public_send(scale, tone).progression(*degrees)
+    end
+
+    def jazz(tone)
+      scale, degrees = PROGRESSIONS[:jazz]
+      Scale.public_send(scale, tone).progression(*degrees)
+    end
+
+    def andalusian(tone)
+      scale, degrees = PROGRESSIONS[:andalusian]
+      Scale.public_send(scale, tone).progression(*degrees)
+    end
+  end
+end

data/lib/coltrane/classic_scales.rb

@@ -1,134 +1,108 @@
-require 'ostruct'
-
-module ClassicScales
-
-  SCALES = {
-    'Major'            => [2,2,1,2,2,2,1],
-    '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 Major' => [2,2,3,2,3],
-    'Pentatonic Minor' => [3,2,2,3,2],
-    'Blues Major'      => [2,1,1,3,2,3],
-    'Blues Minor'      => [3,2,1,1,3,2],
-    'Whole Tone'       => [2,2,2,2,2,2]
-  }
-
-  def major(tone='C', mode=1)
-    new(*SCALES['Major'], tone: tone, mode: mode)
-  end
-
-  def natural_minor(tone='C', mode=1)
-    new(*SCALES['Natural Minor'], tone: tone, mode: mode)
-  end
-
-  def harmonic_minor(tone='C', mode=1)
-    new(*SCALES['Harmonic Minor'], tone: tone, mode: mode)
-  end
-
-  def hungarian_minor(tone='C', mode=1)
-    new(*SCALES['Hungarian Minor'], tone: tone, mode: mode)
-  end
-
-  def pentatonic_major(tone='C', mode=1)
-    new(*SCALES['Pentatonic Major'], tone: tone, mode: mode)
-  end
-
-  def pentatonic_minor(tone='C', mode=1)
-    new(*SCALES['Pentatonic Minor'], tone: tone, mode: mode)
-  end
-
-  def blues_major(tone='C', mode=1)
-    new(*SCALES['Blues Major'], tone: tone, mode: mode)
-  end
-
-  def blues_minor(tone='C', mode=1)
-    new(*SCALES['Blues Minor'], tone: tone, mode: mode)
-  end
-
-  def whole_tone(tone='C', mode=1)
-    new(*SCALES['Blues Minor'], tone: tone, mode: mode)
-  end
+module Coltrane
+  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],
+      'Blues Minor'      => [3,2,1,1,3,2],
+      'Whole Tone'       => [2,2,2,2,2,2],
+      'Flamenco'         => [1,3,1,2,1,2,2]
+    }
+
+    MODES = {
+      'Major' => %w[Ionian Dorian Phrygian Lydian Mixolydian Aeolian Locrian]
+    }
+
+    private
+
+    # A little helper to build method names
+    # just make the code more clear
+    def self.methodize(string)
+      string.downcase.gsub(' ', '_')
+    end
 
-  def chromatic(tone='C', mode=1)
-    new(*([1]*12), tone: tone, mode: mode)
-  end
+    public
 
-  def ionian(tone='C')
-    new(*SCALES['Major'], tone: tone, mode: 1)
-  end
+    # Creates factories for scales
+    SCALES.each do |name, distances|
+      define_method methodize(name) do |tone='C', mode=1|
+        new(*distances, tone: tone, mode: mode, name: name)
+      end
+    end
 
-  def dorian(tone='C')
-    new(*SCALES['Major'], tone: tone, mode: 2)
-  end
+    # Creates factories for Greek Modes and possibly others
+    MODES.each do |scale, modes|
+      modes.each_with_index do |mode, index|
+        scale_method = methodize(scale)
+        mode_name = mode
+        mode_n = index + 1
+        define_method methodize(mode) do |tone='C'|
+          new(*SCALES[scale], tone: tone, mode: mode_n, name: mode_name)
+        end
+      end
+    end
 
-  def phrygian(tone='C')
-    new(*SCALES['Major'], tone: tone, mode: 3)
-  end
+    alias_method :minor,      :natural_minor
+    alias_method :pentatonic, :pentatonic_major
+    alias_method :blues,      :blues_major
 
-  def lydian(tone='C')
-    new(*SCALES['Major'], tone: tone, mode: 4)
-  end
+    def known_scales
+      SCALES.keys
+    end
 
-  def mixolydian(tone='C')
-    new(*SCALES['Major'], tone: tone, mode: 5)
-  end
+    def fetch(name, tone=nil)
+      Coltrane::Scale.public_send(name, tone)
+    end
 
-  def aeolian(tone='C')
-    new(*SCALES['Major'], tone: tone, mode: 6)
-  end
+    def from_key(key)
+      scale = key.delete!('m') ? :minor : :major
+      note  = key
+      Scale.public_send(scale.nil? || scale == 'M' ? :major : :minor, note)
+    end
 
-  def locrian(tone='C')
-    new(*SCALES['Major'], tone: tone, mode: 7)
-  end
 
-  def having_chord(chord)
-    puts "\nSearching #{chord} in scales:\n\n"
-    scale_name_size = SCALES.keys.map(&:size).max
-    chord = Chord.new(chord)
-    SCALES.each_with_object([]) do |scale_obj, results|
-      scale_name, intervals = scale_obj
-      print Paint[scale_name.ljust(scale_name_size), 'yellow']
-      Note.all.each do |note|
-        found_sth = false
-        print ' '
-        scale  = Scale.new(*intervals, tone: note.name)
-        degree = scale.degree_of_chord(chord)
-        unless degree.nil?
-          found_sth = true
-          results << OpenStruct.new({ name: "#{note.name} #{scale_name}",
-                       degree: degree,
-                       scale: scale})
+    # 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(
+        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] ||= {}
+            if output[:results][name].has_key?(tone.number)
+              next
+            else
+              output[:scales] << scale if scale.include?(notes)
+              output[:results][name][tone.number] = scale.notes & notes
+            end
+          end
         end
-        print Paint[note.name, found_sth ? 'yellow' : 'black']
-      end
-      print "\n"
+      )
     end
-  end
 
-  def having_notes(*notes)
-    puts "\nSearching #{notes.join(', ')} in scales:\n\n"
-    scale_name_size = SCALES.keys.map(&:size).max
-    notes = notes.map { |n| Note.new(n) }
-    SCALES.each_with_object([]) do |scale_obj, results|
-      scale_name, intervals = scale_obj
-      print Paint[scale_name.ljust(scale_name_size), 'yellow']
-      Note.all.each do |note|
-        found_sth = false
-        print ' '
-        scale  = Scale.new(*intervals, tone: note.name)
-        notes_included = scale.include_notes?(*notes)
-        if notes_included == notes
-          found_sth = true
-          results << OpenStruct.new({
-            name: "#{note.name} #{scale_name}",
-            notes: notes_included
-          })
-        end
-        print Paint[note.name, found_sth ? 'yellow' : 'black']
-        print Paint["(#{notes_included.count || 0})", found_sth ? 'gray' : 'black']
+    def having_chords(*chords)
+      should_create = !chords.first.is_a?(Chord)
+      notes = chords.reduce(NoteSet[]) do |memo, c|
+        memo + (should_create ? Chord.new(name: c) : c).notes
       end
-      print "\n"
+      having_notes(notes)
     end
+
+    alias_method :having_chord, :having_chords
   end
 end

data/lib/coltrane/errors.rb

@@ -0,0 +1,54 @@
+module Coltrane
+  class ColtraneError < StandardError
+    def initialize(msg)
+      super msg
+    end
+  end
+
+  class BadConstructor < ColtraneError
+    def initialize(msg=nil)
+      super "Bad constructor. #{msg}"
+    end
+  end
+
+  class WrongKeywords < BadConstructor
+    def initialize(msg)
+      super "Use one of the following set of keywords: #{msg}"
+    end
+  end
+
+  class InvalidNote < BadConstructor
+    def initialize(note)
+      super "#{note} is not a valid note"
+    end
+  end
+
+  class InvalidNotes < BadConstructor
+    def initialize(notes)
+      super "#{notes} are not a valid set of notes"
+    end
+  end
+
+  class HasNoNotes < BadConstructor
+    def initialize(obj)
+      super "The given object (#{obj.inspect} does not respond to :notes, "\
+            "thereby it can't be used for this operation)"
+    end
+  end
+
+  class WrongDegree
+    def initialize(degree)
+      super "#{degree} is not a valid degree. Degrees for this scale must be between 1 and #{degrees}"
+    end
+  end
+
+  class ChordNotFoundError < ColtraneError
+    def initialize
+      super "The chord you provided wasn't found. "\
+            "If you're sure this chord exists, "\
+            "would you mind to suggest it's inclusion here: "\
+            "https://github.com/pedrozath/coltrane/issues "\
+            "\n\nA tip tho: always include the letter M for major"
+    end
+  end
+end

data/lib/coltrane/interval.rb

@@ -1,33 +1,41 @@
 module Coltrane
   # It describes a interval between 2 pitches
   class Interval
-    attr_reader :number
+    attr_reader :semitones
 
     NAMES = [
       '1P',
-      '2m', '2M',
-      '3m', '3M',
-      '4P', '4A',
+      '2m',
+      '2M',
+      '3m',
+      '3M',
+      '4P',
+      '4A',
       '5P',
-      '6m', '6M',
+      '6m',
+      '6M',
       '7m',
-      '7M',
-      '8P',
-      '9m', '9M',
-      '10m', '10M',
-      '11P',
-      '12P',
-      '13m', '13M',
-      '14m', '14M',
-      '15P', '15A'
+      '7M'
     ].freeze
 
-    def initialize(number)
-      @number = number
+    def initialize(arg)
+      @semitones = (case arg
+                     when Interval then arg.semitones
+                     when String   then NAMES.index(arg)
+                     when Numeric  then arg
+                   end) % 12
     end
 
     def name
-      NAMES[number]
+      NAMES[semitones]
     end
+
+    def +(x)
+      case x
+      when Numeric then Interval.new(semitones + x)
+      when Interval then Interval.new(semitones + x.semitones)
+      end
+    end
+
   end
 end

data/lib/coltrane/interval_sequence.rb

@@ -1,30 +1,33 @@
 module Coltrane
   # It describes a sequence of intervals
   class IntervalSequence
+    extend Forwardable
     attr_reader :intervals
 
-    def initialize(arg)
-      arg = [arg] if arg.class != Array
-      @intervals = arg.reduce([]) do |memo, arg_item|
-        case arg_item
-        when Numeric  then memo << Interval.new(arg_item)
-        when Interval then memo << arg_item
-        when NoteSet  then memo + intervals_from_note_set(arg_item)
-        end
-      end
-    end
+    def_delegators :@intervals, :map, :each, :[], :size, :reduce
 
-    def intervals_from_note_set(note_set)
-      note_numbers = note_set.notes.collect(&:number)
-      root         = note_numbers.shift
-      note_numbers.reduce([Interval.new(0)]) do |memo, number|
-        number += 12 if number < root
-        memo << Interval.new(number - root)
+    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) }
+      elsif !distances.nil?
+        @distances = distances
+        @intervals = intervals_from_distances(distances)
+      else
+        raise 'Provide: [notes:] || [intervals:] || [distances:]'
       end
     end
 
-    def reordered
-      IntervalSequence.new @intervals.sort_by!(&:number)
+    def distances
+      intervals_semitones[1..-1].each_with_index.map do |n, i|
+        if i == 0
+          n
+        elsif i < intervals_semitones.size
+          n - intervals_semitones[i]
+        end
+      end + [12 - intervals_semitones.last]
     end
 
     def all
@@ -36,35 +39,62 @@ module Coltrane
     end
 
     def shift(ammount)
-      IntervalSequence.new(intervals.map do |i|
-        (i.number + ammount) % 12
+      IntervalSequence.new(intervals: intervals.map do |i|
+        (i.semitones + ammount) % 12
       end)
     end
 
     def zero_it
-      self.shift(-intervals.first.number)
+      self.shift(-intervals.first.semitones)
+    end
+
+    def inversion(index)
+      IntervalSequence.new(intervals: intervals.rotate(index)).zero_it
     end
 
     def next_inversion
-      IntervalSequence.new(intervals.rotate(+1))
+      inversion(index+1)
     end
 
     def previous_inversion
-      IntervalSequence.new(intervals.rotate(-1))
+      inversion(index-1)
     end
 
     def inversions
       Array.new(intervals.length) do |index|
-        IntervalSequence.new(interval.rotate(index))
+        inversion(index)
       end
     end
 
-    def numbers
-      intervals.collect(&:number)
+    def quality
+    end
+
+    def intervals_semitones
+      map(&:semitones)
     end
 
     def names
-      intervals.collect(&:name)
+      map(&:name)
+    end
+
+    def notes_for(root_note)
+      NoteSet[
+        *intervals.reduce([]) do |memo, interval|
+          memo + [root_note + interval]
+        end
+      ]
+    end
+
+    private
+
+    def intervals_from_distances(distances)
+      distances[0..-2].reduce([Interval.new(0)]) do |memo, d|
+        memo + [memo.last + d]
+      end
+    end
+
+    def intervals_from_notes(notes)
+      notes.map { |n| notes.root - n }.sort_by(&:semitones)
     end
   end
 end