wtf_chord 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b17613170273223d591f45e88733cf89449d8b872088496c7c569a7e053f4e0
-  data.tar.gz: 10460d448a476b45fd1ea0c96b6b418458f7c123b83f9bc8f8d45593e6fd1b36
+  metadata.gz: 8d764a30038a11df351e6d3d9dfce09084aa89af352d92b36677ed5eac31e425
+  data.tar.gz: 0c713ee0f4e3b36720014f56c1c55ca6686981b49e228402d8c2f826463affce
 SHA512:
-  metadata.gz: 37dc9a3b6f74eeb4615f8ff897982c0a4dff8577316415ce50cd9278968298d2c9a18d24ca885fde1f599c919b6547884983ab38e68f5ae49e33f6671436e8a9
-  data.tar.gz: 8d326d7047187a13e778af13928a3e5ac847e56c57109817feab09b17d00a29c2d56a33c9d98d23946ccde52fa5cc65e158f14ee71e59470bdb57ec319514ccb
+  metadata.gz: e83f9de2c3913c4206d7d4f424f46f1082fcd16a50f8f19d4d78f2d83f3a66f610d23852ac66b890190f444db14e74d3fc9249514e6ece64626685c4c7434de2
+  data.tar.gz: 3ac9226adb773858a51c474c0f1b299e3bf2601ce567d9967c96b297ba4b0895da08c6b50e404221ba636be01d83740fea20b3f5684ebb24a2053b4b81235425

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,5 +1,7 @@
+# frozen_string_literal: true
+
 require 'wtf_chord/fingering'
-require 'wtf_chord/fingerings_generator'
+require 'wtf_chord/collectors'
 
 module WTFChord
   class Chord
@@ -9,7 +11,7 @@ module WTFChord
 
     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!)
 
@@ -18,8 +20,12 @@ module WTFChord
       end
     end
 
-    def fingerings(limit = nil)
-      FingeringsGenerator.new(self).call[0, limit || 5]
+    def fingerings(limit = nil, collector: Collectors::Guitar)
+      collector.new(self).call[0, limit || 5]
+    end
+
+    def tone
+      bass || original_bass
     end
 
     def third_tone
@@ -30,10 +36,25 @@ module WTFChord
       !!@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

data/lib/wtf_chord/cli.rb

@@ -12,10 +12,17 @@ module WTFChord
 
       debug { "Output using formatter: #{formatter.formatter.to_s}\n" }
 
-      options['amount'] = 1 if options['output'] == 'piano'
+      options['amount'] = 1 if options['output'] == 'piano1'
 
-      puts chord.inspect, nil
-      puts formatter[*chord.fingerings(options['amount'])] * formatter.separator
+      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/fingering.rb

@@ -34,6 +34,10 @@ module WTFChord
       strings.map(&:code).hash
     end
 
+    def used_keys
+      used_strings.map(&:note).map(&:key).uniq.join
+    end
+
     def complexity
       complexity_counter.rate
     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,8 +33,8 @@ module WTFChord
       def draw
       end
 
-      def keys
-        strings.reject(&:dead?).map(&:key)
+      def actual_strings
+        strings.reject(&:dead?)
       end
 
       def with_rates?

data/lib/wtf_chord/formatters/piano.rb

@@ -1,24 +1,20 @@
 # frozen_string_literal: true
 
+require "wtf_chord/formatters/piano1"
 require "wtf_chord/keyboard"
 
 module WTFChord
   module Formatters
-    class Piano < Base
+    class Piano < Piano1
       def draw
         [
-          unique_notes.sort.join(" - "),
-          Keyboard.press(*unique_notes.map(&:position))
-        ].join("\n\n")
+          pressed_keys.map(&:to_s).join(" - "),
+          keyboard_presentation
+        ].join("\n")
       end
 
-      def unique_notes
-        strings.reject(&:dead?).each_with_object([[], []]) do |string, (positions, notes)|
-          unless positions.include?(string.note.position)
-            positions << string.note.position
-            notes << string.note
-          end
-        end[1]
+      def keyboard_presentation
+        KeyboardPresentation.press(*pressed_keys)
       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

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)
@@ -58,8 +63,8 @@ module WTFChord
     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/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

@@ -1,47 +1,20 @@
 # frozen_string_literal: true
 
+require "wtf_chord/piano_key"
+
 module WTFChord
   class Keyboard
-    FRAME = <<~EOF
-    ┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
-    │ │ ││ │ │ │ ││ ││ │ │
-    │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
-    │  │  │  │  │  │  │  │
-    └──┴──┴──┴──┴──┴──┴──┘
-    EOF
+    attr_reader :keys
 
-    Key = Struct.new(:offset)
-    class Key
-      singleton_class.attr_accessor :select_symbol
-      singleton_class.alias_method :[], :new
+    KEYS = %w(C C# D D# E F F# G G# A Bb B)
 
-      def select(frame)
-        frame[offset] = self.class.select_symbol
-        frame
-      end
+    def initialize(octaves = 1..5)
+      @keys = octaves.to_a.product(KEYS).map { |(o, k)| PianoKey.new("#{k}#{o}") }
     end
 
-    W = Class.new(Key) { self.select_symbol = "▐▌" }
-    B = Class.new(Key) { self.select_symbol = "█" }
-
-    KEYS = {
-      1  => W[70...72],
-      2  => B[26...27],
-      3  => W[73...75],
-      4  => B[29...30],
-      5  => W[76...78],
-      6  => W[79...81],
-      7  => B[35...36],
-      8  => W[82...84],
-      9  => B[38...39],
-      10 => W[85...87],
-      11 => B[41...42],
-      12 => W[88...90]
-    }
-
-    def self.press(*positions)
-      positions.each_with_object(FRAME.dup) do |pos, frame|
-        KEYS.fetch(pos).select(frame)
+    def [] idx
+      case idx
+      when 1..@keys.size then @keys[~-idx]
       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/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,7 +62,7 @@ module WTFChord
       Bb|A#
       B|H
     )
-    ScaleArray.build(*chromatic_scale).freeze
+    ScaleArray.build(*chromatic_scale)
   end
 
   def self.guitar=(guitar)
@@ -70,4 +72,12 @@ module WTFChord
   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
+
+  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.6.0"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wtf_chord
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Anton
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-03-28 00:00:00.000000000 Z
+date: 2021-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: methadone
@@ -94,19 +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

data/lib/wtf_chord/fingerings_generator.rb

@@ -1,120 +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 << 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