chordy 0.7.1

data/lib/b_chords.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+require 'chord'
+
+class B < Chord
+  def play_major
+    [2, 2, 4, 4, 4, 2]
+  end
+
+  def play_minor
+    [2, 2, 4, 4, 3, 2]
+  end
+
+  def play_dominant_7
+    [2, 2, 4, 2, 4, 2]
+  end
+
+  def play_dominant_7_5
+    [-1, 2, 1, 2, 0, 1]
+  end
+
+  def play_major_6
+    [2, 2, 4, 4, 4, 4]
+  end
+
+  def play_major_7
+    [2, 2, 4, 3, 4, 2]
+  end
+
+  def play_major_9
+    [-1, 2, 1, 2, 2, 2]
+  end
+
+  def play_minor_6
+    [-1, 2, 0, 1, 3, 2]
+  end
+
+  def play_minor_7
+    [-1, 2, 0, 2, 0, 2]
+  end
+
+  def play_half_diminished_7
+    [1, 0, 0, 2, 0, 1]
+  end
+
+  def play_minor_major_7
+    [2, 2, 4, 3, 3, 2]
+  end
+
+  def play_augmented_5
+    [3, -1, 5, 4, 4, 3]
+  end
+
+  def play_augmented_7
+    [-1, 2, 1, 2, 0, 3]
+  end
+
+  def play_augmented_major_7
+    [-1, 2, -1, 3, 4, 3]
+  end
+
+  def play_diminished_5
+    [1, -1, 3, 4, 3, 1]
+  end
+
+  def play_diminished_7
+    [-1, -1, 0, 1, 0, 1]
+  end
+
+  def play_diminished_9
+    [-1, 2, 1, 2, 1, 2]
+  end
+
+  def play_suspended_4
+    [2, 2, 4, 4, 5, 2]
+  end
+
+  def play_suspended_7
+    [2, 2, 2, 2, 5, 2]
+  end
+end

data/lib/c_chords.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+require 'chord'
+
+class C < Chord
+  def play_major
+    [3, 3, 2, 0, 1, 0]
+  end
+
+  def play_minor
+    [-1, 3, 1, 0, 4, 3]
+  end
+
+  def play_dominant_7
+    [0, 3, 2, 3, 1, 0]
+  end
+
+  def play_dominant_7_5
+    [-1, 1, 2, 3, 1, 2]
+  end
+
+  def play_major_6
+    [0, 3, 2, 1, 1, 0]
+  end
+
+  def play_major_7
+    [0, 3, 2, 0, 0, 0]
+  end
+
+  def play_major_9
+    [0, 3, 2, 3, 3, 0]
+  end
+
+  def play_minor_6
+    [-1, 3, 1, 2, 1, 3]
+  end
+
+  def play_minor_7
+    [-1, 1, 1, 3, 1, 3]
+  end
+
+  def play_half_diminished_7
+    [-1, 1, 1, 3, 1, 2]
+  end
+
+  def play_minor_major_7
+    [-1, 2, 1, 0, 0, 3]
+  end
+
+  def play_augmented_5
+    [0, 3, 2, 1, 1, 0]
+  end
+
+  def play_augmented_7
+    [-1, 1, 2, 3, 1, 4]
+  end
+
+  def play_augmented_major_7
+    [0, 3, 2, 1, 0, 0]
+  end
+
+  def play_diminished_5
+    [-1, -1, 4, 5, 4, 2]
+  end
+
+  def play_diminished_7
+    [-1, -1, 1, 2, 1, 2]
+  end
+
+  def play_diminished_9
+    [-1, 3, 2, 3, 2, 3]
+  end
+
+  def play_suspended_4
+    [3, 3, 3, 0, 1, 1]
+  end
+
+  def play_suspended_7
+    [1, 1, 3, 3, 1, 1]
+  end
+end

data/lib/c_sharp_chords.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+require 'chord'
+
+class CSharp < Chord
+  def play_major
+    [1, 4, 3, 1, 2, 1]
+  end
+
+  def play_minor
+    [0, -1, 2, 1, 2, 4]
+  end
+
+  def play_dominant_7
+    [1, 2, 3, 1, 2, 1]
+  end
+
+  def play_dominant_7_5
+    [-1, 2, 3, 4, 2, 3]
+  end
+  
+  def play_major_6
+    [1, 1, 3, 1, 2, 1]
+  end
+
+  def play_major_7
+    [1, 4, 3, 1, 1, 1]
+  end
+
+  def play_major_9
+    [1, 2, 1, 1, 2, 1]
+  end
+
+  def play_minor_6
+    [0, 4, 2, 3, 2, 4]
+  end
+
+  def play_minor_7
+    [0, 2, 2, 4, 2, 4]
+  end
+  
+  def play_half_diminished_7
+    [0, 2, 2, 4, 2, 3]
+  end
+
+  def play_minor_major_7
+    [0, 3, 2, 1, 1, 4]
+  end
+
+  def play_augmented_5
+    [-1, 0, 3, 2, 2, 1]
+  end
+
+  def play_augmented_7
+    [-1, 2, 3, 4, 2, 5]
+  end
+  
+  def play_augmented_major_7
+    [1, 4, 3, 2, 1, 1]
+  end
+
+  def play_diminished_5
+    [0, -1, 2, 0, 2, 3]
+  end
+
+  def play_diminished_7
+    [-1, -1, 2, 3, 2, 3]
+  end
+
+  def play_diminished_9
+    [-1, 4, 3, 4, 3, 4]
+  end
+
+  def play_suspended_4
+    [4, 4, 6, 6, 7, 4]
+  end
+
+  def play_suspended_7
+    [2, 2, 4, 4, 2, 2]
+  end
+end
+
+DFlat = CSharp

data/lib/chord.rb

@@ -0,0 +1,193 @@
+# encoding: utf-8
+
+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
+  
+  def self.start_of_strings tuning, start_delimiter
+    num_strings = tuning.length
+    (0...num_strings).map { |s| tuning[s].rjust(2) + start_delimiter.rjust(2) } + [ " " * 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 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 print_string_at i, chord_space
+    to_print = chord_space
+    string = @strings[i]
+    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 i, 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}
+    private 
+    def #{name}()
+      add_flag #{name.upcase}
+    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

data/lib/chordy.rb

@@ -0,0 +1,287 @@
+# 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
+
+module Chordy
+  $line_length = 8
+  $separator_length = 40
+  $chords = []
+  $auto = true
+  $tuning = tuning_6_standard.map { |e| e.capitalize  }
+  $reverse = false
+
+  # printing delimiters
+  $chord_space = "-"
+  $half_length_delimiter = "|"
+  $start_delimiter = "["
+  $end_delimiter = "]"
+
+  def auto a=true
+    $auto = if a then true else false end
+  end
+
+  def no_auto
+    auto false
+  end
+
+  def line_length a
+    if a.instance_of? Fixnum
+      $line_length = a
+      do_print
+    else
+      puts "Invalid length"
+    end
+  end
+
+  def clear
+    $chords = []
+    do_print
+  end
+
+  # TODO document + examples
+
+  def set_tuning_with_padding 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 }
+  end
+
+  def tune new_tuning
+    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
+        to_do_print = true
+      else
+        puts "Invalid tuning; only " + strings.join(",") + " strings are allowed" 
+      end
+    else
+      if is_tuning? new_tuning.to_s
+        new_tuning = eval("#{new_tuning}")
+        set_tuning_with_padding new_tuning
+        to_do_print = true
+      else
+        puts "Unknown or invalid tuning"
+      end
+    end
+
+    if to_do_print
+      do_print
+    end
+  end
+
+  def check_sharp_or_flat_chord chord_name
+    chord = chord_name.capitalize
+    sharp_re = /!$/
+    flat_re = /_$/
+
+    if sharp_re =~ chord
+      chord = chord.gsub(sharp_re, "Sharp")
+    elsif flat_re =~ chord
+      chord = chord.gsub(flat_re, "Flat")
+    end
+
+    chord
+  end
+
+  def check_chord_class chord_name
+    eval("defined?(#{chord_name}) == 'constant' and #{chord_name}.class == Class")
+  end
+
+  def play chords, chord_type=:major
+    chord = nil
+    begin
+      if chords.instance_of? Array
+        chord = Chord.new(chords, $tuning.length)
+      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 = eval(chord_init)
+      end
+
+      $chords.push chord
+      do_print
+    rescue NameError => ne
+      puts "Unknown chord or chord type"
+      puts ne.message
+    rescue Exception => e
+      puts e.class.to_s
+      puts e.message
+    end
+
+    chord
+  end
+
+  def text text
+    $chords.push Text.new(text)
+    do_print
+  end
+
+  def section title=""
+    $chords.push Section.new(title, $separator_length)
+    do_print
+  end
+
+  def separator 
+    section
+  end
+
+  def do_print
+    if $auto
+      print_chords
+    end
+  end
+
+  def print_chords
+    lines_to_print = []
+    chord_index = 0
+    chords_in_section = 0
+    tuning_length = $tuning.length
+    is_done = false
+    is_new_line = true
+    is_even_line_length = ($line_length % 2) == 0
+    is_next_chord_section_or_text = false
+    to_print_start_chords = false
+    to_skip_end_strings = false
+
+    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
+          start_strings.each { |s| lines_to_print.push s }
+        end
+        to_print_start_chords = false
+        is_new_line = false
+      end
+
+      last_chord_lines = lines_to_print.last(tuning_length + 1)
+      curr_chord = $chords[chord_index]
+      if curr_chord.is_a? Chord
+        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)
+          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
+        to_skip_end_strings = true
+        chords_in_section = 0
+        
+        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)
+        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 to_skip_end_strings
+          to_skip_end_strings = false
+        else
+          end_strings = Chord.end_of_strings $tuning, $end_delimiter
+          last_chord_lines.each_with_index do |line, i|
+            line << end_strings[i]
+          end
+        end
+
+        # 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
+        last_chord_lines.each_with_index do |line, i| 
+          line << Chord.print_half_length_string_at(i, $tuning, $half_length_delimiter, $chord_space)
+        end
+      end
+      
+      if is_next_chord_section_or_text
+        is_new_line = false
+      end
+
+      if chord_index >= $chords.length
+        is_done = true
+      end
+    end
+
+    # print the buffer
+    lines_to_print.each { |l| puts l }
+    nil
+  end
+
+  Chord::CHORD_FLAGS.each_with_index do |name,i|
+    eval <<-ENDOFEVAL
+    def #{name}
+      saved_auto = $auto
+      saved_chord_index = $chords.length
+      $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} }
+      rescue Exception => e
+        puts e.class.to_s
+        puts e.message
+      end
+
+      $auto = saved_auto
+      do_print
+      chord
+    end
+    ENDOFEVAL
+
+    if name != "dont_play"
+      eval <<-ENDOFEVAL
+      def play_#{name} chords, chord_type=:major
+        #{name} { play chords, chord_type }
+      end
+      ENDOFEVAL
+    end
+  end
+
+  Chord.short_chords.values.each do |s|
+    short_chord_name = s.to_s
+    eval <<-ENDOFEVAL
+      def #{short_chord_name}
+        :#{s}
+      end
+      ENDOFEVAL
+  end
+end
+
+include Chordy