wtf_chord 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cec796fdac73df072faef8d89c98f6fc37aded7f
-  data.tar.gz: 17772eb9d7105e1445ff40e6873c37d12914cca7
+  metadata.gz: 42f6e0b2d54785364d40dfc28d48ac718a62feb3
+  data.tar.gz: 4747da8acf163bdeea61e0ab1902f6bf6d812445
 SHA512:
-  metadata.gz: 945c5110c7e52340a4eca72385710d9cfa031cb647c2a2f8ae8207af7179467f3dc72059dc42bcf8b64083d0338644f018f85f5be551d53e4b722d3cd76f5e63
-  data.tar.gz: ba92873418bb4224f7dbf841501b02694c2fda562ea86030b4c918364b004c74b8f9d3bca6eb38168aeaf939934829ddc6186b44d09d79bc2daa86e01143a89e
+  metadata.gz: f34f794282e89a4f924c04bf74ea234b4e484bd95a4f78e583dae57e27133775a86fd8fa817928c702fadafedd31fa2a8805ce78c7e47ff56958afbaa75108a0
+  data.tar.gz: 6fdf726a6bb8e8f2ad2446b40347f28a2e47692944fc879ed35b80366650bc770eedfa6a9c29a6a846e74ada7a505a6ffc944e5cc0769c9574688fc153fd0339

data/README.md

@@ -1,8 +1,13 @@
-# WTFChord
+# WTF Chord?
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/wtf_chord`. To experiment with that code, run `bin/console` for an interactive prompt.
+‘WTF Chord?’ is the Ruby guitar chords generator library & cli tool, which also contains some abstraction for musical mathematics. Chords generator is a common but a not only mission, the library is ready for extending for generating scales.
 
-TODO: Delete this and the text above, and describe your gem
+Some features:
+
+* Tones math methods.
+* Finding chords by names with many variants of fingering.
+* CLI tool `wtfchord` to quickly find chord and draw it's fingerings to your terminal.
+* Extendable rules (pending).
 
 ## Installation
 
@@ -20,9 +25,35 @@ Or install it yourself as:
 
     $ gem install wtf_chord
 
-## Usage
+## CLI-tool usage
+
+For example, to print two fingering variants of the `Dm` chord, just run:
+
+    $ wtfchord Dm 2
 
-    $ wtfchord F#dim
+And you'll get the visual presentation of chords' fingerings:
+
+    [ ×  ×  0  2  3  1 ]
+     ––––––––––––––––––
+      |  |  |  |  |  •
+      |  |  |  •  |  |
+      |  |  |  |  •  |
+      |  |  |  |  |  |
+      |  |  |  |  |  |
+      |  |  |  |  |  |
+     ––––––––––––––––––
+            D  A  D  F
+
+    [ ×  5  7  7  6  5 ]
+     ––––––––––––––––––
+      |  •  |  |  |  •    V
+      |  |  |  |  •  |
+      |  |  •  •  |  |
+      |  |  |  |  |  |
+      |  |  |  |  |  |
+      |  |  |  |  |  |
+     ––––––––––––––––––
+         D  A  D  F  A
 
 ## Development
 
@@ -32,5 +63,4 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/wtf_chord.
-
+Bug reports and pull requests are welcome on GitHub at https://github.com/estum/wtf_chord.

data/exe/wtfchord

@@ -5,4 +5,7 @@ $:.unshift File.expand_path('../../lib', __FILE__)
 require 'rubygems' unless Object.const_defined?(:Gem)
 require "wtf_chord"
 
-WTFChord.chord(ARGV[0]).draw_fingerings(ARGV[1]&.to_i || 3)
+chord = WTFChord.chord(ARGV[0])
+
+puts chord.inspect, nil
+chord.draw_fingerings(ARGV[1]&.to_i || 3)

data/lib/wtf_chord/chord.rb

@@ -1,3 +1,5 @@
+require 'wtf_chord/fingering'
+
 module WTFChord
   class Chord
     MAX_DIST = 5
@@ -19,32 +21,23 @@ module WTFChord
     def fingerings(limit = 3)
       list = []
       (0..MAX_FRET).each do |from_fret|
-        fingering = get_fingering(from_fret)
-
-        next if list.include?(fingering)
-
-        if all_notes?(fingering.used_strings)
-          list << fingering
-        end
+        f = get_fingering(from_fret)
+        next if list.include?(f)
+        list << f if all_notes?(f.used_strings)
       end
 
       list.sort_by!(&:complexity)[0...limit].sort_by!(&:min_fret)
     end
 
-    def draw_fingerings(limit = 3)
-      puts (fingerings(limit).map(&:draw) * "\n\n")
-    end
-
     def get_fingering(from_fret = 0)
-      GUITAR.dup.tap do |guitar|
-        guitar.strings.each do |s|
-          fret = (from_fret..(from_fret+MAX_DIST)).detect { |dist| @notes.include?((s.original + dist).note) }
+      to_fret = from_fret + MAX_DIST
+      Fingering.new(GUITAR) do |f|
+        f.strings.each do |s|
+          fret = (from_fret..to_fret).detect { |dist| @notes.include?((s.original + dist).note) }
           fret ? s.hold_on(fret) : s.dead
         end
 
-        while guitar.used_strings[0] && guitar.used_strings[0].note != @notes[0]
-          guitar.used_strings.detect { |x| !x.dead? && x.note != @notes[0] }&.dead
-        end
+        adjust_fingering(f.used_strings[0], to_fret, 0) while should_adjust?(f.used_strings[0], 0)
       end
     end
 
@@ -52,5 +45,22 @@ module WTFChord
       snotes = strings.map(&:note).tap(&:uniq!)
       @notes.all? { |n| snotes.include?(n) }
     end
+
+    def adjust_fingering(string, to_fret, i = 0)
+      while string.fret < to_fret.pred
+        string.hold_on(string.fret + 1)
+        break if @notes.include?(string.note)
+      end
+
+      string.dead if !string.dead? && string.note != @notes[i]
+    end
+
+    def should_adjust?(string, i = 0)
+      string && string.note != @notes[i]
+    end
+
+    def draw_fingerings(limit = 3)
+      puts (fingerings(limit).map(&:draw) * "\n\n")
+    end
   end
 end

data/lib/wtf_chord/complexity_counter.rb

@@ -0,0 +1,41 @@
+module WTFChord
+  class ComplexityCounter
+    def initialize(fingering)
+      @fingering = fingering
+    end
+
+    def rate
+      frets = @fingering.holded_strings.map(&:fret)
+      barre = frets.uniq.keep_if { |o| frets.count(o) > 3 }.max
+      barre_strings = barre ? frets.count(barre).pred : 0
+
+      base_rate = (
+        Rational(holded_strings - barre_strings, total_strings) +
+        Rational(finger_dist(frets), 5)
+      ).to_f
+
+      base_rate += 1 if complex_barre?(barre, frets)
+
+      base_rate
+    end
+
+    private
+
+    def holded_strings
+      @fingering.strings.count(&:holded?)
+    end
+
+    def total_strings
+      @fingering.strings.size
+    end
+
+    def finger_dist(frets)
+      (frets.max - frets.min).nonzero? || 1
+    end
+
+    def complex_barre?(barre, frets)
+      return false unless barre
+      barre > frets.min
+    end
+  end
+end

data/lib/wtf_chord/fingering.rb

@@ -0,0 +1,51 @@
+require 'wtf_chord/fretboard'
+require 'wtf_chord/complexity_counter'
+require 'wtf_chord/drawer'
+
+module WTFChord
+  class Fingering < Fretboard
+    def initialize(guitar)
+      @capo      = guitar.capo
+      @strings   = guitar.strings.map(&:dup)
+      yield(self) if block_given?
+    end
+
+    def code
+      @code ||= strings.map(&:code).pack("c*")
+    end
+
+    def == other
+      other.is_a?(Fingering) ? other.code == code : super
+    end
+
+    def complexity
+      complexity_counter.rate
+    end
+
+    def draw
+      Drawer.new(self).draw
+    end
+
+    def set_fingers(fingers)
+      fingers.each_with_index { |f, i| f.nil? ? @strings[i].dead : @strings[i].hold_on(f) }
+    end
+
+    def holded_strings
+      @strings.select(&:holded?)
+    end
+
+    def used_strings
+      @strings.reject(&:dead?)
+    end
+
+    def min_fret
+      holded_strings.min.fret
+    end
+
+    private
+
+    def complexity_counter
+      @complexity_counter ||= ComplexityCounter.new(self)
+    end
+  end
+end

data/lib/wtf_chord/fretboard.rb

@@ -0,0 +1,36 @@
+require 'wtf_chord/guitar_string'
+
+module WTFChord
+  class Fretboard
+    DEAD = "×".freeze
+
+    attr_reader :strings, :capo
+
+    def initialize(*strings)
+      @capo    = 0
+      @strings = strings.map! { |string| GuitarString.new(string, @capo) }
+    end
+
+    def [] idx
+      case idx
+      when 1..@strings.length then @strings[-idx]
+      end
+    end
+
+    def set_capo(capo = 0)
+      @capo = capo
+      @strings.each { |string| string.set_capo(@capo) }
+      self
+    end
+
+    def fingers
+      @strings.map { |string| string.dead? ? DEAD : string.fret  }
+    end
+
+    def to_s
+      "[ #{fingers * " "} ]"
+    end
+
+    alias :inspect :to_s
+  end
+end

data/lib/wtf_chord/guitar_string.rb

@@ -48,6 +48,14 @@ module WTFChord
       dead? ? -1 : to_i
     end
 
+    def <=> other
+      return if dead?
+      case other
+      when Integer      then @fret <=> other
+      when GuitarString then @fret <=> other.fret
+      end
+    end
+
     private
 
     def calculate_note!

data/lib/wtf_chord/scale.rb

@@ -1,6 +1,6 @@
 require 'wtf_chord/note'
 require 'wtf_chord/pitch'
-require 'wtf_chord/fingerboard'
+require 'wtf_chord/fretboard'
 
 module WTFChord
   class ScaleArray < Array
@@ -63,5 +63,5 @@ module WTFChord
     ScaleArray.build(*chromatic_scale).freeze
   end
 
-  GUITAR ||= Fingerboard.new(*%w(E2 A2 D3 G3 B3 E4))
+  GUITAR ||= Fretboard.new(*%w(E2 A2 D3 G3 B3 E4))
 end

data/lib/wtf_chord/version.rb

@@ -1,3 +1,3 @@
 module WTFChord
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/wtf_chord.gemspec

@@ -1,6 +1,8 @@
 # coding: utf-8
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
 require 'wtf_chord/version'
 
 Gem::Specification.new do |spec|
@@ -9,8 +11,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Anton"]
   spec.email         = ["anton.estum@gmail.com"]
 
-  spec.summary       = %q{WTF Chord? is a Ruby Gem for generating guitar chords.}
-  spec.description   = %q{WTF Chord? provides the library and CLI-tool for generating guitar chords.}
+  spec.summary       = %q{‘WTF Chord?’ is the Ruby guitar chords generator library.}
+  spec.description   = %q{‘WTF Chord?’ is the Ruby guitar chords generator library.}
   spec.homepage      = "https://github.com/estum/wtf_chord"
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wtf_chord
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Anton
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-03-29 00:00:00.000000000 Z
+date: 2016-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -70,7 +70,7 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '4'
-description: WTF Chord? provides the library and CLI-tool for generating guitar chords.
+description: "‘WTF Chord?’ is the Ruby guitar chords generator library."
 email:
 - anton.estum@gmail.com
 executables:
@@ -90,8 +90,10 @@ files:
 - lib/wtf_chord.rb
 - lib/wtf_chord.yml
 - lib/wtf_chord/chord.rb
+- lib/wtf_chord/complexity_counter.rb
 - lib/wtf_chord/drawer.rb
-- lib/wtf_chord/fingerboard.rb
+- lib/wtf_chord/fingering.rb
+- lib/wtf_chord/fretboard.rb
 - lib/wtf_chord/guitar_string.rb
 - lib/wtf_chord/note.rb
 - lib/wtf_chord/pitch.rb
@@ -121,6 +123,6 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: WTF Chord? is a Ruby Gem for generating guitar chords.
+summary: "‘WTF Chord?’ is the Ruby guitar chords generator library."
 test_files: []
 has_rdoc: 

data/lib/wtf_chord/fingerboard.rb

@@ -1,102 +0,0 @@
-require 'wtf_chord/guitar_string'
-require 'wtf_chord/drawer'
-
-module WTFChord
-  class Fingerboard
-    attr_reader :strings, :capo
-
-    def initialize(*strings)
-      @capo    = 0
-      @strings = strings.map! do |string|
-        GuitarString.new(string, @capo)
-      end
-    end
-
-    def [] idx
-      case idx
-      when 1..@strings.length then @strings[-idx]
-      end
-    end
-
-    def set_capo(capo = 0)
-      @capo = capo
-      @strings.each do |string|
-        string.set_capo(@capo)
-      end
-      self
-    end
-
-    def fingers
-      strings.map { |string| string.dead? ? "×" : string.fret  }
-    end
-
-    def to_s
-      "[ #{fingers * " "} ]"
-    end
-
-    def initialize_dup(other)
-      super
-      @strings = other.strings.map(&:dup)
-      @code = nil
-      @complexity = nil
-    end
-
-    def set_fingers(fingers)
-      fingers.each_with_index do |f, i|
-        f.nil? ? @strings[i].dead : @strings[i].hold_on(f)
-      end
-    end
-
-    def with_fingers(*fingers)
-      strings_was = @strings.dup
-      set_fingers(fingers)
-      yield(self)
-      self
-    ensure
-      @strings = strings_was
-    end
-
-    def draw
-      Drawer.new(self).draw
-    end
-
-    def count_holded_strings
-      strings.count(&:holded?)
-    end
-
-    def holded_strings
-      strings.select(&:holded?)
-    end
-
-    def used_strings
-      strings.reject(&:dead?)
-    end
-
-    def inspect
-      to_s
-    end
-
-    def code
-      @code ||= strings.map(&:code).pack("c*")
-    end
-
-    def complexity
-      @complexity ||= count_holded_strings * finger_dist
-    end
-
-    def finger_dist
-      frets = holded_strings.map(&:fret)
-      ((frets.max - frets.min).nonzero? || 1)
-    end
-
-    def min_fret
-      holded_strings.map(&:fret).min
-    end
-
-    def == other
-      case other
-      when Fingerboard then other.code == code
-      end
-    end
-  end
-end