coltrane 0.0.2 → 1.0.0

data/lib/cli/bass_guitar.rb

@@ -0,0 +1,9 @@
+module Coltrane
+  module Cli
+    class BassGuitar < Guitar
+      def initialize(notes, flavor, tuning: %w[E A D G])
+        super
+      end
+    end
+  end
+end

data/lib/cli/chord.rb

@@ -0,0 +1,24 @@
+module Coltrane
+  module Cli
+    class Chord
+      def initialize(*chords, on: :text, flavor: 'intervals', notes: nil)
+        @chords =
+          if !chords.empty?
+            if chords[0].is_a?(String)
+              chords.map { |c| Coltrane::Chord.new(name: c) }
+            else
+              chords
+            end
+          elsif !notes.nil?
+             [Coltrane::Chord.new(notes: notes)]
+          end
+
+        @chords.each do |chord|
+          raise ChordNotFoundError unless chord.named?
+          desc = "#{chord.name} chord:"
+          Coltrane::Cli::Notes.new(chord.notes, on: on, desc: desc, flavor: flavor)
+        end
+      end
+    end
+  end
+end

data/lib/cli/errors.rb

@@ -0,0 +1,28 @@
+module Coltrane
+  module Cli
+    class ColtraneCliError < StandardError
+      def initialize(msg)
+        super msg
+      end
+    end
+
+    class WrongFlavorError < ColtraneCliError
+      def initialize(msg=nil)
+        super msg || 'Wrong flavor. Check possible flavors with `coltrane list flavors`.'
+      end
+    end
+
+    class BadFindScales < ColtraneCliError
+      def initialize(msg=nil)
+        super msg || 'Provide --notes or --chords. Ex: `coltrane find-scale --notes C E G`.'
+      end
+    end
+
+    class WrongRepresentationTypeError < ColtraneCliError
+      def initialize(type)
+        super "The provided representation type (#{type}) "\
+              "is not available at the moment."
+      end
+    end
+  end
+end

data/lib/cli/guitar.rb

@@ -0,0 +1,55 @@
+module Coltrane
+  module Cli
+    SPECIAL_FRETS = [3, 5, 7, 9, 12, 15, 17, 19]
+
+    class Guitar < Representation
+      def initialize(notes, flavor, tuning: %w[E A D G B E], frets: 22)
+        @notes    = notes
+        @tuning   = tuning.reverse
+        @frets    = frets
+        @flavor   = flavor
+        @ref_note = @notes.first
+      end
+
+      def render
+        [render_notes, render_special_frets, hint].join("\n"*2)
+      end
+
+      def render_notes
+        @tuning.map do |string|
+          string_note = Note[string]
+          (@frets+2).times.map do |i|
+            if i.zero?
+              string
+            else
+              fret = i - 1
+              note = string_note + fret
+              m = (@notes.include?(note) ? place_mark(note) : "--")
+              fret.zero? ? (m + " |") : m
+            end
+          end.join(' ')
+        end.join("\n")
+      end
+
+      def render_special_frets
+        (@frets+1).times.map do |fret|
+          m = SPECIAL_FRETS.include?(fret) ? fret.to_s.rjust(2, 0.to_s) : '  '
+          "#{m}#{'  ' if fret.zero?}"
+        end.join(' ')
+      end
+
+      def render_dotted_frets
+      end
+
+      def place_mark(note)
+        case @flavor
+        when :notes     then note.pretty_name.ljust(2, "\u266E")
+        when :intervals then (@ref_note - note).name.ljust(2, '-')
+        when :degrees   then @notes.degree(note).to_s.rjust(2, '0')
+        when :marks     then '◼◼'
+        else raise WrongFlavorError.new
+        end
+      end
+    end
+  end
+end

data/lib/cli/notes.rb

@@ -0,0 +1,18 @@
+module Coltrane
+  module Cli
+    class Notes
+      def initialize(notes, on: 'text', desc: 'The notes you supplied:', flavor: 'notes')
+        @desc   = desc
+        flavor  = flavor.underscore.to_sym
+        on      = on.to_sym
+        notes   = Coltrane::NoteSet.new(notes)
+        @representation = Representation.build(on, notes, flavor)
+        render
+      end
+
+      def render
+        puts "\n"+[@desc, @representation.render].join("\n"*2)
+      end
+    end
+  end
+end

data/lib/cli/piano.rb

@@ -0,0 +1,54 @@
+module Coltrane
+  module Cli
+    class Piano < Representation
+      PIANO_TEMPLATE = <<~ASCII
+        ┌─┬─┬┬─┬─╥─┬─┬┬─┬┬─┬─╥─┬─┬┬─┬─╥─┬─┬┬─┬┬─┬─┐
+        │ │ ││ │ ║ │ ││ ││ │ ║ │ ││ │ ║ │ ││ ││ │ │
+        │ │X││X│ ║ │X││X││X│ ║ │X││X│ ║ │X││X││X│ │
+        │ │X││X│ ║ │X││X││X│ ║ │X││X│ ║ │X││X││X│ │
+        │ ┕╥┙┕╥┙ ║ ┕╥┙┕╥┙┕╥┙ ║ ┕╥┙┕╥┙ ║ ┕╥┙┕╥┙┕╥┙ │
+        │  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  │
+        │XX║XX║XX║XX║XX║XX║XX║XX║XX║XX║XX║XX║XX║XX│
+        └──╨──╨──╨──╨──╨──╨──╨──╨──╨──╨──╨──╨──╨──┘
+      ASCII
+
+      def render
+        PIANO_TEMPLATE.each_line.map.each_with_index do |l, ln|
+          case ln
+          when 2, 3 then replace_x(l, black_notes, 1, ln - 2)
+          when 6 then replace_x(l, white_notes, 2)
+          else l
+          end
+        end.join + "\n" + hint
+      end
+
+      private
+
+      def replace_x(line, notes, size, index=0)
+        line.gsub('X'*size).with_index do |match, i|
+          note = notes[i%notes.size]
+          next ' '*size unless @notes.include?(note)
+          Paint[replacer(note)[size == 2 ? 0..2 : index ], 'red']
+        end
+      end
+
+      def replacer(note)
+        # TODO: Maybe extract this method into its own class/module
+        case @flavor
+        when :intervals then (@ref_note - note).name
+        when :marks then '◼ '
+        when :degrees then @notes.degree(note).to_s.rjust(2,'0')
+        when :notes then note.pretty_name.to_s.ljust(2, "\u266E")
+        end
+      end
+
+      def white_notes
+        Coltrane::Scale.major.notes
+      end
+
+      def black_notes
+        Coltrane::Scale.pentatonic_major('C#',4).notes
+      end
+    end
+  end
+end

data/lib/cli/representation.rb

@@ -0,0 +1,47 @@
+module Coltrane
+  module Cli
+    class Representation
+      ACCEPTED_FLAVORS = %i[marks notes intervals degrees]
+
+      def self.inherited(subclass)
+        @@types ||= {}
+        @@types[subclass.to_s.split('::').last.underscore.to_sym] = subclass
+      end
+
+      def self.build(type, notes, flavor)
+        raise WrongFlavorError.new unless ACCEPTED_FLAVORS.include?(flavor)
+        type = case type
+          when :ukelele then :ukulele
+          when :bass then :bass_guitar
+          else type
+        end
+
+        if (the_class = @@types[type])
+          the_class.new(notes, flavor)
+        else
+          raise WrongRepresentationTypeError.new(type)
+        end
+      end
+
+      def initialize(notes, flavor)
+        @notes    = notes
+        @flavor   = flavor
+        @ref_note = notes.first
+      end
+
+      def hint
+        case @flavor
+        when :marks     then ""
+        when :notes     then "(\u266E means the note is natural, not flat nor sharp)"
+        when :intervals
+          <<~DESC
+            The letters represent the intervals relative to the root tone
+            Ex: 1P = Perfect First / 3m = Minor Third / 4A = Augmented Fourth
+          DESC
+
+        when :degrees then "(The numbers represent the degree of the note in the scale)"
+        end
+      end
+    end
+  end
+end

data/lib/cli/scale.rb

@@ -0,0 +1,48 @@
+module Coltrane
+  module Cli
+    class Scale
+      def self.parse(str)
+        *scale_name, tone = str.split('-')
+        Coltrane::Scale.fetch(scale_name.join('_'), tone)
+      end
+
+      def self.find(notes: [], chords: [])
+        if notes.any?
+          puts "\nSearching for scales containing #{notes.join(', ')}:\n\n"
+          notes = NoteSet[*notes]
+        elsif chords.any?
+          puts "\nSearching for scales containing #{chords.join(', ')}:\n\n"
+          notes = chords.reduce(NoteSet[]) {|memo, c| memo + Coltrane::Chord.new(name: c).notes }
+        else raise BadFindScales.new
+        end
+        render_search(notes)
+        puts "\nUnderlined means the scale has all notes"
+      end
+
+      def self.render_search(searched_notes)
+        search = Coltrane::Scale.having_notes(searched_notes)
+        output = []
+        scale_width = search.results.keys.map(&:size).max
+        search.results.each do |name, scales_by_tone|
+          output << name.ljust(scale_width+1, ' ')
+          scales_by_tone.each do |tone_number, notes|
+            p = notes.size.to_f / searched_notes.size
+            l = p == 1 ? p : (p + 0.2) * 0.4
+            hue, val, sat = 30, val = (l * 100).round, sat = p
+            und = p == 1 ? :underline : nil
+            color = "hsv(#{hue},#{sat},#{val})".paint.to_hex
+            output << Paint["#{Note[tone_number].name}(#{notes.size})", color, und]
+            output << " "
+          end
+          output << "\n"
+        end
+        puts output.join
+      end
+
+      def initialize(scale, on: :text, flavor: 'degrees', notes: [], chords: [])
+        desc = "This is the #{scale.tone.name} #{scale.name} scale:"
+        Coltrane::Cli::Notes.new(scale.notes, on: on, desc: desc, flavor: flavor)
+      end
+    end
+  end
+end

data/lib/cli/text.rb

@@ -0,0 +1,13 @@
+module Coltrane
+  module Cli
+    class Text < Representation
+      def render
+        case @flavor
+        when :marks, :notes, :degrees then @notes.pretty_names.join(' ')
+        when :intervals then @notes.map {|n| (@notes.first - n).name}.join(' ')
+        else raise WrongFlavorError.new
+        end
+      end
+    end
+  end
+end

data/lib/cli/ukulele.rb

@@ -0,0 +1,11 @@
+module Coltrane
+  module Cli
+    class Ukulele < Guitar
+      SPECIAL_FRETS = [5, 7, 9, 12]
+
+      def initialize(notes, flavor, tuning: %w[G C E A], frets: 12)
+        super
+      end
+    end
+  end
+end

data/lib/coltrane-cli.rb

@@ -0,0 +1,12 @@
+require 'cli/errors'
+
+require 'cli/representation'
+require 'cli/text'
+require 'cli/piano'
+require 'cli/guitar'
+require 'cli/bass_guitar'
+require 'cli/ukulele'
+
+require 'cli/notes'
+require 'cli/chord'
+require 'cli/scale'

data/lib/coltrane.rb

@@ -1,48 +1,33 @@
-# $LOAD_PATH << __dir__
+require 'bundler'
+Bundler.require
 
-# require 'bundler'
+require 'facets/multiton'
+require 'ostruct'
+require 'paint'
 
-# 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/version'
+require 'coltrane/errors'
 
+require 'coltrane/cache'
 require 'coltrane/cadence'
 
+require 'coltrane/interval_sequence'
+require 'coltrane/interval_set'
+require 'coltrane/interval'
 require 'coltrane/qualities'
 require 'coltrane/chord_quality'
+require 'coltrane/note_set'
 require 'coltrane/chord'
+require 'coltrane/roman_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/classic_progressions'
 
-require 'coltrane/interval_sequence'
-require 'coltrane/interval_set'
-require 'coltrane/interval'
+require 'coltrane/piano_representation'
 
-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'
+require 'coltrane/mode'

data/lib/coltrane/cache.rb

@@ -0,0 +1,34 @@
+module Coltrane
+  class Cache
+    class << self
+      def find_or_record(key, &block)
+        if (cached = fetch(key))
+          return cached
+        else
+          cached = yield block
+          record(key, cached)
+          cached
+        end
+      end
+
+      private
+
+      def dir
+        dir = File.expand_path('../../../', __FILE__) + "/cache/"
+        Dir.mkdir(dir) unless Dir.exist?(dir)
+        dir
+      end
+
+      def fetch(key)
+        return unless File.file?(dir+key)
+        Marshal.load File.read(dir+key)
+      end
+
+      def record(key, contents)
+        File.open(dir+key, "w") do |f|
+          f.write Marshal.dump(contents)
+        end
+      end
+    end
+  end
+end

data/lib/coltrane/chord.rb

@@ -1,52 +1,40 @@
 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
+  class Chord < NoteSet
+    attr_reader :root_note, :quality, :notes
+
+    def initialize(notes: nil, root_note: nil, quality: nil, name: nil)
+      if !notes.nil?
+        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?
+        @notes     = quality.notes_for(root_note)
+        @root_note = root_note
+        @quality   = quality
+      elsif !name.nil?
+        @root_note, @quality, @notes = parse_from_name(name)
+      else
+        raise WrongKeywords.new('[notes:] || [root_note:, quality:] || [name:]')
       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?
+      return @notes.names.join('/') if !named?
       "#{root_note.name}#{quality.name}"
     end
 
-    def notes
-      quality.intervals.each_with_object([]) do |interval, notes|
-        notes << Note.new(root_note.number + interval)
-      end
+    def named?
+      notes.size >= 3 &&
+      !root_note.nil? &&
+      !quality&.name.nil?
     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
@@ -69,13 +57,12 @@ module Coltrane
 
     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)]
+    def parse_from_name(name)
+      _, name, quality_name = name.match(/([A-Z]#?)(.*)/).to_a
+      root    = Note[name]
+      quality = ChordQuality.new(name: quality_name)
+      notes   = quality.notes_for(root)
+      [root, quality, notes]
     end
   end
 end