chordy 0.7.1 → 0.7.2

data/Rakefile

@@ -2,6 +2,7 @@
 
 require 'rubygems'
 require 'bundler'
+
 begin
   Bundler.setup(:default, :development)
 rescue Bundler::BundlerError => e
@@ -9,6 +10,14 @@ rescue Bundler::BundlerError => e
   $stderr.puts "Run `bundle install` to install missing gems"
   exit e.status_code
 end
+
+if !File.exist?('VERSION')
+  $stderr.puts "Could not find VERSION file"
+  exit 1
+end
+
+VERSION = File.read('VERSION').gsub(/\n/, '')
+
 require 'rake/dsl_definition'
 require 'rake'
 
@@ -16,11 +25,11 @@ require 'jeweler'
 Jeweler::Tasks.new do |gem|
   gem.name = "chordy"
   gem.rubyforge_project = "chordy"
-  gem.version = "0.7.1"
+  gem.version = VERSION
   gem.homepage = "http://github.com/darth10/chordy"
   gem.license = "MIT"
   gem.summary = %Q{DSL for guitar chords}
-  gem.description = %Q{Chordy is a DSL written in Ruby to print guitar chords diagrams}
+  gem.description = %Q{A Ruby DSL for printing guitar chords diagrams}
   gem.email = "akhil.wali.10@gmail.com"
   gem.authors = ["Akhil Wali"]
 end
@@ -37,10 +46,8 @@ task :default => [:test, :build]
 
 require 'rdoc/task'
 Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "chordy #{version}"
+  rdoc.title = "chordy #{VERSION}"
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('LICENSE.rdoc')
   rdoc.rdoc_files.include('lib/**/*.rb')

data/VERSION

@@ -0,0 +1 @@
+0.7.2

data/lib/chordy.rb

@@ -1,51 +1,56 @@
 # encoding: utf-8
 
-require 'chord'
-
-require 'c_chords'
-require 'c_sharp_chords'
-require 'd_chords'
-require 'd_sharp_chords'
-require 'e_chords'
-require 'f_chords'
-require 'f_sharp_chords'
-require 'g_chords'
-require 'g_sharp_chords'
-require 'a_chords'
-require 'a_sharp_chords'
-require 'b_chords'
-
-require 'text'
-require 'section'
-
-require 'tuning'
-include Tuning
+includes = ['chords', 'util']
+
+include_dirs = includes.map { |dir| "chordy/#{dir}/" }
+include_dirs.each do |dir|
+  Dir[File.join(File.dirname(__FILE__), dir + '**.rb')].each do |file|
+    require file
+  end
+end
 
 module Chordy
-  $line_length = 8
-  $separator_length = 40
-  $chords = []
-  $auto = true
-  $tuning = tuning_6_standard.map { |e| e.capitalize  }
-  $reverse = false
+  extend self, Util, Util::Tuning
 
-  # printing delimiters
-  $chord_space = "-"
-  $half_length_delimiter = "|"
-  $start_delimiter = "["
-  $end_delimiter = "]"
+  attr_accessor :chords, :line_length, :separator_length, :tuning, :auto, :low_to_high
+  attr_accessor :chord_space, :half_length_delimiter, :start_delimiter, :end_delimiter
+
+  @line_length = 8
+  @separator_length = 40
+  @chords = []
+  @auto = true
+  @tuning = tuning_6_standard
+  @low_to_high = false
 
-  def auto a=true
-    $auto = if a then true else false end
+  # printing delimiters
+  @chord_space = "-"
+  @half_length_delimiter = "|"
+  @start_delimiter = "["
+  @end_delimiter = "]"
+
+  def do_auto a=true
+    Chordy.auto = a
+    Chordy.auto
   end
 
   def no_auto
-    auto false
+    Chordy.auto = false
+    Chordy.auto
   end
 
-  def line_length a
+  def do_low_to_high
+    Chordy.low_to_high = true
+    do_print
+  end
+
+  def do_high_to_low
+    Chordy.low_to_high = false
+    do_print
+  end
+
+  def set_line_length a
     if a.instance_of? Fixnum
-      $line_length = a
+      Chordy.line_length = a
       do_print
     else
       puts "Invalid length"
@@ -53,26 +58,30 @@ module Chordy
   end
 
   def clear
-    $chords = []
+    Chordy.chords = []
     do_print
   end
 
   # TODO document + examples
 
-  def set_tuning_with_padding tuning
+  def set_chords_to_tuning tuning
     longest_tuning_str_length = tuning.max.length
-    $tuning = tuning.map { |e| e.capitalize.rjust(longest_tuning_str_length) }
-    
-    $chords = $chords.each { |e| e.pad_or_trim $tuning.length, true }
+    Chordy.tuning = tuning.map { |e| e.rjust(longest_tuning_str_length) }
+
+    Chordy.chords.select { |c| c.is_a? Chord } .each { |e| e.pad_or_trim Chordy.tuning.length, true }
   end
 
-  def tune new_tuning
+  def tune new_tuning, direction=:low_to_high
     to_do_print = false
     strings = [6, 7, 8]
 
     if new_tuning.is_a? Array
       if strings.include? new_tuning.length
-        set_tuning_with_padding new_tuning
+        if direction == :high_to_low
+          new_tuning = new_tuning.reverse
+        end
+
+        set_chords_to_tuning new_tuning
         to_do_print = true
       else
         puts "Invalid tuning; only " + strings.join(",") + " strings are allowed" 
@@ -80,7 +89,7 @@ module Chordy
     else
       if is_tuning? new_tuning.to_s
         new_tuning = eval("#{new_tuning}")
-        set_tuning_with_padding new_tuning
+        set_chords_to_tuning new_tuning
         to_do_print = true
       else
         puts "Unknown or invalid tuning"
@@ -110,41 +119,48 @@ module Chordy
     eval("defined?(#{chord_name}) == 'constant' and #{chord_name}.class == Class")
   end
 
-  def play chords, chord_type=:major
+  def play chords, chord_type_or_direction=:major
     chord = nil
     begin
       if chords.instance_of? Array
-        chord = Chord.new(chords, $tuning.length)
+        chord = Chord.new(chords, Chordy.tuning.length)
+
+        # play high-to-low, unless :low_to_high is specified
+        if chord_type_or_direction != :low_to_high
+          chord.reverse_strings!
+        end
       else
         chord_name = chords.to_s
         if !check_chord_class chord_name
           chord_name = check_sharp_or_flat_chord chord_name
         end
 
-        chord_init = "#{chord_name}.new :#{chord_type}, #{$tuning.length}"
+        chord_init = "#{chord_name}.new :#{chord_type_or_direction}, #{Chordy.tuning.length}"
         chord = eval(chord_init)
       end
 
-      $chords.push chord
+      Chordy.chords.push chord
       do_print
     rescue NameError => ne
       puts "Unknown chord or chord type"
       puts ne.message
+      puts ne.backtrace
     rescue Exception => e
       puts e.class.to_s
       puts e.message
+      puts e.backtrace
     end
 
     chord
   end
 
   def text text
-    $chords.push Text.new(text)
+    Chordy.chords.push Util::Text.new(text)
     do_print
   end
 
   def section title=""
-    $chords.push Section.new(title, $separator_length)
+    Chordy.chords.push Util::Section.new(title, Chordy.separator_length)
     do_print
   end
 
@@ -153,7 +169,7 @@ module Chordy
   end
 
   def do_print
-    if $auto
+    if Chordy.auto
       print_chords
     end
   end
@@ -162,18 +178,22 @@ module Chordy
     lines_to_print = []
     chord_index = 0
     chords_in_section = 0
-    tuning_length = $tuning.length
+    tuning_length = Chordy.tuning.length
     is_done = false
     is_new_line = true
-    is_even_line_length = ($line_length % 2) == 0
+    is_even_line_length = (Chordy.line_length % 2) == 0
     is_next_chord_section_or_text = false
     to_print_start_chords = false
     to_skip_end_strings = false
 
+    chords = Chordy.chords.to_a
+    chords.select { |c| c.is_a? Util::Section } .map { |s| s.separator_length = Chordy.separator_length }
+
     while !is_done
       if is_new_line or to_print_start_chords
-        if $chords[chord_index].is_a? Chord
-          start_strings = Chord.start_of_strings $tuning, $start_delimiter
+        if chords[chord_index].is_a? Chord
+          start_strings = Chord.start_of_strings Chordy.tuning, Chordy.start_delimiter, Chordy.low_to_high
+
           start_strings.each { |s| lines_to_print.push s }
         end
         to_print_start_chords = false
@@ -181,40 +201,40 @@ module Chordy
       end
 
       last_chord_lines = lines_to_print.last(tuning_length + 1)
-      curr_chord = $chords[chord_index]
+      curr_chord = chords[chord_index]
       if curr_chord.is_a? Chord
-        last_chord_lines.each_with_index do |line,i|
+        last_chord_lines.each_with_index do |line, i|
           if i == tuning_length
             line << curr_chord.print_flag
           else
-            line << curr_chord.print_string_at(i, $chord_space)
+            line << curr_chord.print_string_at(i, Chordy.chord_space, Chordy.low_to_high)
           end
         end
         
         chords_in_section = chords_in_section + 1
         to_skip_end_strings = false
-      elsif ($chords[chord_index].is_a? Text) or ($chords[chord_index].is_a? Section)
-        lines_to_print.push $chords[chord_index].to_s
+      elsif (chords[chord_index].is_a? Util::Text) or (chords[chord_index].is_a? Util::Section)
+        lines_to_print.push chords[chord_index].to_s
         to_skip_end_strings = true
         chords_in_section = 0
         
-        if $chords[chord_index + 1].is_a? Chord
+        if chords[chord_index + 1].is_a? Chord
           to_print_start_chords = true
         end
       end
 
       chord_index = chord_index + 1
-      if ($chords[chord_index].is_a? Text) or ($chords[chord_index].is_a? Section)
+      if (chords[chord_index].is_a? Util::Text) or (chords[chord_index].is_a? Util::Section)
         is_next_chord_section_or_text = true
       else
         is_next_chord_section_or_text = false
       end
       
-      if ((chords_in_section % $line_length) == 0) or (chord_index == $chords.length) or is_next_chord_section_or_text
+      if ((chords_in_section % Chordy.line_length) == 0) or (chord_index == chords.length) or is_next_chord_section_or_text
         if to_skip_end_strings
           to_skip_end_strings = false
         else
-          end_strings = Chord.end_of_strings $tuning, $end_delimiter
+          end_strings = Chord.end_of_strings Chordy.tuning, Chordy.end_delimiter
           last_chord_lines.each_with_index do |line, i|
             line << end_strings[i]
           end
@@ -223,9 +243,9 @@ module Chordy
         # start the next actual line
         lines_to_print.push ""
         is_new_line = true
-      elsif (chords_in_section % $line_length) == ($line_length / 2) and is_even_line_length
+      elsif (chords_in_section % Chordy.line_length) == (Chordy.line_length / 2) and is_even_line_length
         last_chord_lines.each_with_index do |line, i| 
-          line << Chord.print_half_length_string_at(i, $tuning, $half_length_delimiter, $chord_space)
+          line << Chord.print_half_length_string_at(i, Chordy.tuning, Chordy.half_length_delimiter, Chordy.chord_space)
         end
       end
       
@@ -233,7 +253,7 @@ module Chordy
         is_new_line = false
       end
 
-      if chord_index >= $chords.length
+      if chord_index >= chords.length
         is_done = true
       end
     end
@@ -246,20 +266,21 @@ module Chordy
   Chord::CHORD_FLAGS.each_with_index do |name,i|
     eval <<-ENDOFEVAL
     def #{name}
-      saved_auto = $auto
-      saved_chord_index = $chords.length
-      $auto = false
+      saved_auto = Chordy.auto
+      saved_chord_index = Chordy.chords.length
+      Chordy.auto = false
       begin
         chord = yield if block_given?
         
-        num_new_chords = $chords.length - saved_chord_index
-        $chords.last(num_new_chords).each { |c| c.send :#{name} }
+        num_new_chords = Chordy.chords.length - saved_chord_index
+        Chordy.chords.last(num_new_chords).each { |c| c.send :#{name} }
       rescue Exception => e
         puts e.class.to_s
         puts e.message
+        puts e.backtrace
       end
 
-      $auto = saved_auto
+      Chordy.auto = saved_auto
       do_print
       chord
     end
@@ -267,8 +288,8 @@ module Chordy
 
     if name != "dont_play"
       eval <<-ENDOFEVAL
-      def play_#{name} chords, chord_type=:major
-        #{name} { play chords, chord_type }
+      def play_#{name} chords, chord_type_or_direction=:major
+        #{name} { play chords, chord_type_or_direction }
       end
       ENDOFEVAL
     end

data/lib/chordy/chord.rb

@@ -0,0 +1,228 @@
+# encoding: utf-8
+
+module Chordy
+
+  class Chord
+    CHORD_FLAGS = %w(mute harmonic bend pull hammer_down slide_down slide_up dont_play vibrato)
+
+    def self.all_flags
+      CHORD_FLAGS.to_a
+    end
+
+    # gets number of high strings in a tuning by approximation
+    def self.get_num_high_strings length
+      (length / 3.0).ceil
+    end
+    
+    def self.start_of_strings tuning, start_delimiter, low_to_high
+      num_strings = tuning.length
+      num_high_strings = get_num_high_strings num_strings
+
+      strings_in_downcase = tuning.map { |s| s.downcase }
+      high_strings = strings_in_downcase.last(num_high_strings)
+      low_strings = strings_in_downcase.first(num_strings - num_high_strings).map { |s| s.capitalize }
+
+      strings_range = low_strings + high_strings
+      if !low_to_high
+        strings_range = strings_range.reverse
+      end
+
+      strings_to_print = strings_range.map { |s| s.rjust(2) + start_delimiter.rjust(2) }
+      strings_to_print + [ " " * 4 ]
+    end
+    
+    def self.end_of_strings tuning, end_delimiter
+      num_strings = tuning.length
+      ([ end_delimiter ] * num_strings) + [ "" ]
+    end
+
+    def self.print_half_length_string_at string_pos, tuning, half_length_delimiter, chord_space
+      if string_pos == tuning.length
+        "".rjust(2)
+      else
+        half_length_delimiter.rjust(2, chord_space)
+      end
+    end
+
+    def self.short_chords
+      {
+        :M => :major,
+        :m => :minor,
+        :_7 => :dominant_7,
+        :_7_5 => :dominant_7_5,
+        :_9 => :diminished_9,
+        :M6 => :major_6,
+        :M7 => :major_7,
+        :M9 => :major_9,
+        :m5 => :diminished_5,
+        :m6 => :minor_6,
+        :m7 => :minor_7,
+        :m7_5 => :half_diminished_7,
+        :mM7 => :minor_major_7,
+        :aug5 => :augmented_5,
+        :aug7 => :augmented_7,
+        :aug7_5 => :augmented_major_7,
+        :dim => :diminished_7,
+        :dim7 => :diminished_7,
+        :dim5 => :diminished_5,
+        :dim9 => :diminished_9,
+        :sus => :suspended_4,
+        :sus4 => :suspended_4,
+        :sus7 => :suspended_7,
+      }
+    end
+    
+    def initialize chord, strings
+      @strings = [-1] * strings
+      pad_low = false
+      if chord.instance_of? String or chord.instance_of? Symbol
+        short_chords = Chord.short_chords
+        if short_chords.key? chord
+          chord_strings = play short_chords[chord]
+          @type = short_chords[chord]
+        else
+          chord_strings = play chord.to_sym
+          @type = chord.to_sym
+        end
+        pad_low = true
+      elsif chord.instance_of? Array
+        chord_strings = chord.to_a
+      end
+
+      @strings = chord_strings
+      pad_or_trim strings, pad_low
+      @flags = 0
+    end
+    
+    def pad_or_trim length, pad_low
+      if @strings.length > length
+        @strings = @strings.last length
+      elsif @strings.length < length
+        diff = length - @strings.length
+        if pad_low
+          first = @strings.first
+          min = @strings.min
+          
+          # play as bar chord
+          bar_chord_string = ((first == min) and (min > 0) and (first > 0)) ? first : -1
+          @strings = ([bar_chord_string] * diff) + @strings
+        else
+          @strings = @strings + [-1] * diff
+        end
+
+        self
+      end
+    end
+
+    def play chord_type
+      method_for_chord_type = "play_" + chord_type.to_s
+      chord = eval(method_for_chord_type)
+      chord
+    end
+
+    def reverse_strings!
+      @strings = @strings.reverse
+      self
+    end
+
+    def strings
+      @strings
+    end
+
+    def flags
+      @flags
+    end
+
+    def has_flag flag
+      (@flags & flag) == flag
+    end
+
+    def add_flag flag
+      @flags = @flags | flag
+      self
+    end
+
+    def get_index_to_print i, low_to_high
+      if low_to_high
+        i
+      else
+        @strings.length - i - 1
+      end
+    end
+
+    def print_string_at i, chord_space, low_to_high=false
+      to_print = chord_space
+      index_to_print = get_index_to_print i, low_to_high
+      string = @strings[index_to_print]
+      if string != -1
+        to_print = string.to_s
+      end
+
+      to_print = to_print.rjust(3, chord_space)
+      
+      if @flags != 0
+        to_print = print_string_with_flag_at index_to_print, to_print, chord_space
+      end
+      
+      to_print.ljust(4, chord_space)
+    end
+
+    def print_string_with_flag_at i, printed_string, chord_space
+      to_print = printed_string
+      string = @strings[i]
+
+      if string != -1
+        if has_flag DONT_PLAY
+          to_print = "x".rjust(3, chord_space)
+        elsif has_flag BEND
+          to_print = to_print + "b"
+        elsif has_flag HAMMER_DOWN
+          to_print = to_print + "h"
+        elsif has_flag PULL
+          to_print = to_print + "p"
+        elsif has_flag SLIDE_UP
+          to_print = to_print + "/"
+        elsif has_flag SLIDE_DOWN
+          to_print = to_print + "\\"
+        elsif has_flag VIBRATO
+          to_print = to_print + "~"
+        end
+      end
+
+      to_print
+    end
+
+    # for printing flags on diff line
+    def print_flag 
+      to_print = ""
+
+      if has_flag MUTE
+        to_print = "M"
+      elsif has_flag HARMONIC
+        to_print = "H"
+      end
+
+      to_print.rjust(3).ljust(4)
+    end 
+  end
+
+  Chord::CHORD_FLAGS.each_with_index do |name,i|
+    Chord.class_eval <<-ENDOFEVAL
+    #{name.upcase} = #{2**i}
+
+    def #{name}
+      add_flag #{name.upcase}
+      self
+    end
+    ENDOFEVAL
+  end
+
+  Chord.short_chords.values.each do |chord_type|
+    chord_type_str = chord_type.to_s
+    Chord.class_eval <<-ENDOFEVAL
+     def play_#{chord_type_str}
+       [-1] * 6
+     end
+     ENDOFEVAL
+  end
+end