coltrane 0.0.2

data/lib/coltrane/guitar.rb

@@ -0,0 +1,15 @@
+module Coltrane
+  # This holds default guitar features
+  module Guitar
+    extend EssentialGuitarChords
+    def self.strings
+      %w[E4 B3 G3 D3 A2 E2].map do |pitch|
+        GuitarString.new(pitch)
+      end
+    end
+
+    def self.frets
+      23
+    end
+  end
+end

data/lib/coltrane/guitar_chord.rb

@@ -0,0 +1,50 @@
+module Coltrane
+  # It describes a group of guitar notes
+  class GuitarChord < GuitarNoteSet
+
+    class << self
+      def new_from_notes(guitar_notes)
+        new(*frets_in_sequence(guitar_notes))
+      end
+
+      def new_from_frets(*frets)
+        gns = (0..5).each_with_object([]) do |string_index, memo|
+          fret = frets[5-string_index]
+          unless fret.nil?
+            memo << GuitarNote.new(guitar_string_index: string_index,
+                                   fret: fret)
+          end
+        end
+        new_from_notes(gns)
+      end
+
+      def frets_in_sequence(guitar_notes)
+        guitar_notes.each_with_object([]) do |gn, memo|
+          memo[gn.guitar_string_index] = gn.fret
+        end
+      end
+    end
+
+    def initialize(*frets_in_sequence)
+      arg = frets_in_sequence.each_with_index.map do |fret, i|
+        { fret: fret, guitar_string_index: i }
+      end
+      super(arg)
+    end
+
+    def chord
+      Chord.new(notes)
+    end
+
+    def frets_in_sequence
+      self.class.frets_in_sequence(guitar_notes)
+    end
+
+    def to_s
+      fs = frets_in_sequence
+      (0..5).map { |x|
+        fs[5-x].nil? ? 'X ' : fs[5-x].to_s.ljust(2,' ')
+      }.join(' ')
+    end
+  end
+end

data/lib/coltrane/guitar_chord_finder.rb

@@ -0,0 +1,98 @@
+# require 'digest'
+
+module Coltrane
+  module GuitarChordFinder
+    class << self
+      # TODO Refactor this piece of shit
+      def by_chord_name(chord_name)
+        by_chord(Chord.new(chord_name))
+      end
+
+      def by_chord(chord)
+        gnotes = gnotes_for_chord(chord.notes)
+        frets = gnotes.map(&:fret).uniq.sort
+        frets.delete(0)
+        threads = []
+        frets.each do |fret|
+          threads << Thread.new do
+            gnotes_for_fret = gnotes.dup.delete_if do |gnote|
+              !(gnote.fret-fret).between?(0,4) && !gnote.fret.zero?
+            end
+
+            gnotes_to_start_with = gnotes_for_fret.dup.delete_if do |gnote|
+              gnote.fret != fret
+            end
+
+            gnotes_to_start_with.reduce([]) do |memo2, gnote|
+              gnotes_for_fret.delete(gnote)
+              memo2 + combine_gnotes_into_chords( gnotes_for_fret, [gnote])
+            end
+          end
+        end
+        chords = threads.map(&:value).flatten
+        remove_duplicate_chords(chords)
+      end
+
+      def gnotes_for_chord(notes)
+        gnotes = notes.reduce([]) do |memo_1, note|
+          memo_1 + Guitar.strings.reduce([]) do |memo_2, gs|
+            memo_2 + gs.guitar_notes_for_note_in_region(note, 0..12)
+          end
+        end
+      end
+
+      def combine_gnotes_into_chords(gnotes_left,
+                                     chord_notes=[],
+                                     repeat_notes: false,
+                                     color_gnotes: [])
+
+        if chord_notes.size == 6
+          return [GuitarChord.new_from_notes(chord_notes)]
+        elsif gnotes_left.empty?
+          if color_gnotes.empty?
+            return [GuitarChord.new_from_notes(chord_notes)]
+          else
+            return combine_gnotes_into_chords color_gnotes.uniq,
+                                       chord_notes,
+                                       repeat_notes: true
+          end
+        else
+
+          chords = []
+
+          gnotes_left.each do |gnote|
+            new_chord_notes = chord_notes + [gnote]
+            new_gnl = gnotes_left.dup
+            new_gnl.delete(gnote)
+            new_gnl.delete_if do |g|
+              next(true) if g.guitar_string_index == gnote.guitar_string_index
+              if g.note.name == gnote.note.name && !repeat_notes
+                color_gnotes << g
+                next(true)
+              end
+            end
+
+            chords += combine_gnotes_into_chords new_gnl,
+                                                 new_chord_notes,
+                                                 repeat_notes: repeat_notes,
+                                                 color_gnotes: color_gnotes.uniq
+          end
+
+          return chords.compact
+        end
+      end
+
+      def remove_duplicate_chords(chords)
+        chords_to_include = chords.map(&:to_s).uniq
+        chords.each_with_object [] do |chord, new_chords|
+          chord_str = chord.to_s
+          if chords_to_include.include?(chord_str)
+            chords_to_include.delete(chord_str)
+            new_chords << chord
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/coltrane/guitar_note.rb

@@ -0,0 +1,50 @@
+module Coltrane
+  # It describes a guitar note
+  class GuitarNote
+    attr_reader :position
+
+    def initialize(fret:, guitar_string_index:)
+      if fret.nil? || guitar_string_index.nil?
+        raise "invalid guitar note for f:#{fret} and s:#{guitar_string_index}"
+      end
+      @position = { fret: fret, guitar_string_index: guitar_string_index }
+    end
+
+    def new_from_guitar_string_and_note(gsi, note); end
+
+    def note
+      pitch.note
+    end
+
+    def to_s
+      "string: #{guitar_string_index}/fret: #{fret}"
+    end
+
+    def guitar_string_index
+      position[:guitar_string_index]
+    end
+
+    def fret
+      position[:fret]
+    end
+
+    def guitar_string
+      Guitar.strings[guitar_string_index]
+    end
+
+    def pitch
+      Pitch.new(guitar_string.pitch.number + fret)
+    end
+
+    def guitar_chord(_quality)
+      guitar_strings    = (guitar_string_index..0).to_a
+      guitar_note_array = guitar_strings.each_with_object([]) do |gsi, memo|
+        if f < Guitar.frets
+          gn = new_from_guitar_string_and_note(gsi, note)
+          memo << gn unless gn.nil?
+        end
+      end
+      GuitarChord.new(guitar_note_array)
+    end
+  end
+end

data/lib/coltrane/guitar_note_set.rb

@@ -0,0 +1,61 @@
+module Coltrane
+  class GuitarNoteSet
+    attr_reader :guitar_notes
+
+    def initialize(arg)
+      arg = [arg] unless arg.class == Array
+      @guitar_notes = arg.reduce([]) do |memo, arg_item|
+        case arg_item
+        when Hash
+          if arg_item[:fret].nil?
+            memo
+          else
+            (memo + [GuitarNote.new(arg_item)])
+          end
+
+        when GuitarNote then memo + [arg_item]
+        when Pitch      then memo + guitar_notes_for_pitch(arg_item)
+        when String     then memo + guitar_notes_for_pitch(Pitch.new(arg_item))
+        end
+      end
+    end
+
+    def guitar_notes_for_pitch(pitch)
+      Guitar.strings.each_with_index.each_with_object([]) do |object, memo|
+        guitar_string, index = object
+        fret = guitar_string.fret_by_pitch(pitch)
+        unless fret.nil?
+          memo << GuitarNote.new(guitar_string_index: index, fret: fret)
+        end
+      end
+    end
+
+    def root_note
+      lowest_pitch.note
+    end
+
+    def lowest_pitch
+      pitches.sort_by(&:number).first
+    end
+
+    def pitches
+      guitar_notes.collect(&:pitch)
+    end
+
+    def notes
+      guitar_notes.collect(&:note)
+    end
+
+    def note_string
+      notes.collect(&:name).join(' ')
+    end
+
+    def chord_quality
+      ChordQuality.new_from_pitches(*pitches)
+    end
+
+    def render(*args)
+      GuitarRepresentation.render(self, *args)
+    end
+  end
+end

data/lib/coltrane/guitar_representation.rb

@@ -0,0 +1,96 @@
+require 'paint'
+module Coltrane
+  module GuitarRepresentation
+    class << self
+      def render(guitar_notes, ref_note=nil)
+        gns = guitar_notes.guitar_notes.map(&:position)
+        tabs = Guitar.strings.map do |string|
+          Guitar.frets.times.map.each do |fret|
+            position = { guitar_string_index: string.index, fret: fret }
+            present = gns.include?(position)
+            x = if present
+              gn = GuitarNote.new(position)
+              mark = ref_note ? (gn.note - ref_note).name : '◼︎◼︎'
+              Paint[mark, :red]
+            else
+              '--'
+            end
+            x + (fret.zero? ? '|' : ' ')
+          end.join('')
+        end.join("\n")
+
+        special_frets = [3,5,7,9,12,15,17,19,21]
+        visual_aids = Guitar.frets.times.map do |fret|
+          x = if special_frets.include?(fret)
+            Paint[fret.to_s.rjust(2, 0.to_s), :yellow]
+          else
+            '  '
+          end
+          x + ' '
+        end.join('')
+
+        [tabs, "#{visual_aids}"].join("\n")
+      end
+
+      def render_degrees(guitar_notes, ref_scale)
+        gns = guitar_notes.guitar_notes.map(&:position)
+        tabs = Guitar.strings.map do |string|
+          Guitar.frets.times.map.each do |fret|
+            position = { guitar_string_index: string.index, fret: fret }
+            present = gns.include?(position)
+            x = if present
+              gn = GuitarNote.new(position)
+              mark = ref_scale.degree_of_note(gn.note).to_s.rjust(2, 0.to_s)
+              Paint[mark, :red]
+            else
+              '--'
+            end
+            x + (fret.zero? ? '|' : ' ')
+          end.join('')
+        end.join("\n")
+
+        special_frets = [3,5,7,9,12,15,17,19,21]
+        visual_aids = Guitar.frets.times.map do |fret|
+          x = if special_frets.include?(fret)
+            Paint[fret.to_s.rjust(2, 0.to_s), :yellow]
+          else
+            '  '
+          end
+          x + ' '
+        end.join('')
+
+        [tabs, "#{visual_aids}"].join("\n")
+      end
+
+      def render_notes(guitar_notes, ref_scale)
+        gns = guitar_notes.guitar_notes.map(&:position)
+        tabs = Guitar.strings.map do |string|
+          Guitar.frets.times.map.each do |fret|
+            position = { guitar_string_index: string.index, fret: fret }
+            present = gns.include?(position)
+            x = if present
+              gn = GuitarNote.new(position)
+              mark = gn.note.name.to_s.ljust(2, ' ')
+              Paint[mark, :red]
+            else
+              '--'
+            end
+            x + (fret.zero? ? '|' : ' ')
+          end.join('')
+        end.join("\n")
+
+        special_frets = [3,5,7,9,12,15,17,19,21]
+        visual_aids = Guitar.frets.times.map do |fret|
+          x = if special_frets.include?(fret)
+            Paint[fret.to_s.rjust(2, 0.to_s), :yellow]
+          else
+            '  '
+          end
+          x + ' '
+        end.join('')
+
+        [tabs, "#{visual_aids}"].join("\n")
+      end
+    end
+  end
+end

data/lib/coltrane/guitar_string.rb

@@ -0,0 +1,52 @@
+module Coltrane
+  # It describes a guitar string
+  class GuitarString
+    attr_reader :pitch
+
+    def initialize(pitch)
+      @pitch = Pitch.new(pitch)
+    end
+
+    def fret_by_pitch(pitch)
+      pitch = Pitch.new(pitch) if pitch.class != Pitch
+      fret = pitch.number - @pitch.number
+      fret if fret >= 0
+    end
+
+    def pitch_by_fret(fret)
+      Pitch.new(pitch.number + fret)
+    end
+
+    def guitar_notes_for_note(note)
+      pitches_for_note(note).map do |pitch|
+        GuitarNote.new(fret: fret_by_pitch(pitch),
+                       guitar_string_index: index)
+      end
+    end
+
+    def guitar_notes_for_note_in_region(note, region)
+      pitches_for_note(note).each_with_object([]) do |pitch, memo|
+        fret = fret_by_pitch(pitch)
+        if region.include?(fret) || fret == 0
+          memo << GuitarNote.new(fret: fret, guitar_string_index: index)
+        end
+      end
+    end
+
+    def index
+      Guitar.strings.index { |string| string.pitch.number == self.pitch.number }
+    end
+
+    def pitches_for_note(note)
+      pitches.each_with_object([]) do |pitch, memo|
+        memo << pitch if pitch.note.name == note.name
+      end
+    end
+
+    def pitches
+      Guitar.frets.times.map do |fret|
+        pitch_by_fret(fret)
+      end
+    end
+  end
+end

data/lib/coltrane/interval.rb

@@ -0,0 +1,33 @@
+module Coltrane
+  # It describes a interval between 2 pitches
+  class Interval
+    attr_reader :number
+
+    NAMES = [
+      '1P',
+      '2m', '2M',
+      '3m', '3M',
+      '4P', '4A',
+      '5P',
+      '6m', '6M',
+      '7m',
+      '7M',
+      '8P',
+      '9m', '9M',
+      '10m', '10M',
+      '11P',
+      '12P',
+      '13m', '13M',
+      '14m', '14M',
+      '15P', '15A'
+    ].freeze
+
+    def initialize(number)
+      @number = number
+    end
+
+    def name
+      NAMES[number]
+    end
+  end
+end