coltrane 0.0.2 → 1.0.0

data/lib/coltrane/guitar.rb

@@ -1,15 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,98 +0,0 @@
-# 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

@@ -1,50 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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/scale_cache.rb

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