chords 0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Antti Hakala
+ 
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+ 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,24 @@
+Chords
+======
+A chord generator lib for guitar-like instruments.
+
+
+Running irb under chords/lib:
+
+>> require 'chords'
+=> true
+>> include Chords
+=> Object
+>> Fretboard.standard.print E.major, :duplicates => 3, :max_fret_distance => 2
+
+E: --0----0----0----0---12----7----0---12----7--
+B: --9----0----0---12---12----9---12---12----9--
+G: --9----9----1---13---13----9---13---13----9--
+D: --9----9----2---14---14----9---14---14----9--
+A: -11---11----2---14---14----7---14---14----7--
+E: --0----0----0----0----0----0---12---12----7--
+
+Total 9 fingerings.
+
+=> nil
+>>

data/bin/chords

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'chords/command_line'
+
+Chords::CommandLineParser.new(ARGV).parse

data/lib/chords.rb

@@ -0,0 +1,3 @@
+
+require 'chords/fretboard'
+

data/lib/chords/chord.rb

@@ -0,0 +1,52 @@
+require 'chords/note'
+
+module Chords
+  
+  class Chord
+    attr_reader :notes
+    attr_accessor :root
+    
+    def initialize(*notes)
+      @notes = notes.flatten
+      @root = @notes.first
+    end
+    
+    def first_inversion
+      raise "Not enough notes for inversion" if notes.size < 3
+      inversion = Chord.new(@notes[1], @notes[2], @root, *@notes[3..-1])
+      inversion.root = @root
+      inversion
+    end
+    
+    def second_inversion
+      raise "Not enough notes for inversion" if notes.size < 3
+      inversion = Chord.new(@notes[2], @root, @notes[1], *@notes[3..-1])
+      inversion.root = @root
+      inversion
+    end
+    
+    def sixth
+      Chord.new(@notes + [@root + 9])
+    end
+    
+    def seventh
+      Chord.new(@notes + [@root + 10])
+    end
+    
+    def add9
+      Chord.new(@notes + [@root + 14])
+    end
+    
+    def add11
+      Chord.new(@notes + [@root + 17])
+    end
+    
+    def bass(note)
+      chord = Chord.new([note] + @notes)
+      chord.root = self.root
+      chord
+    end
+    
+  end
+  
+end

data/lib/chords/chord_factory.rb

@@ -0,0 +1,33 @@
+require 'chords/chord'
+
+module Chords
+  module ChordFactory
+    extend self
+    CHORDS = {:major  => [4,7],
+              :minor  => [3,7],
+              :five   => [7],
+              :sus2   => [2, 7],
+              :sus4   => [5, 7],
+              :aug    => [4, 8],
+              :dim    => [3, 6],
+              :minus5 => [4, 6]}
+    
+    def new_chord(root, key)
+      raise "No chord with key #{key}" unless CHORDS.has_key?(key)
+      notes = [root]
+      notes += CHORDS[key].map{|interval| root + interval}
+      Chord.new(notes)
+    end
+  end
+  
+  # Extensions to Note so we can say for example 'E.major' to create a chord
+  module NoteExt
+    ChordFactory::CHORDS.keys.each do |key|
+      define_method key do
+        ChordFactory.new_chord(self, key)
+      end
+    end
+  end
+  
+  NOTES.flatten.each{|note_name| Chords.const_get(note_name).extend NoteExt}
+end

data/lib/chords/command_line.rb

@@ -0,0 +1,115 @@
+require 'optparse'
+require 'chords'
+
+module Chords
+  class CommandLineParser
+    
+    def initialize(args)
+      @args = args
+      @frets = Chords::Fretboard::DEFAULT_FRETS
+      @duplicates = 0
+      @max_fret_distance = Chords::Fingering::DEFAULT_MAX_FRET_DISTANCE
+      @tuning = Chords::Fretboard::TUNINGS[:standard]
+    end
+    
+    def parse
+      @opts = OptionParser.new
+      @opts.banner = "Usage: chords [options] CHORD"
+      
+      @opts.on("-l", "--list", 
+              "List tunings and chords.") do
+        puts tunings_and_chords
+        exit
+      end
+        
+      @opts.on("-f", "--frets NUMBER_OF_FRETS",
+              Integer,
+              "Number of frets, i.e. max position in fingerings.") do |frets|
+        @frets = frets
+      end
+      
+      @opts.on("-d", "--duplicates DUPLICATES",
+              Integer,
+              "Number of duplicated notes.") do |duplicates|
+        @duplicates = duplicates
+      end
+      
+      @opts.on("-m", "--max-fret-distance MAX_FRET_DISTANCE",
+              Integer,
+              "Maximum distance between positions in fingering.") do |mfd|
+        @max_fret_distance = mfd
+      end
+      
+      @opts.on("-t", "--tuning TUNING", 
+              "Tuning to use. See -l for list of available tunings and chords.") do |t|
+        if !Chords::Fretboard::TUNINGS.has_key?(t.to_sym)
+          raise OptionParser::ParseError.new("Invalid tuning")
+        end
+        @tuning = Chords::Fretboard::TUNINGS[t.to_sym]
+      end
+      
+      @opts.on_tail("-h", "--help", examples) do
+        puts @opts
+      end
+      
+      begin
+        print_chord @opts.parse!(@args)
+      rescue OptionParser::ParseError => e
+        puts e.message
+      end
+    end
+    
+    private
+    
+    def print_chord(args)
+      if args.size == 1
+        chord_str = args.first
+        chord_str =~ /^(.{1,2})\.(.*)/
+
+        if $1 and $2 and Chords::NOTES.flatten.include?($1)
+          note = Chords.const_get($1)
+          begin
+            chord = note.class_eval($2)
+            Fretboard.new(@tuning, @frets).print(chord, 
+              {:duplicates => @duplicates,
+               :max_fret_distance => @max_fret_distance})
+            return
+          rescue NameError => e # invalid chord variation
+          end
+        end
+      end
+      
+      puts "Invalid chord."
+      puts @opts
+    end
+    
+    def tunings_and_chords
+      out = "Tunings:\n=======\n"
+      Chords::Fretboard::TUNINGS.each do |key, value|
+        out += "#{key.to_s.ljust(12, ' ')}: #{value.map{|n| n.class.to_s.gsub(/.*::/,'')}.join(',')}\n"
+      end
+      out += "\nChords:\n======\n"
+      Chords::ChordFactory::CHORDS.each do |key, value|
+        out += "#{key}\n"
+      end
+      out += "\nYou can also use following modifiers on chords:\n"+
+             "* first_inversion\n"+
+             "* second_inversion\n"+
+             "* sixth\n"+
+             "* seventh\n"+
+             "* add9\n"+
+             "* add11\n"+
+             "* bass(NOTE)\n"
+    end
+    
+    def examples
+      "\n\nExamples:\n"+
+      "$ chords E.major.add9\n"+
+      "$ chords \"C.major.bass(G)\"\n"+
+      "$ chords -d 3 As.dim\n"+
+      "$ chords -t dadgad D.minor.first_inversion\n"+
+      "\nSharp notes are followed by 's' and flats by 'b', e.g. 'Gs' and 'Eb'."
+    end
+    
+  end
+end

data/lib/chords/fingering.rb

@@ -0,0 +1,132 @@
+require 'forwardable'
+
+module Chords
+  
+  class Fingering
+    DEFAULT_MAX_FRET_DISTANCE = 3
+    
+    extend Forwardable
+    
+    def_delegators :@positions, :[], :==, :inspect, :each, :each_with_index
+    
+    def initialize(fretboard, positions=nil)
+      @fretboard = fretboard
+      @positions = positions || ([nil] * @fretboard.open_notes.size)
+    end
+    
+    def self.find_variations(fretboard, chord, opts={})
+      fingering = Fingering.new(fretboard)
+      fingerings = fingering.expand(chord.notes.first)
+      
+      chord.notes[1..-1].each do |note|
+        fingerings = fingerings.map{|f| f.expand(note, opts)}.flatten(1)
+      end
+      
+      (opts[:duplicates] || 0).times do
+        fingerings = fingerings.map{|f| f.add_duplicate(opts)}.flatten(1).uniq
+      end
+      
+      fingerings
+    end
+    
+    # Returns all fingering variations of this fingering
+    # expanded with note.
+    # Expanded note wil be on a higher string than existing notes.
+    # It will also be the highest note.
+    def expand(note, opts={})
+      max_fret_distance = opts[:max_fret_distance] || DEFAULT_MAX_FRET_DISTANCE
+      
+      fingerings = []
+      
+      ((highest_used_string+1)..(@positions.size-1)).each do |str_i|
+        new_note_positions(note, str_i, max_fret_distance).each do |pos|
+          if (@fretboard.open_notes[str_i] + pos) > highest_note
+            new_positions = @positions.dup
+            new_positions[str_i] = pos
+            fingerings << Fingering.new(@fretboard, new_positions)
+          end
+        end
+      end
+      
+      fingerings
+    end
+    
+    # returns variations of this fingering with one duplicate note added
+    def add_duplicate(opts={})
+      return [] if unused_strings < 1
+      max_fret_distance = opts[:max_fret_distance] || DEFAULT_MAX_FRET_DISTANCE
+      
+      fingerings = []
+      
+      @positions.each_with_index do |pos, i|
+        next unless pos.nil?
+        
+        each_note do |note|
+          new_note_positions(note, i, max_fret_distance).each do |pos|
+            new_positions = @positions.dup
+            new_positions[i] = pos
+            fingerings << Fingering.new(@fretboard, new_positions)
+          end
+        end
+      end
+      
+      fingerings
+    end
+    
+    def each_note
+      @positions.each_with_index do |pos, i|
+        yield((@fretboard.open_notes[i] + pos).class) unless pos.nil?
+      end
+    end
+    
+    def eql?(other)
+      self.hash == other.hash
+    end
+    
+    def hash
+      @positions.hash
+    end
+    
+    private
+    
+    def new_note_positions(note, string_index, max_fret_distance)
+      positions = []
+      open_note = @fretboard.open_notes[string_index]
+      pos = note.new(open_note.octave).value - open_note.value
+      pos += 12 if pos < 0
+      
+      while pos <= @fretboard.frets
+        positions << pos if distance(pos) <= max_fret_distance
+        pos += 12
+      end
+      positions
+    end
+    
+    def distance(position)
+      pos_arr = (@positions + [position]).select{|p| !p.nil? && p > 0}
+      (pos_arr.max || 0) - (pos_arr.min || 0)
+    end
+    
+    def unused_strings
+      @fretboard.open_notes.size - @positions.compact.size
+    end
+    
+    def highest_used_string
+      indices = []
+      @positions.each_with_index do |pos,i|
+        indices << i unless pos.nil?
+      end
+      indices.max || -1
+    end
+    
+    def highest_note
+      notes = []
+      @positions.each_with_index do |pos,i|
+        notes << @fretboard.open_notes[i] + pos unless pos.nil?
+      end
+      notes.max || (@fretboard.open_notes.min - 1)
+    end
+    
+  end
+  
+end

data/lib/chords/fretboard.rb

@@ -0,0 +1,68 @@
+require 'chords/chord_factory'
+require 'chords/fingering'
+require 'chords/text_formatter'
+
+module Chords
+  
+  class Fretboard
+    DEFAULT_FRETS = 14
+    
+    # See http://en.wikipedia.org/wiki/Guitar_tunings
+    TUNINGS = {
+               # Some usual ones
+               :standard => [E.new, A.new, D.new, G.new(1), B.new(1), E.new(2)],
+               :drop_d   => [D.new(-1), A.new, D.new, G.new(1), B.new(1), E.new(2)],
+               :ddd      => [D.new(-1), A.new, D.new, G.new(1), B.new(1), D.new(1)], # double-dropped D
+               :dadgad   => [D.new(-1), A.new, D.new, G.new(1), A.new(1), D.new(1)],
+               
+               # Major open tunings
+               :open_e   => [E.new, B.new, E.new(1), Gs.new(1), B.new(1), E.new(2)],
+               :open_d   => [D.new(-1), A.new, D.new, Fs.new(1), A.new(1), D.new(1)],
+               :open_a   => [E.new, A.new, E.new(1), A.new(1), Cs.new(1), E.new(2)],
+               :open_g   => [D.new(-1), G.new, D.new, G.new(1), B.new(1), D.new(1)],
+               :open_c   => [C.new(-1), G.new, C.new, G.new(1), C.new(1), E.new(2)],
+               
+               # Cross-note tunings
+               :cross_e  => [E.new, B.new, E.new(1), G.new(1), B.new(1), E.new(2)],
+               :cross_d  => [D.new(-1), A.new, D.new, F.new(1), A.new(1), D.new(1)],
+               :cross_a  => [E.new, A.new, E.new(1), A.new(1), C.new(1), E.new(2)],
+               :cross_g  => [D.new(-1), G.new, D.new, G.new(1), Bb.new(1), D.new(1)],
+               :cross_c  => [C.new(-1), G.new, C.new, G.new(1), C.new(1), Eb.new(1)],
+               
+               # Modal tunings
+               :cacgce   => [C.new(-1), A.new, C.new, G.new(1), C.new(1), E.new(2)],
+               :e_modal  => [E.new, B.new, E.new(1), E.new(1), B.new(1), E.new(2)],
+               :g_modal  => [G.new, G.new, D.new, G.new(1), B.new(1), D.new(1)],
+               :gsus2    => [D.new(-1), G.new, D.new, G.new(1), A.new(1), D.new(1)],
+               :c15      => [C.new(-1), G.new, D.new, G.new(1), C.new(1), D.new(1)],
+               
+               # "Extended chord" tunings
+               :dmaj7    => [D.new(-1), A.new, D.new, Fs.new(1), A.new(1), Cs.new(1)]
+              }
+    
+    attr_reader :frets, :open_notes
+    
+    def initialize(open_notes, frets)
+      @open_notes, @frets = open_notes, frets
+      @formatter = TextFormatter.new(self)
+    end
+    
+    def self.method_missing(meth, *args)
+      if TUNINGS.has_key?(meth)
+        Fretboard.new(TUNINGS[meth], (args.first || DEFAULT_FRETS))
+      else
+        super
+      end
+    end
+    
+    def find(chord, opts={})
+      Fingering.find_variations(self, chord, opts)
+    end
+    
+    def print(chord, opts={})
+      fingerings = find(chord, opts)
+      @formatter.print(fingerings)
+    end
+    
+  end
+end

data/lib/chords/note.rb

@@ -0,0 +1,66 @@
+
+module Chords
+  NOTES = ['E', 'F', ['Fs', 'Gb'], 'G', ['Gs', 'Ab'], 'A',
+           ['As', 'Bb'], ['B', 'H'], 'C', ['Cs', 'Db'], 'D', ['Ds', 'Eb']]
+
+  module Note
+    include Comparable
+    attr_reader :interval, :name, :octave
+
+    def self.create_by_value(value)
+      octave = value / 12
+      interval = value % 12
+      Chords.const_get([NOTES[interval]].flatten.first).new(octave)
+    end
+    
+    def value
+      (@octave * 12) + @interval
+    end
+
+    def <=>(other)
+      if other.respond_to?(:value)
+        value <=> other.value
+      else
+        value <=> other
+      end
+    end
+
+    def coerce(other)
+      if other.respond_to?(:value)
+        [other.value, value]
+      else
+        [other, value]
+      end
+    end
+
+    def name; self.class.to_s.gsub(/^.*::/, '') end
+
+    def +(other); Note.create_by_value(value + other) end
+    def -(other); Note.create_by_value(value - other) end
+  end
+  
+  # E.g. E + 3 => G
+  module NoteClassArithmetic
+    def +(interval)
+      note = NOTES.detect{|n| [n].flatten.include?(self.to_s.gsub(/^.*::/, ''))}
+      idx = NOTES.index(note) + interval
+      idx = idx % NOTES.size
+      Chords.const_get [NOTES[idx]].flatten.first
+    end
+    def -(interval); self + (-interval) end
+  end
+  
+  NOTES.each_with_index do |names, i|
+    names = [names].flatten
+    names.each do |n|
+      eval %Q(class #{n}
+                include Note
+                extend NoteClassArithmetic
+                
+                def initialize(octave=0)
+                  @interval, @octave = #{i}, octave
+                end
+              end)
+    end
+  end
+end

data/lib/chords/text_formatter.rb

@@ -0,0 +1,34 @@
+
+module Chords
+  
+  class TextFormatter
+    
+    def initialize(fretboard)
+      @fretboard = fretboard
+    end
+    
+    def print(fingerings)
+      rows = [""] * @fretboard.open_notes.size
+      
+      fingerings.each do |fingering|
+        fingering.each_with_index do |position,i|
+          rows[i] += "-#{position ? position.to_s.rjust(2,'-') : '-X'}--"
+        end
+      end
+      
+      idx = 0
+      while rows.first.length > idx
+        parts = []
+        rows.each_with_index do |row, i| 
+          parts << "#{@fretboard.open_notes[i].name.rjust(2, ' ')}: " + row[idx...(idx+75)]
+        end
+        puts "\n" + (parts.reverse.join("\n")) + "\n\n"
+        idx += 75
+      end
+      
+      puts "Total #{fingerings.size} fingerings."
+    end
+    
+  end
+  
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: chords
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Antti Hakala
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-25 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: "Chords is a chord generator for guitar-like instruments. Handy for special tunings. "
+email: antti.hakala@gmail.com
+executables: 
+- chords
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- MIT-LICENSE
+- bin/chords
+- lib/chords/chord.rb
+- lib/chords/chord_factory.rb
+- lib/chords/command_line.rb
+- lib/chords/fingering.rb
+- lib/chords/fretboard.rb
+- lib/chords/note.rb
+- lib/chords/text_formatter.rb
+- lib/chords.rb
+has_rdoc: true
+homepage: http://github.com/ander/chords
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Chord generator for guitar-like instruments.
+test_files: []
+