wtf_chord 0.2.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 23feadfbf5375e890423135cc86a56d9b70af3e8
-  data.tar.gz: aaa6a0d46fbeb51e715306da3d127b86816ed293
+SHA256:
+  metadata.gz: 6b17613170273223d591f45e88733cf89449d8b872088496c7c569a7e053f4e0
+  data.tar.gz: 10460d448a476b45fd1ea0c96b6b418458f7c123b83f9bc8f8d45593e6fd1b36
 SHA512:
-  metadata.gz: 711ef213b9ea7302e812c122fda26aee2bb305960a0a1fc3f687106948ea401dcfe17eaeac3972d9a42f6bdf22f6189d01255be790bf89194dbb5e6479a3d86c
-  data.tar.gz: 4c081a0a57e196422c13fa0a40f671e55d2b39ad49f96678c8b87da277d5e242d4d38fd19924d7e0d920444cc290af7d5984208e75f8a1cbc4dbeeddd10e7547
+  metadata.gz: 37dc9a3b6f74eeb4615f8ff897982c0a4dff8577316415ce50cd9278968298d2c9a18d24ca885fde1f599c919b6547884983ab38e68f5ae49e33f6671436e8a9
+  data.tar.gz: 8d326d7047187a13e778af13928a3e5ac847e56c57109817feab09b17d00a29c2d56a33c9d98d23946ccde52fa5cc65e158f14ee71e59470bdb57ec319514ccb

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:

data/lib/wtf_chord/chord.rb

@@ -1,68 +1,41 @@
 require 'wtf_chord/fingering'
+require 'wtf_chord/fingerings_generator'
 
 module WTFChord
   class Chord
-    MAX_DIST = 5
-    MAX_FRET = 7
+    BASS_MATCH = /(?<=[\\\/])[A-H][b#]?(?=$)/
 
-    attr_reader :pitch, :steps, :notes, :name
+    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
       @steps = Array(WTFChord.rules[name])
       @notes = @steps.map { |dist| (@pitch + dist).note }.tap(&:uniq!)
-    end
 
-    def inspect
-      "#{name} (#{@notes.map(&:key) * ' - '})"
-    end
-
-    def fingerings(limit = 3)
-      list = []
-
-      (0..MAX_FRET).each do |from_fret|
-        f = get_fingering(from_fret)
-        next if list.include?(f)
-        list << f if all_notes?(f.used_strings)
+      BASS_MATCH.match(@name) do |m|
+        @bass = WTFChord.note(m[0]).note
       end
-
-      sort_fingerings(list, limit)
     end
 
-    def get_fingering(from_fret = 0)
-      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
-
-        adjust_fingering(f.used_strings[0], to_fret, 0) while should_adjust?(f.used_strings[0], 0)
-      end
+    def fingerings(limit = nil)
+      FingeringsGenerator.new(self).call[0, limit || 5]
     end
 
-    def all_notes?(strings)
-      snotes = strings.map(&:note).tap(&:uniq!)
-      @notes.all? { |n| snotes.include?(n) }
+    def third_tone
+      @third_tone ||= @notes[@steps.size > 3 ? 2 : -1]
     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]
+    def bass?
+      !!@bass
     end
 
-    def should_adjust?(string, i = 0)
-      string && string.note != @notes[i]
+    def original_bass
+      @notes[0]
     end
 
-    def sort_fingerings(list, limit)
-      list.sort_by!(&:complexity)
-      list[0...limit].sort_by!(&:min_fret)
+    def inspect
+      "#{name} (#{@notes.map(&:key) * ' - '})"
     end
   end
 end

data/lib/wtf_chord/cli.rb

@@ -7,14 +7,15 @@ 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" }
 
+      options['amount'] = 1 if options['output'] == 'piano'
+
       puts chord.inspect, nil
-      formatter.(*fingerings)
+      puts formatter[*chord.fingerings(options['amount'])] * formatter.separator
     end
 
     version VERSION
@@ -31,7 +32,7 @@ module WTFChord
     ##
     # Options
     #
-    options['amount'] = 3
+    options['amount'] = 5
     options['output'] = 'default'
     options['rates']  = false
 

data/lib/wtf_chord/complexity_counter.rb

@@ -6,19 +6,29 @@ module WTFChord
 
     def rate
       frets = @fingering.holded_strings.map(&:fret)
-      barre = frets.uniq.keep_if { |o| frets.count(o) >= 2 }.min
-      barre_strings = barre ? frets.count(barre).pred : 0
+      barre = frets.uniq.keep_if { |o| frets.count(o) >= 2 }
+      barre_strings = barre.min ? frets.count(barre.min).pred : 0
 
       base_rate = begin
-        Rational(holded_strings - barre_strings, 6).to_f +
-        Rational(finger_dist(frets), 5).to_f
+        Rational(holded_strings - barre_strings, 4).to_f +
+        Rational(finger_dist(@fingering.used_strings.map(&:fret)), 4).to_f
       end
 
+      base_rate += 0.5 if (holded_strings - barre_strings) > 4
+
       # p [@fingering, holded_strings, barre_strings]
 
-      base_rate += 1 if (barre_strings > 2 || frets.uniq.size > 3) && complex_barre?(barre, frets)
+      if holded_strings > 4
+        uniq_frets = frets.uniq.size
+
+        if barre.size > 1 && uniq_frets == 3 && frets.count(barre.max) > barre_strings.next
+          base_rate += 1 if complex_barre?(barre.max, frets)
+        elsif barre_strings.next >= 2 || uniq_frets.size > 3
+          base_rate += 1 if complex_barre?(barre.min, frets)
+        end
+      end
 
-      base_rate
+      base_rate + @fingering.extra_complexity
     end
 
     private

data/lib/wtf_chord/fingering.rb

@@ -4,14 +4,18 @@ require 'wtf_chord/formatter'
 
 module WTFChord
   class Fingering < Fretboard
-    def initialize(guitar)
+    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
@@ -22,6 +26,14 @@ module WTFChord
       end
     end
 
+    def eql?(other)
+      super || self == other
+    end
+
+    def hash
+      strings.map(&:code).hash
+    end
+
     def complexity
       complexity_counter.rate
     end
@@ -42,6 +54,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/fingerings_generator.rb

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

data/lib/wtf_chord/formatter.rb

@@ -9,19 +9,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

@@ -31,6 +31,10 @@ module WTFChord
       def draw
       end
 
+      def keys
+        strings.reject(&:dead?).map(&:key)
+      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,25 @@
+# frozen_string_literal: true
+
+require "wtf_chord/keyboard"
+
+module WTFChord
+  module Formatters
+    class Piano < Base
+      def draw
+        [
+          unique_notes.sort.join(" - "),
+          Keyboard.press(*unique_notes.map(&:position))
+        ].join("\n\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]
+      end
+    end
+  end
+end

data/lib/wtf_chord/fretboard.rb

@@ -23,6 +23,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

@@ -48,6 +48,13 @@ 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

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/keyboard.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module WTFChord
+  class Keyboard
+    FRAME = <<~EOF
+    ┌─┬─┬┬─┬─┬─┬─┬┬─┬┬─┬─┐
+    │ │ ││ │ │ │ ││ ││ │ │
+    │ └┬┘└┬┘ │ └┬┘└┬┘└┬┘ │
+    │  │  │  │  │  │  │  │
+    └──┴──┴──┴──┴──┴──┴──┘
+    EOF
+
+    Key = Struct.new(:offset)
+    class Key
+      singleton_class.attr_accessor :select_symbol
+      singleton_class.alias_method :[], :new
+
+      def select(frame)
+        frame[offset] = self.class.select_symbol
+        frame
+      end
+    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)
+      end
+    end
+  end
+end

data/lib/wtf_chord/note.rb

@@ -25,8 +25,9 @@ module WTFChord
 
     def == other
       case other
-      when String        then other.casecmp(@key).zero?
-      when Integer, Note then other == @position
+      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
     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/rules.rb

@@ -23,7 +23,9 @@ module WTFChord
       name.match(pattern) do |m|
         base = chords[m[:name]] || chords["M"]
         steps.concat(base)
-        steps.concat(extra[m[:ext]]) if m[:ext] && m[:ext].length <= (6 - steps.length)
+
+        ext = extra[m[:ext]] if m[:ext]
+        steps.concat(ext) if ext
       end
 
       steps.tap(&:uniq!)

data/lib/wtf_chord/scale.rb

@@ -63,5 +63,11 @@ module WTFChord
     ScaleArray.build(*chromatic_scale).freeze
   end
 
-  GUITAR ||= Fretboard.new(*%w(E2 A2 D3 G3 B3 E4))
+  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
 end

data/lib/wtf_chord/version.rb

@@ -1,3 +1,3 @@
 module WTFChord
-  VERSION = "0.2.1"
+  VERSION = "0.6.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.2.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Anton
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-04-03 00:00:00.000000000 Z
+date: 2021-03-28 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
@@ -107,12 +96,16 @@ files:
 - lib/wtf_chord/cli.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/simple.rb
 - lib/wtf_chord/fretboard.rb
 - lib/wtf_chord/guitar_string.rb
+- lib/wtf_chord/helpers/roman_numbers_helper.rb
+- lib/wtf_chord/keyboard.rb
 - lib/wtf_chord/note.rb
 - lib/wtf_chord/pitch.rb
 - lib/wtf_chord/rules.rb
@@ -137,10 +130,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: