chords 0.3.2 → 0.4.1

data/lib/chords/command_line_parser.rb

@@ -43,10 +43,11 @@ module Chords
       
       @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)
+        begin
+          @tuning = Fretboard.send(t.downcase).open_notes
+        rescue Exception => e
           raise OptionParser::ParseError.new("Invalid tuning")
         end
-        @tuning = Chords::Fretboard::TUNINGS[t.to_sym]
       end
       
       @opts.on("--pdf", "Output to pdf. Requires Prawn.") do
@@ -109,6 +110,8 @@ module Chords
       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 += "\nYou can also give a tuning as a string of notes, e.g. 'eadgbe'. Note that "+
+             "all 'b':s are considered notes, not flats, so use 's':s for sharps instead.\n"
       out += "\nChords:\n======\n"
       Chords::ChordFactory::CHORDS.each do |key, value|
         out += "#{key}\n"

data/lib/chords/fingering.rb

@@ -87,7 +87,12 @@ module Chords
       @positions.hash
     end
     
-    # fingering id, a unique identifier for fretboard/fingering combo
+    # Fingering id, a unique identifier for fretboard/fingering combo.
+    # Actually, fid is not unique if max_fret_distance >= 9,
+    # as positions [0,10,0,0,1,0] and [0,1,0,0,0,10] produce the
+    # same fid (if the tuning is the same).
+    # However, max_fret_distance of 9 or greater is not 
+    # realistic.
     def fid
       @fretboard.open_notes.map{|n| n.class.title}.to_s + 
         @positions.map{|pos| pos.nil? ? 'x' : pos}.to_s

data/lib/chords/fretboard.rb

@@ -26,8 +26,8 @@ module Chords
                :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)],
+               :cross_g  => [D.new(-1), G.new, D.new, G.new(1), As.new(1), D.new(1)],
+               :cross_c  => [C.new(-1), G.new, C.new, G.new(1), C.new(1), Ds.new(1)],
                
                # Modal tunings
                :cacgce   => [C.new(-1), A.new, C.new, G.new(1), C.new(1), E.new(2)],
@@ -47,15 +47,44 @@ module Chords
     
     attr_reader :frets, :open_notes, :formatter
     
-    def initialize(open_notes, frets, formatter_class=TextFormatter)
+    def initialize(open_notes, frets=DEFAULT_FRETS, formatter_class=TextFormatter)
       @open_notes, @frets = open_notes, frets
       @formatter = formatter_class.new(self)
     end
     
+    # Creates a new fretboard, parsing the open notes from the open_notes_str.
+    # All 'b':s are interpreted as B-notes, not flats, so use 's' for sharps instead.
+    def self.new_by_string(open_notes_str, frets=DEFAULT_FRETS, 
+                           formatter_class=TextFormatter)
+      open_notes_str.upcase!
+      raise "Provide at least 3 strings" if open_notes_str.scan(/[^S]/m).size < 3
+      open_notes = []
+      
+      open_notes_str.scan(/./m).each do |chr|
+        if chr == 'S'
+          raise "Invalid tuning!" if open_notes.empty?
+          open_notes[open_notes.size-1] += 1
+        else
+          open_notes << Chords.const_get(chr).new
+        end
+      end
+      
+      (1..(open_notes.size-1)).each do |i|
+        open_notes[i] += 12 while open_notes[i-1] > open_notes[i]
+      end
+      
+      Fretboard.new(open_notes, frets, formatter_class)
+    end
+    
     def self.method_missing(meth, *args)
       if TUNINGS.has_key?(meth)
         Fretboard.new(TUNINGS[meth], (args[0] || DEFAULT_FRETS),
                       args[1] || TextFormatter)
+                      
+      elsif meth.to_s =~ /^[efgabhcds]+$/
+        Fretboard.new_by_string(meth.to_s, (args[0] || DEFAULT_FRETS),
+                                args[1] || TextFormatter)
+      
       else
         super
       end
@@ -70,5 +99,34 @@ module Chords
       @formatter.print(chord.title, fingerings, opts)
     end
     
+    # Method for printing a single fingering using Fingering#fid,
+    # which contains also the tuning/fretboard used.
+    # Doesn't handle big max_fret_distances right.
+    def self.print_fingering_by_fid(fid, opts={}, formatter_class=TextFormatter)
+      fingering_part = fid.split(/[efgabhcds]/).last
+      raise "Invalid fingering" if fingering_part.nil?
+      tuning_part = fid.sub(fingering_part, '')
+      
+      fretboard = Fretboard.new_by_string(tuning_part, 50, formatter_class)
+      over_tens = fingering_part.size - fretboard.open_notes.size
+      
+      i=0
+      positions = []
+      
+      while i < fingering_part.size
+        fp = fingering_part[i,1]
+        fp == 'x' ? pos = nil : pos = fp.to_i
+        if over_tens > 0 and pos and pos < 4
+          over_tens -= 1
+          i += 2
+          pos = "#{pos}#{fingering_part[i+1,1]}".to_i
+        else
+          i += 1
+        end
+        positions << pos
+      end
+      fretboard.formatter.print('', [Fingering.new(fretboard, positions)], opts)
+    end
+    
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: chords
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 13
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 2
-  version: 0.3.2
+  - 4
+  - 1
+  version: 0.4.1
 platform: ruby
 authors: 
 - Antti Hakala
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-23 00:00:00 +03:00
+date: 2010-08-10 00:00:00 +03:00
 default_executable: 
 dependencies: []