wtf_chord 0.3 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0ffe99b5205f9a4cbde1ebdd815a41dc9f8f0836
-  data.tar.gz: d08a21cf109465b729d171e88e7a3f3631ca95df
+SHA256:
+  metadata.gz: 8d764a30038a11df351e6d3d9dfce09084aa89af352d92b36677ed5eac31e425
+  data.tar.gz: 0c713ee0f4e3b36720014f56c1c55ca6686981b49e228402d8c2f826463affce
 SHA512:
-  metadata.gz: e250bfa2ee065d20208dfca8831b33c216b2a4c2c450fecae75bef2a9b8c69189c2d6fd244dff31c25c00c38f9549d579f42b7ba6fca557509fb5a88460a2290
-  data.tar.gz: 25a18c48cecc08247ccfa78c6c396d2edd9c4481b0c86f39cf23636fb1b7bf51ba038d15b5e2fd0db8cd89c904aaf5d939cacb1a78233dcd0e7108495e1fd4cc
+  metadata.gz: e83f9de2c3913c4206d7d4f424f46f1082fcd16a50f8f19d4d78f2d83f3a66f610d23852ac66b890190f444db14e74d3fc9249514e6ece64626685c4c7434de2
+  data.tar.gz: 3ac9226adb773858a51c474c0f1b299e3bf2601ce567d9967c96b297ba4b0895da08c6b50e404221ba636be01d83740fea20b3f5684ebb24a2053b4b81235425

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+## 0.5.0 / 2016-08-17
+
+* 2 major features
+  * Support chords with bass string mods (like Am/G)
+  * Add extra_complexity modifier
+
+* 1 bug fixes:
+  * Fix fingering equality
+
+* Add CHANGELOG.md

data/README.md

@@ -31,13 +31,13 @@ Or install it yourself as:
 
     Finds fingerings of the requested chord.
 
-    v0.2.1
+    v0.3.1
 
     Options:
         -h, --help                       Show command line help
             --version                    Show help/version info
         -n, --amount N                   Amount of fingering variants to output.
-                                         (default: 3)
+                                         (default: 5)
         -o, --output FORMAT              Output format.
                                          (default: default)
         -R, --[no-]rates                 Output fingering complexity rates
@@ -57,25 +57,25 @@ For example, to print two fingering variants of the `Dm` chord, just run:
 And you'll get the visual presentation of chords' fingerings:
 
     [ ×  ×  0  2  3  1 ]
-     ––––––––––––––––––
-      |  |  |  |  |  •
-      |  |  |  •  |  |
-      |  |  |  |  •  |
+     ——————————————————
+      |  |  |  |  |  ◉
+      |  |  |  ◉  |  |
+      |  |  |  |  ◉  |
       |  |  |  |  |  |
       |  |  |  |  |  |
       |  |  |  |  |  |
-     ––––––––––––––––––
+     ——————————————————
             D  A  D  F
 
     [ ×  5  7  7  6  5 ]
-     ––––––––––––––––––
-      |  •  |  |  |  •    V
-      |  |  |  |  •  |
-      |  |  •  •  |  |
+     ——————————————————
+      |  ◉  |  |  |  ◉   ← V
+      |  |  |  |  ◉  |
+      |  |  ◉  ◉  |  |
       |  |  |  |  |  |
       |  |  |  |  |  |
       |  |  |  |  |  |
-     ––––––––––––––––––
+     ——————————————————
          D  A  D  F  A
 
 You can get simpler output, using the `--output` option:
@@ -91,6 +91,28 @@ You can get simpler output, using the `--output` option:
     [ 10 8 7 7 6 10 ]
     [ 10 8 7 7 10 10 ]
 
+Starting with 0.7.0, we have the very nice piano formatting:
+
+    $ wtfchord Fdim -n 2 --output=piano
+    F1 - G♯1 - B1
+    ┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
+    │ │ ││ │ │ │ ││█││ │ │
+    │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
+    │  │  │  │▐▌│  │  │▐▌│
+    └──┴──┴──┴──┴──┴──┴──┘
+     ↑
+     Ⅰ
+
+
+    G♯1 - B1 - F2
+    ┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┬─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
+    │ │ ││ │ │ │ ││█││ │ │ │ ││ │ │ │ ││ ││ │ │
+    │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
+    │  │  │  │  │  │  │▐▌│  │  │  │▐▌│  │  │  │
+    └──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
+     ↑                    ↑
+     Ⅰ                    Ⅱ
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment. Run `bundle exec wtf_chord` to use the gem in this directory, ignoring other installed copies of this gem.

data/lib/wtf_chord.rb

@@ -1,8 +1,13 @@
+# frozen_string_literal: true
+
 require "wtf_chord/scale"
 require "wtf_chord/rules"
 require "wtf_chord/version"
 
 module WTFChord
+  autoload :Fretboard, "wtf_chord/fretboard"
+  autoload :Keyboard, "wtf_chord/keyboard"
+
   DEFAULTS = {
     :rules_file => File.expand_path("../wtf_chord.yml", __FILE__)
   }.freeze

data/lib/wtf_chord/chord.rb

@@ -1,28 +1,62 @@
+# frozen_string_literal: true
+
 require 'wtf_chord/fingering'
-require 'wtf_chord/fingerings_generator'
+require 'wtf_chord/collectors'
 
 module WTFChord
   class Chord
-    attr_reader :pitch, :steps, :notes, :name
+    BASS_MATCH = /(?<=[\\\/])[A-H][b#]?(?=$)/
+
+    attr_reader :pitch, :steps, :notes, :name, :bass
 
     def initialize(note, name)
       @pitch = note.is_a?(Pitch) ? note : WTFChord.note(note)
-      @name  = "#{@pitch.key}#{name}".freeze
+      @name  = "#{@pitch.key}#{name}"
       @steps = Array(WTFChord.rules[name])
       @notes = @steps.map { |dist| (@pitch + dist).note }.tap(&:uniq!)
+
+      BASS_MATCH.match(@name) do |m|
+        @bass = WTFChord.note(m[0]).note
+      end
     end
 
-    def inspect
-      "#{name} (#{@notes.map(&:key) * ' - '})"
+    def fingerings(limit = nil, collector: Collectors::Guitar)
+      collector.new(self).call[0, limit || 5]
     end
 
-    def fingerings(limit = nil)
-      limit ||= 5
-      FingeringsGenerator.new(self).call[0, limit]
+    def tone
+      bass || original_bass
     end
 
     def third_tone
-      @third_tone ||= @notes[@steps.index(7) || -1]
+      @third_tone ||= @notes[@steps.size > 3 ? 2 : -1]
+    end
+
+    def bass?
+      !!@bass
+    end
+
+    def size
+      bass? ? -~@notes.size : @notes.size
+    end
+
+    def original_bass
+      @notes[0]
+    end
+
+    def === other
+      case other
+      when InstrumentPitch
+        self === other.note
+      when Note
+        notes.include?(other) || (bass? && bass == other)
+      else
+        super
+      end
+    end
+
+    def inspect
+      "#{name} (#{@notes.map(&:key) * ' - '})"
     end
   end
 end

data/lib/wtf_chord/cli.rb

@@ -7,14 +7,22 @@ module WTFChord
     include Methadone::CLILogging
 
     main do |name|
-      chord      = WTFChord.chord(name)
-      fingerings = chord.fingerings(options['amount'])
-      formatter  = WTFChord::Formatter.new(options['output'], options['rates'])
+      chord     = WTFChord.chord(name)
+      formatter = WTFChord::Formatter.new(options['output'], options['rates'])
 
       debug { "Output using formatter: #{formatter.formatter.to_s}\n" }
 
-      puts chord.inspect, nil
-      formatter.(*fingerings)
+      options['amount'] = 1 if options['output'] == 'piano1'
+
+      collector =
+        case formatter.name when 'piano', 'piano1'
+          Collectors::Piano
+        else
+          Collectors::Guitar
+        end
+
+      fingerings = chord.fingerings(options['amount'], collector: collector)
+      puts formatter[*fingerings].uniq * formatter.separator
     end
 
     version VERSION

data/lib/wtf_chord/collectors.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "wtf_chord/collectors/generic"
+
+module WTFChord
+  module Collectors
+    autoload :Guitar, "wtf_chord/collectors/guitar"
+    autoload :Piano,  "wtf_chord/collectors/piano"
+  end
+end

data/lib/wtf_chord/collectors/generic.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module WTFChord
+  class Chord
+  end
+
+  module Collectors
+    class Generic < DelegateClass(Chord)
+      singleton_class.attr_accessor :max_dist
+
+      def fingerings
+        @fingerings ||= []
+      end
+
+      def call
+        reset!
+        collect!
+      end
+
+      def reset!
+        fingerings.clear
+      end
+
+      def collect!
+        raise NotImplementedError
+      end
+
+      def max_dist
+        self.class.max_dist
+      end
+    end
+  end
+end

data/lib/wtf_chord/collectors/guitar.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module WTFChord
+  module Collectors
+    class Guitar < Generic
+      self.max_dist = 5
+
+      MAX_FRET = 7
+
+      def collect!
+        (0...MAX_FRET).each do |from|
+          to = from + max_dist
+          generate(from...to) do |variant|
+            fingerings << set_bass(variant) if filter_variant(variant)
+          end
+        end
+
+        fingerings.uniq!
+        fingerings.sort_by!(&:complexity)
+      end
+
+      private
+
+      def generate(fret_range)
+        combinations = WTFChord.guitar.strings.map.with_index do |s, index|
+          fret_range.
+            select { |dist| pitch = s.original + dist; has_note?(pitch) }.
+            tap    { |frets| frets << nil if frets.size == 0 }
+        end
+
+        combinations.inject(&:product).each do |fingers|
+          fingers.flatten!
+
+          Fingering.new(WTFChord.guitar, fingers) do |variant|
+            adjust(variant)
+            yield(variant)
+          end
+        end
+      end
+
+      def filter_variant(variant)
+        used_strings = variant.used_strings
+        used_notes = used_strings.map(&:note)
+        tones_count = notes.map { |n| used_notes.count(n) }
+
+        !fingerings.include?(variant) &&
+        basetone?(used_strings[0]) &&
+        (
+          (third?(used_strings[1]) || third?(used_strings[2])) ||
+          (last?(used_strings[1]) || last?(used_strings[2]))
+        ) &&
+        all_notes?(used_notes) &&
+        used_notes.each_cons(2).none? { |(l, r)| l == r } &&
+        tones_count.all? { |n| tones_count[0] >= n || tones_count[notes.index(third_tone)] >= n } &&
+        variant.complexity <= 2.25
+      end
+
+      def adjust(fingering)
+        while (string = fingering.used_strings[0]) && !basetone?(string)
+          string.dead if !string.dead?
+          break if fingering.used_strings.size == 4
+        end
+      end
+
+      def set_bass(variant)
+        if bass?
+          variant.find_used_string_for(original_bass) do |idx, bass_string|
+            try_set_bass_on(variant, idx) or begin
+              4.times do |i|
+                next if i == idx
+                if try_set_bass_on(variant, i)
+                  bass_string.dead
+                  break
+                end
+              end
+            end
+          end
+        end
+
+        variant
+      end
+
+      def try_set_bass_on(variant, idx)
+        bass_string = variant.strings[idx].dup
+        distance = bass_string.distance_to(bass)
+
+        if distance >= 0 && distance < 5 && (distance - variant.min_fret) > -3
+          variant.extra_complexity += 0.5 if distance < variant.min_fret
+          variant.strings[idx].hold_on(distance)
+          true
+        end
+      end
+
+      def all_notes?(used_notes)
+        notes.all? { |n| used_notes.include?(n) }
+      end
+
+      def has_note?(value)
+        value = value.note if !value.is_a?(Note) && value.respond_to?(:note)
+        notes.include?(value)
+      end
+
+      def basetone?(string)
+        string && string.note == notes[0]
+      end
+
+      def third?(string)
+        string && (string.note == third_tone)
+      end
+
+      def last?(string)
+        string && (string.note == notes[-1])
+      end
+    end
+  end
+end

data/lib/wtf_chord/collectors/piano.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module WTFChord
+  module Collectors
+    class Piano < Generic
+      self.max_dist = 12
+      MAX_OCTAVE = 5
+
+      CheckDist = -> ((a, b)) { (a.to_i - b.to_i).abs <= max_dist }
+
+      FilterProc = -> (actual_size, notes) {
+        notes.uniq(&:key).size == actual_size && notes.sort.each_cons(2).all?(&CheckDist)
+      }.curry(2).freeze
+
+      Distances = -> (notes) {
+        notes.each_cons(2).map { |(a, b)| (a.to_i - b.to_i).abs }
+      }
+
+      FirstTone = -> (tone, notes) {
+        Distances[notes]
+      }.curry(2).freeze
+
+      def collect!
+        @keyboard = Keyboard.new(1..MAX_OCTAVE)
+
+        @fingerings = @keyboard.keys.
+          grep(__getobj__).
+          combination(size).
+          filter(&FilterProc[size])
+        @fingerings.uniq! { |x| x.map(&:key) }
+        @fingerings.sort_by!(&FirstTone[tone])
+        @fingerings
+      end
+    end
+  end
+end

data/lib/wtf_chord/complexity_counter.rb

@@ -28,7 +28,7 @@ module WTFChord
         end
       end
 
-      base_rate
+      base_rate + @fingering.extra_complexity
     end
 
     private

data/lib/wtf_chord/fingering.rb

@@ -4,15 +4,18 @@ require 'wtf_chord/formatter'
 
 module WTFChord
   class Fingering < Fretboard
+    attr_accessor :extra_complexity
+
     def initialize(guitar, fingers = nil)
       @capo      = guitar.capo
       @strings   = guitar.strings.map(&:dup)
+      @extra_complexity = 0.0
       set_fingers(fingers) if fingers.is_a?(Array)
       yield(self) if block_given?
     end
 
     def code
-      @code ||= strings.map(&:code).pack("c*")
+      strings.map(&:code).pack("c*")
     end
 
     def == other
@@ -23,6 +26,18 @@ module WTFChord
       end
     end
 
+    def eql?(other)
+      super || self == other
+    end
+
+    def hash
+      strings.map(&:code).hash
+    end
+
+    def used_keys
+      used_strings.map(&:note).map(&:key).uniq.join
+    end
+
     def complexity
       complexity_counter.rate
     end
@@ -43,6 +58,14 @@ module WTFChord
       @strings.reject(&:dead?)
     end
 
+    def find_used_string_for(note)
+      used = used_strings
+      if idx = used.index(note)
+        string = used[idx]
+        yield(strings.index(string), string)
+      end
+    end
+
     def min_fret
       holded_strings.min.fret
     end

data/lib/wtf_chord/formatter.rb

@@ -2,6 +2,8 @@ require 'wtf_chord/formatters/base'
 
 module WTFChord
   class Formatter
+    attr_reader :name
+
     def initialize(name, with_rates = false)
       @name = name
       @with_rates = with_rates
@@ -9,19 +11,21 @@ module WTFChord
     end
 
     def call(*fingerings)
-      formatter.with_rates(@with_rates) do |f|
-        puts (fingerings.map(&f) * f.separator)
-      end
+      formatter.with_rates(@with_rates) { |f| fingerings.map(&f) }
     end
 
     alias :[] :call
 
+    def separator
+      formatter.separator
+    end
+
     def formatter
-      WTFChord::Formatters.const_get(formatter_name)
+      Formatters.const_get(formatter_name)
     end
 
     def formatter?
-      WTFChord::Formatters.const_defined?(formatter_name)
+      Formatters.const_defined?(formatter_name)
     end
 
     def formatter_name

data/lib/wtf_chord/formatters/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 
 module WTFChord
@@ -9,7 +11,7 @@ module WTFChord
       def_delegators :@fret, :strings
 
       def self.separator
-        "\n".freeze
+        "\n"
       end
 
       def self.to_proc
@@ -31,6 +33,10 @@ module WTFChord
       def draw
       end
 
+      def actual_strings
+        strings.reject(&:dead?)
+      end
+
       def with_rates?
         !!@with_rates
       end

data/lib/wtf_chord/formatters/default.rb

@@ -1,25 +1,28 @@
+require 'wtf_chord/helpers/roman_numbers_helper'
+
 module WTFChord
   module Formatters
     class Default < Base
       OPEN  = "|".freeze
-      HORIZ = "–".freeze
+      HORIZ = "—".freeze
       SPACE = "  ".freeze
-      BULL  = "\u2022".freeze
-      LATIN = %w(0 I II III IV V VI VII VIII IX X XII XIII).freeze
+      BULL  = "\u25C9".freeze
       NEWLINE = "\n".freeze
+      COMPLEXITY_FORMAT = "  (complexity: %.2f)".freeze
+      EMPTY_STRING = Array.new(FRETS, OPEN).freeze
 
-      def self.separator
-        "\n\n".freeze
-      end
+      include RomanNumbersHelper
 
       def draw
-        [
-          "[ #{head} ]#{capo}",
-          " #{border}",
-          *fret_rows,
-          " #{border}",
-          "  #{string_keys}#{rate}"
-        ] * NEWLINE
+        <<-EOF.gsub(/^\s+\|/, '')
+          |[ #{head} ]  #{capo}
+          | #{border}
+          #{fret_rows.map.with_index { |row, index|
+         "  |  #{row}  #{roman_min_fret if index == 0}"
+          }.join("\n")}
+          | #{border}
+          |  #{string_keys}#{rate}
+        EOF
       end
 
       private
@@ -29,11 +32,15 @@ module WTFChord
       end
 
       def capo
-        "  (capo #{to_latin @fret.capo})" if @fret.capo > 0
+        "(capo #{romanize(@fret.capo)})" if @fret.capo > 0
+      end
+
+      def roman_min_fret
+        " ← #{romanize(min_fret)}" if min_fret > 1
       end
 
       def rate
-        "  (complexity: %.2f)" % @fret.complexity if with_rates?
+        COMPLEXITY_FORMAT % @fret.complexity if with_rates?
       end
 
       def border
@@ -41,27 +48,21 @@ module WTFChord
       end
 
       def string_rows
-        strings.map { |string| draw_string(string.fret) }
+        strings.map { |string| draw_string(string) }
       end
 
       def fret_rows
-        string_rows.transpose.map! { |row| "  #{row * SPACE}  " }.tap do |rows|
-          rows[0] << "  #{to_latin min_fret}" if min_fret > 1
-        end
+        return to_enum(__method__) unless block_given?
+        string_rows.transpose.each { |row| yield(row * SPACE) }
       end
 
       def string_keys
         strings.map { |s| s.dead? ? SPACE : "%-2s" % s.key } * " "
       end
 
-      def to_latin(num)
-        LATIN[num]
-      end
-
-      def draw_string(fret)
-        Array.new(FRETS, OPEN).tap do |rows|
-          rows[(fret - min_fret.pred).pred] = BULL if fret.to_i > 0
-        end
+      def draw_string(string)
+        EMPTY_STRING.dup.
+          tap { |rows| rows[string.fret - min_fret] = BULL if string.holded? }
       end
     end
   end

data/lib/wtf_chord/formatters/piano.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "wtf_chord/formatters/piano1"
+require "wtf_chord/keyboard"
+
+module WTFChord
+  module Formatters
+    class Piano < Piano1
+      def draw
+        [
+          pressed_keys.map(&:to_s).join(" - "),
+          keyboard_presentation
+        ].join("\n")
+      end
+
+      def keyboard_presentation
+        KeyboardPresentation.press(*pressed_keys)
+      end
+    end
+  end
+end

data/lib/wtf_chord/formatters/piano1.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "wtf_chord/keyboard_presentation"
+
+module WTFChord
+  module Formatters
+    class Piano1
+      def self.separator
+        "\n"
+      end
+
+      def self.to_proc
+        proc { |keys| new(keys).draw }
+      end
+
+      def self.with_rates(*)
+        yield(self)
+      end
+
+      attr_reader :pressed_keys
+
+      def initialize(keys)
+        @pressed_keys = keys
+      end
+
+      def draw
+        [
+          unique_notes.sort.join(" - "),
+          keyboard_presentation
+        ].join("\n\n")
+      end
+
+      def actual_notes
+        actual_strings.map(&:note)
+      end
+
+      def unique_notes
+        actual_notes.uniq(&:position)
+      end
+
+      def keyboard_presentation
+        KeyboardPresentation.press(*unique_notes.map(&:position))
+      end
+    end
+  end
+end

data/lib/wtf_chord/fretboard.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 require 'wtf_chord/guitar_string'
 
 module WTFChord
   class Fretboard
-    DEAD = "×".freeze
+    DEAD = "×"
 
     attr_reader :strings, :capo
 
     def initialize(*strings)
       @capo    = 0
-      @strings = strings.map! { |string| GuitarString.new(string, @capo) }
+      @strings = strings.map { |string| GuitarString.new(string, @capo) }
     end
 
     def [] idx
@@ -23,6 +25,14 @@ module WTFChord
       self
     end
 
+    def with_capo(capo)
+      capo_was = @capo
+      set_capo(capo)
+      yield
+    ensure
+      set_capo(capo_was)
+    end
+
     def fingers
       @strings.map { |string| string.dead? ? DEAD : string.fret  }
     end

data/lib/wtf_chord/guitar_string.rb

@@ -1,14 +1,19 @@
-require 'wtf_chord/pitch'
+# frozen_string_literal: true
+
+require 'wtf_chord/instrument_pitch'
 
 module WTFChord
-  class GuitarString < DelegateClass(WTFChord::Pitch)
+  class GuitarString < InstrumentPitch
     attr_reader :capo, :fret, :original
 
     def initialize(note, capo = 0)
-      @original = WTFChord.note(note)
       @fret = nil
       @capo = capo
-      super(@original + capo)
+      super(note)
+    end
+
+    def init_pitch
+      @original + capo
     end
 
     def initialize_dup(other)
@@ -48,11 +53,18 @@ module WTFChord
       dead? ? -1 : to_i
     end
 
+    def distance_to(pitch)
+      pos = 0
+      opened = dup.open
+      pos += 1 while (opened + pos) != pitch
+      pos
+    end
+
     def <=> other
       return if dead?
       case other
-      when Integer      then @fret <=> other
-      when GuitarString then @fret <=> other.fret
+      when Integer       then @fret <=> other
+      when GuitarString  then @fret <=> other.fret
       end
     end
 

data/lib/wtf_chord/helpers/roman_numbers_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module WTFChord
+  module RomanNumbersHelper
+    ROMAN_SYMBOLS ||= ("\u2160".."\u216B").to_a.unshift(nil).freeze
+
+    def romanize(number)
+      ROMAN_SYMBOLS[number]
+    end
+  end
+end

data/lib/wtf_chord/instrument_pitch.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'wtf_chord/pitch'
+
+module WTFChord
+  class InstrumentPitch < DelegateClass(Pitch)
+    attr_reader :interval, :original
+
+    def initialize(note)
+      @original = WTFChord.note(note)
+      super(init_pitch)
+    end
+
+    def init_pitch
+      @original
+    end
+
+    def initialize_dup(other)
+      super
+      __setobj__(@original.dup)
+    end
+
+    def dead
+    end
+
+    def dead?
+      raise NotImplementedError
+    end
+
+    def holded?
+      raise NotImplementedError
+    end
+
+    def distance_to(pitch)
+      pos = 0
+      pos += 1 while (original + pos) != pitch
+      pos
+    end
+
+    def code
+      to_i
+    end
+
+    def <=> other
+      case other
+      when Integer
+        to_i <=> other
+      when InstrumentPitch
+        to_i <=> other.to_i
+      end
+    end
+  end
+end

data/lib/wtf_chord/keyboard.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "wtf_chord/piano_key"
+
+module WTFChord
+  class Keyboard
+    attr_reader :keys
+
+    KEYS = %w(C C# D D# E F F# G G# A Bb B)
+
+    def initialize(octaves = 1..5)
+      @keys = octaves.to_a.product(KEYS).map { |(o, k)| PianoKey.new("#{k}#{o}") }
+    end
+
+    def [] idx
+      case idx
+      when 1..@keys.size then @keys[~-idx]
+      end
+    end
+  end
+end

data/lib/wtf_chord/keyboard_presentation.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'wtf_chord/helpers/roman_numbers_helper'
+
+module WTFChord
+  class KeyboardPresentation
+    FRAME = <<~EOF
+    ┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐┬
+    │ │ ││ │ │ │ ││ ││ │ ││
+    │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ ││
+    │  │  │  │  │  │  │  ││
+    └──┴──┴──┴──┴──┴──┴──┘┴
+     ↑                    |
+     %s                    |
+                          |
+    EOF
+
+    include RomanNumbersHelper
+
+    KeyStruct = Struct.new(:index) do
+      singleton_class.attr_accessor :mark
+      singleton_class.alias_method :[], :new
+
+      def call(frame)
+        frame[index, mark.length] = mark
+      end
+
+      private def mark
+        self.class.mark
+      end
+    end
+
+    Key = -> (mark) { Class.new(KeyStruct).tap { |c| c.mark = mark } }
+    W, B = Key["▐▌"], Key["█"]
+
+    KEYS = [W[73], B[27], W[76], B[30], W[79], W[82], B[36], W[85], B[39], W[88], B[42], W[91]].
+      map.with_index(1).to_h.invert.freeze
+
+    def self.press(*positions)
+      if positions.all? { |v| Integer === v }
+        new.press(*positions)
+      else
+        positions.uniq(&:key).group_by(&:octave).inject(nil) do |a, (octave, strings)|
+          pos = strings.map { |s| s.note.position }
+          kb = new(octave).press(*pos)
+          a.nil? ? kb : a + kb
+        end
+      end
+    end
+
+    attr_reader :frame
+
+    def initialize(octave = 1)
+      @octave = octave
+      @frame = FRAME.dup % romanize(octave)
+    end
+
+    def +@
+      shift!
+      self
+    end
+
+    def +(other)
+      pop!
+      @frame.replace(@frame.lines(chomp: true).zip((+other).frame.lines).map(&:join).join)
+      self
+    end
+
+    def press(*positions)
+      positions.each { |pos| KEYS.fetch(pos).(@frame) }
+      self
+    end
+
+    def to_s
+      finalize!
+    end
+
+    def finalize!
+      @frame.gsub("|", " ").gsub(/[^\s](?=\n)/, "")
+    end
+
+    def pop!
+      @frame.replace(@frame.lines.each { |line| line[-3, 1] = "" }.join)
+    end
+
+    def shift!
+      @frame.replace(@frame.lines.each { |line| line[0, 1] = "" }.join)
+    end
+  end
+end

data/lib/wtf_chord/note.rb

@@ -25,7 +25,7 @@ module WTFChord
 
     def == other
       case other
-      when String  then other.casecmp(@key).zero?
+      when String  then other.casecmp(@key).zero? || aliases.any? { |a| other.casecmp(a.key).zero? }
       when Integer then other == @position
       when Note    then other.position == @position
       end

data/lib/wtf_chord/piano_key.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "wtf_chord/instrument_pitch"
+
+module WTFChord
+  class PianoKey < InstrumentPitch
+    def pressed?
+      !!@pressed
+    end
+
+    def dead?
+      !pressed?
+    end
+
+    def press!
+      @pressed = true
+    end
+  end
+end

data/lib/wtf_chord/pitch.rb

@@ -46,6 +46,10 @@ module WTFChord
       move -amount
     end
 
+    def -@
+      -to_i
+    end
+
     def to_i
       (@octave * 12) + @note.position
     end

data/lib/wtf_chord/scale.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'wtf_chord/note'
 require 'wtf_chord/pitch'
 require 'wtf_chord/fretboard'
@@ -30,9 +32,9 @@ module WTFChord
 
   private_constant :ScaleArray
 
-  FLAT    ||= "b".freeze
-  SHARP   ||= "#".freeze
-  SIGNS   ||= { FLAT => "\u266D".freeze, SHARP => "\u266F".freeze }.freeze
+  FLAT    ||= "b"
+  SHARP   ||= "#"
+  SIGNS   ||= { FLAT => "\u266D", SHARP => "\u266F" }.freeze
 
   DIATONIC = {
     "C" => "Do",
@@ -43,7 +45,7 @@ module WTFChord
     "A" => "La",
     "B" => "Si",
     "H" => "Si"
-  }.freeze
+  }
 
   SCALE ||= begin
     chromatic_scale = %W(
@@ -60,8 +62,22 @@ module WTFChord
       Bb|A#
       B|H
     )
-    ScaleArray.build(*chromatic_scale).freeze
+    ScaleArray.build(*chromatic_scale)
+  end
+
+  def self.guitar=(guitar)
+    Thread.current[:wtf_guitar] = guitar
+  end
+
+  def self.guitar
+    Thread.current[:wtf_guitar] ||= Fretboard.new(*%w(E2 A2 D3 G3 B3 E4))
+  end
+
+  def self.piano=(piano)
+    Thread.current[:wtf_piano] = piano
   end
 
-  GUITAR ||= Fretboard.new(*%w(E2 A2 D3 G3 B3 E4))
+  def self.piano
+    Thread.current[:wtf_piano] ||= Keyboard.new
+  end
 end

data/lib/wtf_chord/version.rb

@@ -1,3 +1,3 @@
 module WTFChord
-  VERSION = "0.3"
+  VERSION = "0.7.0"
 end

data/wtf_chord.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency "methadone"
 
-  spec.add_development_dependency "bundler", ">= 1.11", "< 2"
-  spec.add_development_dependency "rake", ">= 10.0", "< 12"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", ">= 3.0", "< 4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wtf_chord
 version: !ruby/object:Gem::Version
-  version: '0.3'
+  version: 0.7.0
 platform: ruby
 authors:
 - Anton
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-04-03 00:00:00.000000000 Z
+date: 2021-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: methadone
@@ -30,40 +30,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.11'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.11'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '12'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '12'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -95,6 +83,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - README.md
 - Rakefile
@@ -105,16 +94,26 @@ files:
 - lib/wtf_chord.yml
 - lib/wtf_chord/chord.rb
 - lib/wtf_chord/cli.rb
+- lib/wtf_chord/collectors.rb
+- lib/wtf_chord/collectors/generic.rb
+- lib/wtf_chord/collectors/guitar.rb
+- lib/wtf_chord/collectors/piano.rb
 - lib/wtf_chord/complexity_counter.rb
 - lib/wtf_chord/fingering.rb
-- lib/wtf_chord/fingerings_generator.rb
 - lib/wtf_chord/formatter.rb
 - lib/wtf_chord/formatters/base.rb
 - lib/wtf_chord/formatters/default.rb
+- lib/wtf_chord/formatters/piano.rb
+- lib/wtf_chord/formatters/piano1.rb
 - lib/wtf_chord/formatters/simple.rb
 - lib/wtf_chord/fretboard.rb
 - lib/wtf_chord/guitar_string.rb
+- lib/wtf_chord/helpers/roman_numbers_helper.rb
+- lib/wtf_chord/instrument_pitch.rb
+- lib/wtf_chord/keyboard.rb
+- lib/wtf_chord/keyboard_presentation.rb
 - lib/wtf_chord/note.rb
+- lib/wtf_chord/piano_key.rb
 - lib/wtf_chord/pitch.rb
 - lib/wtf_chord/rules.rb
 - lib/wtf_chord/scale.rb
@@ -138,10 +137,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: "‘WTF Chord?’ is the Ruby guitar chords generator library."
 test_files: []
-has_rdoc: 

data/lib/wtf_chord/fingerings_generator.rb

@@ -1,85 +0,0 @@
-module WTFChord
-  class Chord
-  end
-
-  class FingeringsGenerator < DelegateClass(Chord)
-    MAX_DIST = 5
-    MAX_FRET = 7
-
-    def fingerings
-      @fingerings ||= []
-    end
-
-    def call
-      fingerings.clear
-
-      (0...MAX_FRET).each do |from|
-        to = from + MAX_DIST
-        generate(from...to) do |variant|
-          fingerings << variant if filter_variant(variant)
-        end
-      end
-
-      fingerings.sort_by!(&:complexity)
-    end
-
-    private
-
-    def generate(fret_range)
-      combinations = GUITAR.strings.map.with_index do |s, index|
-        fret_range.select do |dist|
-          pitch = s.original + dist
-          has_note?(pitch)
-        end.tap do |frets|
-          frets << nil if frets.size == 0
-        end
-      end
-
-      combinations.inject(&:product).each do |fingers|
-        fingers.flatten!
-        Fingering.new(GUITAR, fingers) do |variant|
-          adjust(variant)
-          yield(variant)
-        end
-      end
-    end
-
-    def filter_variant(variant)
-      used_strings = variant.used_strings
-      used_notes = used_strings.map(&:note)
-      tones_count = notes.map { |n| used_notes.count(n) }
-
-      !fingerings.include?(variant) &&
-      basetone?(used_strings[0]) &&
-      (third?(used_strings[1]) || third?(used_strings[2])) &&
-      all_notes?(used_notes) &&
-      used_notes.each_cons(2).none? { |(l, r)| l == r } &&
-      tones_count.all? { |n| tones_count[0] >= n || tones_count[notes.index(third_tone)] >= n } &&
-      variant.complexity <= 2.25
-    end
-
-    def adjust(fingering)
-      while (string = fingering.used_strings[0]) && !basetone?(string)
-        string.dead if !string.dead?
-        break if fingering.used_strings.size == 4
-      end
-    end
-
-    def all_notes?(used_notes)
-      notes.all? { |n| used_notes.include?(n) }
-    end
-
-    def has_note?(value)
-      value = value.note if !value.is_a?(Note) && value.respond_to?(:note)
-      notes.include?(value)
-    end
-
-    def basetone?(string)
-      string && string.note == notes[0]
-    end
-
-    def third?(string)
-      string && (string.note == third_tone)
-    end
-  end
-end