wtf_chord 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cec796fdac73df072faef8d89c98f6fc37aded7f
+  data.tar.gz: 17772eb9d7105e1445ff40e6873c37d12914cca7
+SHA512:
+  metadata.gz: 945c5110c7e52340a4eca72385710d9cfa031cb647c2a2f8ae8207af7179467f3dc72059dc42bcf8b64083d0338644f018f85f5be551d53e4b722d3cd76f5e63
+  data.tar.gz: ba92873418bb4224f7dbf841501b02694c2fda562ea86030b4c918364b004c74b8f9d3bca6eb38168aeaf939934829ddc6186b44d09d79bc2daa86e01143a89e

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.ruby-version

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,18 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in wtf_chord.gemspec
+gemspec
+
+# To use a debugger
+gem 'byebug', group: [:development, :test]
+
+group :development, :test do
+  # You need these
+  gem "rspec"
+  gem "pry"
+end
+
+group :development do
+  # You don't need these, but I use them
+  gem "awesome_print"
+end

data/README.md

@@ -0,0 +1,36 @@
+# WTFChord
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/wtf_chord`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'wtf_chord'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install wtf_chord
+
+## Usage
+
+    $ wtfchord F#dim
+
+## 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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/wtf_chord.
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "wtf_chord"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/wtfchord

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rubygems' unless Object.const_defined?(:Gem)
+require "wtf_chord"
+
+WTFChord.chord(ARGV[0]).draw_fingerings(ARGV[1]&.to_i || 3)

data/lib/wtf_chord/chord.rb

@@ -0,0 +1,56 @@
+module WTFChord
+  class Chord
+    MAX_DIST = 5
+    MAX_FRET = 7
+
+    attr_reader :pitch, :steps, :notes, :name
+
+    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|
+        fingering = get_fingering(from_fret)
+
+        next if list.include?(fingering)
+
+        if all_notes?(fingering.used_strings)
+          list << fingering
+        end
+      end
+
+      list.sort_by!(&:complexity)[0...limit].sort_by!(&:min_fret)
+    end
+
+    def draw_fingerings(limit = 3)
+      puts (fingerings(limit).map(&:draw) * "\n\n")
+    end
+
+    def get_fingering(from_fret = 0)
+      GUITAR.dup.tap do |guitar|
+        guitar.strings.each do |s|
+          fret = (from_fret..(from_fret+MAX_DIST)).detect { |dist| @notes.include?((s.original + dist).note) }
+          fret ? s.hold_on(fret) : s.dead
+        end
+
+        while guitar.used_strings[0] && guitar.used_strings[0].note != @notes[0]
+          guitar.used_strings.detect { |x| !x.dead? && x.note != @notes[0] }&.dead
+        end
+      end
+    end
+
+    def all_notes?(strings)
+      snotes = strings.map(&:note).tap(&:uniq!)
+      @notes.all? { |n| snotes.include?(n) }
+    end
+  end
+end

data/lib/wtf_chord/drawer.rb

@@ -0,0 +1,79 @@
+require 'forwardable'
+
+module WTFChord
+  class Drawer
+    FRETS = 6
+    OPEN  = "|".freeze
+    HORIZ = "–".freeze
+    SPACE = "  ".freeze
+    BULL  = "\u2022".freeze
+    LATIN = %w(0 I II III IV V VI VII VIII IX X XII XIII).freeze
+    NEWLINE = "\n".freeze
+
+    extend Forwardable
+    def_delegators :@fret, :strings
+
+    def initialize(fret, newline: nil)
+      @fret    = fret
+      @newline = newline || NEWLINE
+    end
+
+    def draw
+      [
+        "[ #{head} ]#{capo}",
+        " #{border}",
+        *fret_rows,
+        " #{border}",
+        "  #{string_keys}"
+      ] * @newline
+    end
+
+    protected
+
+    def min_fret
+      @min_fret = begin
+        frets = strings.map(&:fret).tap(&:compact!)
+        _min = frets.min.to_i || 1
+        _min > 2 ? _min : 1
+      end
+    end
+
+    def head
+      @fret.fingers * SPACE
+    end
+
+    def capo
+      "  (capo #{to_latin @fret.capo})" if @fret.capo > 0
+    end
+
+    def border
+      @border ||= HORIZ * 3 * strings.length
+    end
+
+    def string_rows
+      strings.map { |string| draw_string(string.fret) }
+    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
+    end
+
+    def string_keys
+      strings.map { |s| s.dead? ? SPACE : "%-2s" % s.key } * " "
+    end
+
+    private
+
+    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
+    end
+  end
+end

data/lib/wtf_chord/fingerboard.rb

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

data/lib/wtf_chord/guitar_string.rb

@@ -0,0 +1,57 @@
+require 'wtf_chord/pitch'
+
+module WTFChord
+  class GuitarString < DelegateClass(WTFChord::Pitch)
+    attr_reader :capo, :fret, :original
+
+    def initialize(note, capo = 0)
+      @original = WTFChord.note(note)
+      @fret = nil
+      @capo = capo
+      super(@original + capo)
+    end
+
+    def initialize_dup(other)
+      super
+      __setobj__(@original.dup)
+    end
+
+    def set_capo(capo)
+      @capo = capo
+      calculate_note!
+    end
+
+    def hold_on(fret)
+      @fret = fret
+      calculate_note!
+    end
+
+    def open
+      @fret = 0
+      calculate_note!
+    end
+
+    def dead
+      @fret = nil
+      calculate_note!
+    end
+
+    def dead?
+      @fret.nil?
+    end
+
+    def holded?
+      !dead? && @fret > 0
+    end
+
+    def code
+      dead? ? -1 : to_i
+    end
+
+    private
+
+    def calculate_note!
+      __setobj__(@original + @capo + (@fret || 0))
+    end
+  end
+end

data/lib/wtf_chord/note.rb

@@ -0,0 +1,58 @@
+module WTFChord
+  class Note
+    include Comparable
+
+    attr_reader :key, :name, :position
+
+    def initialize(key, position = nil)
+      if /^(?<note>[a-h])(?<sign>#|b)?$/i =~ key
+        note.upcase!
+        @key      = "#{note}#{sign}".freeze
+        @name     = "#{DIATONIC[note]}#{SIGNS[sign]}".freeze
+        @position = position
+      else
+        raise ArgumentError
+      end
+    end
+
+    def to_s
+      @key.sub(/[b#]$/, SIGNS)
+    end
+
+    def inspect
+      "#@name (#{to_s}: #@position)"
+    end
+
+    def == other
+      case other
+      when String        then other.casecmp(@key).zero?
+      when Integer, Note then other == @position
+      end
+    end
+
+    def <=> other
+      case other
+      when Note     then @position <=> other.position
+      when Integer  then @position <=> other
+      end
+    end
+
+    def aliases
+      @aliases ||= SCALE.select { |t| t.position == @position && t.key != @key }
+    end
+
+    def semitone?
+      @key.end_with?(FLAT, SHARP)
+    end
+
+    def with_octave(octave)
+      Pitch.new(self, octave)
+    end
+
+    def chord(name)
+      with_octave.chord(name)
+    end
+
+    alias :[] :with_octave
+  end
+end

data/lib/wtf_chord/pitch.rb

@@ -0,0 +1,83 @@
+require 'scanf'
+require 'wtf_chord/note'
+require 'forwardable'
+
+module WTFChord
+  class Pitch
+    extend Forwardable
+    include Comparable
+
+    def_delegators :@note, :key
+    attr_reader :note, :octave
+
+    def initialize(note, octave = nil)
+      raise ArgumentError unless note.is_a?(Note)
+
+      @note   = note
+      @octave = octave || 4
+    end
+
+    def to_str
+      "#{@note.key}#{octave}"
+    end
+
+    def to_s
+      "#{@note.to_s}#{octave}"
+    end
+
+    alias :inspect :to_s
+
+    def move(amount)
+      return self if amount.zero?
+
+      to_octave, to_pos = (to_i + amount).divmod(12)
+
+      if to_pos.zero?
+        to_octave -= 1
+        to_pos = 12
+      end
+
+      SCALE[to_pos][to_octave]
+    end
+
+    alias :+ :move
+
+    def - amount
+      move -amount
+    end
+
+    def to_i
+      (@octave * 12) + @note.position
+    end
+
+    def == other
+      case other
+      when Integer, Pitch then other == to_i
+      when String then other.casecmp(to_str).zero?
+      when Note   then other == @note
+      end
+    end
+
+    def <=> other
+      case other
+      when Note     then @note <=> other
+      when Integer  then to_i  <=> other
+      when Pitch    then to_i  <=> other.to_i
+      end
+    end
+
+    def chord(name)
+      Chord.new(self, name)
+    end
+  end
+
+  NOTE_FSTR ||= "%2[A-Ha-h#b]%d".freeze
+
+  def self.note(val)
+    case val
+    when String
+      key, octave = val.scanf(NOTE_FSTR)
+      SCALE[key][octave || 4] if key
+    end
+  end
+end

data/lib/wtf_chord/rules.rb

@@ -0,0 +1,40 @@
+require 'yaml'
+require 'wtf_chord/chord'
+
+module WTFChord
+  class Rules
+    attr_reader :path, :chords, :extra, :pattern
+
+    def initialize(path)
+      @path = path
+      rules = YAML.load_file(@path)
+      @chords  = rules[:chords]
+      @extra   = rules[:extra]
+      @pattern = /
+        (?<name>#{Regexp.union(@chords.keys.sort_by(&:length).reverse!)})?
+        (?<ext>#{Regexp.union(@extra.keys.sort_by(&:length).reverse!)})?
+      /x
+    end
+
+    def find(name = nil)
+      steps = []
+      name ||= ""
+
+      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)
+      end
+
+      steps.tap(&:uniq!)
+    end
+
+    alias :[] :find
+  end
+
+  def self.chord(name)
+    name.match /^(?<note>[A-H][b#]?)(?<name>.+)?$/ do |m|
+      Chord.new(m[:note], m[:name])
+    end
+  end
+end

data/lib/wtf_chord/scale.rb

@@ -0,0 +1,67 @@
+require 'wtf_chord/note'
+require 'wtf_chord/pitch'
+require 'wtf_chord/fingerboard'
+
+module WTFChord
+  class ScaleArray < Array
+    attr_reader :last_position
+
+    def self.build(*list)
+      tones = list.flat_map.with_index do |keys, position|
+        keys.split("|").map! { |key| Note.new(key, position.next) }
+      end
+      new(tones)
+    end
+
+    def initialize(list)
+      @last_position = list.map(&:position).sort![-1]
+      super(list)
+    end
+
+    def [] idx
+      case idx
+      when 0       then nil
+      when Integer then super(index(idx < 0 ? last_position + idx.next : idx))
+      when String  then super(index(idx))
+      else super
+      end
+    end
+  end
+
+  private_constant :ScaleArray
+
+  FLAT    ||= "b".freeze
+  SHARP   ||= "#".freeze
+  SIGNS   ||= { FLAT => "\u266D".freeze, SHARP => "\u266F".freeze }.freeze
+
+  DIATONIC = {
+    "C" => "Do",
+    "D" => "Re",
+    "E" => "Mi",
+    "F" => "Fa",
+    "G" => "Sol",
+    "A" => "La",
+    "B" => "Si",
+    "H" => "Si"
+  }.freeze
+
+  SCALE ||= begin
+    chromatic_scale = %W(
+      C
+      C#|Db
+      D
+      D#|Eb
+      E
+      F
+      F#|Gb
+      G
+      G#|Ab
+      A
+      Bb|A#
+      B|H
+    )
+    ScaleArray.build(*chromatic_scale).freeze
+  end
+
+  GUITAR ||= Fingerboard.new(*%w(E2 A2 D3 G3 B3 E4))
+end

data/lib/wtf_chord/version.rb

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

data/lib/wtf_chord.rb

@@ -0,0 +1,25 @@
+require "wtf_chord/scale"
+require "wtf_chord/rules"
+require "wtf_chord/version"
+
+module WTFChord
+  DEFAULTS = {
+    :rules_file => File.expand_path("../wtf_chord.yml", __FILE__)
+  }.freeze
+
+  class << self
+    attr_accessor :rules
+
+    def config # :yields:
+      yield(self)
+    end
+
+    def rules_file= value
+      self.rules = Rules.new(File.expand_path(value))
+    end
+
+    def rules
+      @rules ||= Rules.new(DEFAULTS[:rules_file])
+    end
+  end
+end

data/lib/wtf_chord.yml

@@ -0,0 +1,27 @@
+:chords:
+  "M":      [0, 4, 7]
+  "m":      [0, 3, 7]
+  "aug":    [0, 4, 6]
+  "dim":    [0, 3, 6]
+  "sus2":   [0, 2, 7]
+  "sus4":   [0, 5, 7]
+  "6":      [0, 4, 7, 9]
+  "m6":     [0, 3, 7, 9]
+  "7":      [0, 4, 7, 10]
+  "7M":     [0, 4, 7, 11]
+  "m7":     [0, 3, 7, 10]
+  "m7M":    [0, 3, 7, 11]
+  "dim7":   [0, 3, 6, 9]
+  "7sus2":  [0, 2, 7, 10]
+  "7sus4":  [0, 5, 7, 10]
+  "7Msus2": [0, 2, 7, 11]
+  "7Msus4": [0, 5, 7, 11]
+  "5":      [0, 7]
+
+:extra:
+  "9":     [14]
+  "11":    [17]
+  "13":    [21]
+  "add9":  [10, 14]
+  "add11": [10, 14, 17]
+  "add13": [10, 14, 17, 21]

data/wtf_chord.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'wtf_chord/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "wtf_chord"
+  spec.version       = WTFChord::VERSION
+  spec.authors       = ["Anton"]
+  spec.email         = ["anton.estum@gmail.com"]
+
+  spec.summary       = %q{WTF Chord? is a Ruby Gem for generating guitar chords.}
+  spec.description   = %q{WTF Chord? provides the library and CLI-tool for generating guitar chords.}
+  spec.homepage      = "https://github.com/estum/wtf_chord"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", ">= 1.11", "< 2"
+  spec.add_development_dependency "rake", ">= 10.0", "< 12"
+  spec.add_development_dependency "rspec", ">= 3.0", "< 4"
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: wtf_chord
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Anton
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-03-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.11'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.11'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !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'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '12'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+description: WTF Chord? provides the library and CLI-tool for generating guitar chords.
+email:
+- anton.estum@gmail.com
+executables:
+- wtfchord
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/wtfchord
+- lib/wtf_chord.rb
+- lib/wtf_chord.yml
+- lib/wtf_chord/chord.rb
+- lib/wtf_chord/drawer.rb
+- lib/wtf_chord/fingerboard.rb
+- lib/wtf_chord/guitar_string.rb
+- lib/wtf_chord/note.rb
+- lib/wtf_chord/pitch.rb
+- lib/wtf_chord/rules.rb
+- lib/wtf_chord/scale.rb
+- lib/wtf_chord/version.rb
+- wtf_chord.gemspec
+homepage: https://github.com/estum/wtf_chord
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: WTF Chord? is a Ruby Gem for generating guitar chords.
+test_files: []
+has_rdoc: