wtf_chord 0.3.1 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6659fef8eb5eb71f547c1186e3d676a600f4b075
-  data.tar.gz: b4bff9c2a9251ece5fb9fc21b6ff03b0484dd102
+SHA256:
+  metadata.gz: d79d3b4f0a6ef8088987819387a46e7e1b4fd4e03614f131dba94ea7cc19e6c8
+  data.tar.gz: e7122f195b69586a37c6a570bc0e3b64cf5f4ca8f1e357fc2504be86dfc0d0bc
 SHA512:
-  metadata.gz: b6c5b2ac510e44764a577b3af1744bfd71cc573047866a9cfed73e79cb882a299c894d62c664fcd8ae04814faebf04ef7740168045edccf2a304630fb9f05cc5
-  data.tar.gz: 18342e90f1af73920ee3d5974bb662c5d1e506af50c9bc822f67367dcc04f68717d4649ce5a925afc671edb184bf0339b200d5c64f822c4b72457e56328f9eee
+  metadata.gz: d2defd3bdae6c97b0eeb1e899edc1204a53c61a124b6832ac5748c1083fae7714cf322ba53e0000fc36fd217bbd85c0393833fada192cc02df76a2aadd4661b1
+  data.tar.gz: 18d8cf19045668207068d5854108292cc045f35da1e9063b7a3d869c78d2d78a98cad034730b8f950c465223128acb30d754a2b84136926a3358484f8575beeb

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

@@ -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, bass].uniq.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
-      puts formatter[*fingerings] * formatter.separator
+      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,39 @@
+# 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 }
+      }
+
+      Sorting = -> (tone, notes) {
+        notes = notes.sort
+        mod = (notes[0].note.position - tone.position).abs.next
+        score = Distances[notes[1..-1]].sum
+        mod + score
+      }.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!(&Sorting[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

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/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

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module WTFChord
   module RomanNumbersHelper
-    ROMAN_SYMBOLS ||= %w(I II III IV V VI VII VIII IX X XII XIII XIV XV XVI XVII).unshift(nil).freeze
+    ROMAN_SYMBOLS ||= ("\u2160".."\u216B").to_a.unshift(nil).freeze
 
     def romanize(number)
       ROMAN_SYMBOLS[number]

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/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.1"
+  VERSION = "0.7.1"
 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.1
+  version: 0.7.1
 platform: ruby
 authors:
 - Anton
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-04-04 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,17 +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
@@ -139,10 +137,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.2
+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,92 +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])) ||
-        (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 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