coltrane 0.0.2

data/coltrane.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'coltrane/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "coltrane"
+  spec.version       = Coltrane::VERSION
+  spec.authors       = ["Pedro Maciel"]
+  spec.email         = ["pedro@pedromaciel.com"]
+
+  spec.summary       = %q{It deals with all sorts of calculations around music theory
+                          and allows for graphical representations of it}
+  spec.homepage      = "http://github.com/pedrozath/coltrane"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/db/config.yml

@@ -0,0 +1,11 @@
+production:
+  adapter: sqlite3
+  database: db/cache.sqlite3
+  pool: 5
+  timeout: 5000
+
+test:
+  adapter: sqlite3
+  database: db/cache_test.sqlite3
+  pool: 5
+  timeout: 5000

data/db/schema.rb

@@ -0,0 +1,30 @@
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# Note that this schema.rb definition is the authoritative source for your
+# database schema. If you need to create the application database on another
+# system, you should be using db:schema:load, not running all the migrations
+# from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended that you check this file into your version control system.
+
+ActiveRecord::Schema.define(version: 20170508162849) do
+
+  create_table "scale_caches", force: :cascade do |t|
+    t.string "interval_sequence"
+    t.string "tone"
+  end
+
+  create_table "chord_caches", force: :cascade do |t|
+    t.string "name"
+    t.integer "size"
+  end
+
+  create_table "scale_chords", force: :cascade do |t|
+    t.integer "scale_cache_id"
+    t.integer "chord_cache_id"
+  end
+
+end

data/lib/coltrane.rb

@@ -0,0 +1,48 @@
+# $LOAD_PATH << __dir__
+
+# require 'bundler'
+
+# Bundler.require
+
+# ActiveSupport::Inflector.inflections do |inflect|
+#   inflect.irregular 'cache', 'caches'
+# end
+
+# ActiveRecord::Base.establish_connection YAML.load_file("#{__dir__}/../db/config.yml")['production']
+# require "#{__dir__}/../db/schema.rb"
+
+require 'coltrane/cadence'
+
+require 'coltrane/qualities'
+require 'coltrane/chord_quality'
+require 'coltrane/chord'
+
+require 'coltrane/classic_scales'
+require 'coltrane/fret_set'
+
+# require 'coltrane/piano_representation'
+# require 'coltrane/guitar_representation'
+require 'coltrane/essential_guitar_chords'
+require 'coltrane/guitar_chord_finder'
+require 'coltrane/guitar_note_set'
+require 'coltrane/guitar_chord'
+require 'coltrane/guitar_note'
+require 'coltrane/guitar_string'
+require 'coltrane/guitar'
+
+require 'coltrane/interval_sequence'
+require 'coltrane/interval_set'
+require 'coltrane/interval'
+
+require 'coltrane/note_set'
+require 'coltrane/note'
+
+require 'coltrane/pitch'
+require 'coltrane/progression'
+require 'coltrane/scale'
+require 'coltrane/mode'
+
+# require 'coltrane/scale_chord'
+# require 'coltrane/chord_cache'
+# require 'coltrane/scale_cache'
+# require 'terminal_input'

data/lib/coltrane/cadence.rb

@@ -0,0 +1,4 @@
+module Coltrane
+  class Cadence
+  end
+end

data/lib/coltrane/chord.rb

@@ -0,0 +1,81 @@
+module Coltrane
+  # It describe a chord
+  class Chord
+    attr_reader :root_note, :quality
+
+    def initialize(arg)
+      @root_note, @quality = case arg
+        when String then note_and_quality_from_name(arg)
+        when GuitarNoteSet then [arg.root_note, arg.chord_quality]
+        when Array
+          case arg[0]
+            when String then note_and_quality_from_notes(*arg.map{|a| Note.new(a)})
+            when Note then note_and_quality_from_notes(*arg)
+          end
+      end
+    end
+
+    def guitar_chords
+      GuitarChordFinder.by_chord(self)
+    end
+
+    def guitar_notes_for_root
+      root_note.guitar_notes
+    end
+
+    def name
+      return '—' if root_note.nil? || quality.nil?
+      "#{root_note.name}#{quality.name}"
+    end
+
+    def notes
+      quality.intervals.each_with_object([]) do |interval, notes|
+        notes << Note.new(root_note.number + interval)
+      end
+    end
+
+    def intervals
+      IntervalSequence.new(NoteSet.new(notes))
+    end
+
+    def on_guitar
+      name + "\n" +
+      NoteSet.new(notes).guitar_notes.render(root_note) + "\n\n"
+    end
+
+    def on_piano
+      PianoRepresentation.render_intervals(notes, root_note)
+    end
+
+    def size
+      notes.size
+    end
+
+    def scales
+      Scale.having_chord(self.name)
+    end
+
+    def next_inversion
+      Chord.new(notes.rotate(1))
+    end
+
+    def invert(n=1)
+      Chord.new(notes.rotate(n))
+    end
+
+    def previous_inversion
+      Chord.new(notes.rotate(-1))
+    end
+
+    protected
+
+    def note_and_quality_from_name(chord_name)
+      _, name, quality = chord_name.match(/([A-Z]#?)(.*)/).to_a
+      [Note.new(name), ChordQuality.new_from_string(quality)]
+    end
+
+    def note_and_quality_from_notes(*notes)
+      [notes.first, ChordQuality.new_from_notes(notes)]
+    end
+  end
+end

data/lib/coltrane/chord_cache.rb

@@ -0,0 +1,4 @@
+class ChordCache < ActiveRecord::Base
+  has_many :scale_chords
+  has_many :scale_caches, through: :scale_chords
+end

data/lib/coltrane/chord_quality.rb

@@ -0,0 +1,48 @@
+
+
+module Coltrane
+  # It describe the quality of a chord, like maj7 or dim.
+  class ChordQuality
+    attr_reader :name
+    include Qualities
+
+    def initialize(interval_sequence)
+      if interval_sequence.class != IntervalSequence
+        interval_sequence = IntervalSequence.new(interval_sequence)
+      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_scales.rb

@@ -0,0 +1,134 @@
+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
+
+  def chromatic(tone='C', mode=1)
+    new(*([1]*12), tone: tone, mode: mode)
+  end
+
+  def ionian(tone='C')
+    new(*SCALES['Major'], tone: tone, mode: 1)
+  end
+
+  def dorian(tone='C')
+    new(*SCALES['Major'], tone: tone, mode: 2)
+  end
+
+  def phrygian(tone='C')
+    new(*SCALES['Major'], tone: tone, mode: 3)
+  end
+
+  def lydian(tone='C')
+    new(*SCALES['Major'], tone: tone, mode: 4)
+  end
+
+  def mixolydian(tone='C')
+    new(*SCALES['Major'], tone: tone, mode: 5)
+  end
+
+  def aeolian(tone='C')
+    new(*SCALES['Major'], tone: tone, mode: 6)
+  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})
+        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']
+      end
+      print "\n"
+    end
+  end
+end

data/lib/coltrane/essential_guitar_chords.rb

@@ -0,0 +1,82 @@
+module Coltrane
+  module EssentialGuitarChords
+    CHORDS = {
+      'C'      => [nil, 3, 2, 0, 1, 0],
+      'Cm'     => [nil, 10, 10, 8, 6, 4],
+      'Cmaj7'  => [nil, 3, 5, 4, 5, nil],
+      'C7'     => [nil, 10, 10, 9, 11, nil],
+      'Cm7'    => [6,6,5,5,nil,nil],
+      'Cm7b5'  => [nil, 3,4,3,4, nil],
+      'C#'     => [nil,8,6,6,6,nil],
+      'C#m'    => [nil,5,6,6,5,nil],
+      'C#maj7' => [4,4,3,5,nil,nil],
+      'C#7'    => [nil, nil, 6,6,6,7],
+      'C#m7'   => [nil, 2,2,1,2],
+      'C#m7b5' => [nil, 4,5,4,5, nil],
+      'D'      => [5,5,4,nil,nil,nil],
+      'Dm'     => [10,nil,nil,10,10,nil],
+      'Dmaj7'  => [5,5,4,6,nil,nil],
+      'D7'     => [5,5,4,5,nil,nil],
+      'Dm7'    => [nil,3,3,2,3,nil],
+      'Dm7b5'  => [],
+      'D#'     => [],
+      'D#m'    => [],
+      'D#maj7' => [],
+      'D#7'    => [],
+      'D#m7'   => [],
+      'D#m7b5' => [],
+      'E'      => [],
+      'Em'     => [],
+      'Emaj7'  => [],
+      'E7'     => [],
+      'Em7'    => [],
+      'Em7b5'  => [],
+      'F'      => [],
+      'Fm'     => [],
+      'Fmaj7'  => [],
+      'F7'     => [],
+      'Fm7'    => [],
+      'Fm7b5'  => [],
+      'F#'     => [],
+      'F#m'    => [],
+      'F#maj7' => [],
+      'F#7'    => [],
+      'F#m7'   => [],
+      'F#m7b5' => [],
+      'G'      => [],
+      'Gm'     => [],
+      'Gmaj7'  => [],
+      'G7'     => [],
+      'Gm7'    => [],
+      'Gm7b5'  => [],
+      'G#'     => [],
+      'G#m'    => [],
+      'G#maj7' => [],
+      'G#7'    => [],
+      'G#m7'   => [],
+      'G#m7b5' => [],
+      'A'      => [],
+      'Am'     => [],
+      'Amaj7'  => [],
+      'A7'     => [],
+      'Am7'    => [],
+      'Am7b5'  => [],
+      'A#'     => [],
+      'A#m'    => [],
+      'A#maj7' => [],
+      'A#7'    => [],
+      'A#m7'   => [],
+      'A#m7b5' => [],
+      'B'      => [],
+      'Bm'     => [],
+      'Bmaj7'  => [],
+      'B7'     => [],
+      'Bm7'    => [],
+      'Bm7b5'  => []
+    }
+
+    def [](name)
+      GuitarChord.new_from_frets(*CHORDS[name])
+    end
+  end
+end