guitar 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6e822498b88eaac759d7a60a16da3fc580fc58cf
+  data.tar.gz: 3de594c37f1be97abe2e5f4949608248e5888c93
+SHA512:
+  metadata.gz: b7659c74f7b4aec9ed7cceeb98b6ee76615cfb987b48f9ae4f8e5ff4510e0dcc2a0f2c940dfa6ed00f515e349680209256b5008f5c973909c98c68f1d873341e
+  data.tar.gz: e377a4713a19a16aee5837be3360edb490e25d2a9bdc404a43dda66f616a7664e898aa879f5f0385f53875006d85eccb641c4beec290a1fdfba5a2fe1d438998

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.0
+before_install: gem install bundler -v 1.16.0

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in guitar.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    guitar (0.2.0)
+      colorize (>= 0.8.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    colorize (0.8.1)
+    minitest (5.9.1)
+    rake (10.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  guitar!
+  minitest (~> 5.0)
+  rake (~> 10.0)
+
+BUNDLED WITH
+   1.16.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Xin Luo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# Guitar
+
+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/guitar`. 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 'guitar'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install guitar
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+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]/guitar.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'guitar/commands/console'

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

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+git_path = File.expand_path('../../.git', __FILE__)
+
+if File.exist?(git_path)
+  lib_path = File.expand_path('../../lib', __FILE__)
+  $:.unshift(lib_path)
+end
+
+require 'guitar/commands'

data/guitar.gemspec

@@ -0,0 +1,28 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "guitar/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "guitar"
+  spec.version       = Guitar::VERSION
+  spec.authors       = ["Xin Luo"]
+  spec.email         = ["luoxin.net@gmail.com"]
+
+  spec.summary       = %q{Guitar learning assistant.}
+  spec.description   = %q{Learn guitar the programmer's way.}
+  spec.homepage      = "http://luoxin.net"
+  spec.license       = "MIT"
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency('colorize', '~> 0.8.1')
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

data/lib/guitar/commands/console.rb

@@ -0,0 +1,5 @@
+require 'irb'
+require 'guitar'
+
+include Guitar
+IRB.start(__FILE__)

data/lib/guitar/commands/practice.rb

@@ -0,0 +1,85 @@
+require 'optparse'
+
+module Guitar
+  module Commands
+    class Practice
+      def run(args = ARGV)
+        options = {}
+
+        parser = OptionParser.new do |opts|
+          opts.banner = 'Usage: guitar practice LESSON [OPTIONS]'
+          opts.separator ''
+
+          opts.on(
+            '-s', '--size=size', Integer,
+            'Specifies the guitar fret size.'
+          ) { |v| options[:size] = v }
+
+          opts.on(
+            '-c', '--color=color', ::String,
+            'Specifies the show color.'
+          ) { |v| options[:color] = v }
+
+          opts.on(
+            '-i', '--interval=interval', Float,
+            'Specifies the practice loop interval.'
+          ) { |v| options[:interval] = v }
+
+          opts.on(
+            '-h', '--help',
+            'Show this help message.'
+          ) { puts opts; exit }
+
+          opts.separator ''
+          opts.separator 'Available LESSONS:'
+          opts.separator ''
+          opts.separator '     1. Random NOTE(natural).'
+          opts.separator '     2. Random NOTE.'
+          opts.separator ''
+          opts.separator '     3. Random NOTE(natural) in random STRING.'
+          opts.separator '     4. Random NOTE in random STRING.'
+          opts.separator ''
+          opts.separator '     5. Random NOTE(natural) in random FRET(2/5/7/10/12).'
+          opts.separator '     6. Random NOTE(natural) in random FRET.'
+          opts.separator '     7. Random NOTE in random FRET(2/5/7/10/12).'
+          opts.separator '     8. Random NOTE in random FRET.'
+          opts.separator ''
+          opts.separator '     9. Random NOTE(natural) in FRETBOARD.'
+          opts.separator '    10. Random NOTE in FRETBOARD.'
+        end
+        parser.parse!(args)
+
+        case args[0].to_i
+        when 1
+          options.merge!(natural: true)
+          Guitar::Practice.new(options).random_note
+        when 2
+          Guitar::Practice.new(options).random_note
+        when 3
+          options.merge!(natural: true)
+          Guitar::Practice.new(options).random_note_in_random_string
+        when 4
+          Guitar::Practice.new(options).random_note_in_random_string
+        when 5
+          options.merge!(natural: true, fret: [2, 5, 7, 10, 12])
+          Guitar::Practice.new(options).random_note_in_random_fret
+        when 6
+          options.merge!(natural: true)
+          Guitar::Practice.new(options).random_note_in_random_fret
+        when 7
+          options.merge!(fret: [2, 5, 7, 10, 12])
+          Guitar::Practice.new(options).random_note_in_random_fret
+        when 8
+          Guitar::Practice.new(options).random_note_in_random_fret
+        when 9
+          options.merge!(natural: true)
+          Guitar::Practice.new(options).random_note_in_fretboard
+        when 10
+          Guitar::Practice.new(options).random_note_in_fretboard
+        else
+          puts parser
+        end
+      end
+    end
+  end
+end

data/lib/guitar/commands/tonic_shape.rb

@@ -0,0 +1,49 @@
+require 'optparse'
+
+module Guitar
+  module Commands
+    class TonicShape
+      def run(args = ARGV)
+        size    = 15
+        options = {}
+
+        parser = OptionParser.new do |opts|
+          opts.banner = 'Usage: guitar tonic_shape TONIC SHAPE [OPTIONS]'
+          opts.separator ''
+          opts.separator 'TONIC examples:   ["C", "D#", "Ab"]'
+          opts.separator 'Available SHAPES: ["<", ">", "/\", "\", "/<"]'
+          opts.separator ''
+
+          opts.on(
+            '-s', '--size=size', Integer,
+            'Specifies the guitar fret size.'
+          ) { |v| size = v }
+
+          opts.on(
+            '-a', '--as=as', ::String,
+            'Specifies the show type [pretty_name, finger, degree].'
+          ) { |v| options[:as] = v }
+
+          opts.on(
+            '-c', '--color=color', ::String,
+            'Specifies the show color.'
+          ) { |v| options[:color] = v.split(',') }
+
+          opts.on(
+            '-h', '--help',
+            'Show this help message.'
+          ) { puts opts; exit }
+        end
+        parser.parse!(args)
+
+        if tonic = args[0]
+          f = Guitar::Fretboard.new(size)
+          f.desc = "The tonic shape of #{tonic.to_n.name} major".bold
+          puts f.show_tonic_shape(tonic, args[1], options).inspect
+        else
+          puts parser
+        end
+      end
+    end
+  end
+end

data/lib/guitar/commands.rb

@@ -0,0 +1,45 @@
+require 'guitar'
+
+trap('INT') { exit }
+
+commands = %w(
+  -help    --help
+  -version --version
+  console
+  practice
+  tonic_shape
+)
+
+help = <<-HELP
+Usage: guitar COMMAND [ARGS]
+
+The available guitar commands are:
+
+    console          Start the console      (short-cut alias: "c")
+    practice         Do practice            (short-cut alias: "p")
+    tonic_shape      Show tonic shapes      (short-cut alias: "t")
+
+All commands can be run with -h (or --help) for more information.
+HELP
+
+if command = commands.detect { |c| c =~ /^#{ARGV.first}/ }
+  ARGV.shift
+
+  case command
+  when '-help', '--help'
+    puts help
+  when '-version', '--version'
+    puts "guitar #{Guitar::VERSION}"
+  when 'console'
+    require 'guitar/commands/console'
+  when 'practice'
+    require 'guitar/commands/practice'
+    Guitar::Commands::Practice.new.run
+  when 'tonic_shape'
+    require 'guitar/commands/tonic_shape'
+    Guitar::Commands::TonicShape.new.run
+  end
+else
+  puts "### Error: Command '#{ARGV.first}' can not be recognized ###"
+  puts help
+end

data/lib/guitar/common.rb

@@ -0,0 +1,38 @@
+module Guitar
+  module Common
+    def make_change(&b)
+      if @in_change
+        b.call
+      else
+        @in_change = true
+        record_change(&b)
+        @in_change = false
+      end
+
+      self
+    end
+
+    private
+
+    # index and range all start from 1, for they are fret or string
+    # in?(1, 1); in?(2, 1..3); in?(3, [3, 4, 5]); in?(1, nil)
+    def in?(index, range)
+      if range
+        range = [range] unless range.respond_to?(:include?)
+        range.include?(index)
+      else
+        true
+      end
+    end
+
+    def colorize(str, color)
+      if color.is_a?(Array)
+        color.inject(str) { |s, c| s.send(c) }
+      elsif color
+        str.send(color)
+      else
+        str
+      end
+    end
+  end
+end

data/lib/guitar/core_ext/object.rb

@@ -0,0 +1,5 @@
+class Object
+  def to_n
+    self.is_a?(Guitar::Note) ? self : Guitar::Note.new(self)
+  end
+end

data/lib/guitar/fretboard.rb

@@ -0,0 +1,84 @@
+require 'guitar/common'
+require 'guitar/tonic_shape'
+
+module Guitar
+  class Fretboard
+    include Common
+    include TonicShape
+
+    attr_reader :size, :strings, :changes
+    attr_accessor :desc
+
+    def initialize(size = DEFAULT_SIZE, desc: nil)
+      @size = size
+      @desc = desc
+      @changes = []
+      @strings = [
+        String.new(:E5, Guitar.get_frets(1, size)),
+        String.new(:B4, Guitar.get_frets(2, size)),
+        String.new(:G4, Guitar.get_frets(3, size)),
+        String.new(:D4, Guitar.get_frets(4, size)),
+        String.new(:A3, Guitar.get_frets(5, size)),
+        String.new(:E3, Guitar.get_frets(6, size))
+      ]
+    end
+
+    def show_notes(notes = nil, string: nil, fret: nil, color: nil, &b)
+      make_change do
+        @strings.each_with_index do |s, i|
+          if in?(i + 1, string)
+            if block_given?
+              s.show_notes(notes, fret: fret, color: color) do |n, f|
+                b.call(n, i + 1, f)
+              end
+            else
+              s.show_notes(notes, fret: fret, color: color)
+            end
+          end
+        end
+      end
+    end
+
+    def mark(content = nil, string: nil, fret: nil, color: nil)
+      make_change do
+        @strings.each_with_index do |s, i|
+          s.mark(content, fret: fret, color: color) if in?(i + 1, string)
+        end
+      end
+    end
+
+    def undo
+      if last_change = changes.pop
+        last_change.each { |i| @strings[i].undo }
+      end
+
+      self
+    end
+
+    def clear
+      @strings.each(&:clear)
+      changes.clear
+      self
+    end
+
+    def inspect
+      string_lines = @strings.collect(&:inspect).join("\n")
+      point_lines  = ASCII_ARRAY.last[0...(WIDTH * @size)]
+
+      "#@desc\n#{string_lines}\n  #{point_lines}"
+    end
+
+    private
+
+    def record_change(&b)
+      before = @strings.collect { |s| s.changes.size }
+      b.call
+    ensure
+      after = @strings.collect { |s| s.changes.size }
+
+      change = []
+      after.each_with_index { |e, i| (e - before[i]).times { change << i } }
+      changes << change if change.size > 0
+    end
+  end
+end

data/lib/guitar/note.rb

@@ -0,0 +1,149 @@
+module Guitar
+  class Note
+    include Comparable
+
+    DEFAULT_OCTAVE = 4
+
+    # http://newt.phys.unsw.edu.au/jw/notes.html
+    MIDI_NUMBERS = {
+      'C'  => 60,
+      'C♯' => 61,
+      'D♭' => 61,
+      'D'  => 62,
+      'D♯' => 63,
+      'E♭' => 63,
+      'E'  => 64,
+      'F'  => 65,
+      'F♯' => 66,
+      'G♭' => 66,
+      'G'  => 67,
+      'G♯' => 68,
+      'A♭' => 68,
+      'A'  => 69,
+      'A♯' => 70,
+      'B♭' => 70,
+      'B'  => 71
+    }
+
+    attr_reader :name, :octave, :number
+    alias_method :to_i, :number
+
+    NOTE_PATTERN  = /\A([a-gA-G][#b♯♭]?)(\d)?\z/
+    NATURAL_NOTES = %w(A B C D E F G).freeze
+
+    # A0..C8
+    def self.random(natural = false)
+      if natural
+        new("#{NATURAL_NOTES.sample}#{rand(0..8)}")
+      else
+        new(rand(21..108)).tap { |n| n.alias! if rand(0..1) == 0 }
+      end
+    end
+
+    def initialize(note)
+      case note
+      when Integer
+        init_with_number(note)
+      else
+        note = note.to_s
+
+        if note =~ NOTE_PATTERN
+          init_with_name_and_octave($1, $2 || DEFAULT_OCTAVE)
+        else
+          fail "invalid note #{note}"
+        end
+      end
+    end
+
+    def -(other)
+      case other
+      when Note
+        @number - other.number
+      when Integer
+        self.class.new(@number - other)
+      else
+        fail "invalid operation with #{other}"
+      end
+    end
+
+    def +(other)
+      case
+      when Integer
+        self.- (-other)
+      else
+        fail "invalid operation with #{other}"
+      end
+    end
+
+    def <=>(other)
+      if other.respond_to?(:to_i)
+        to_i <=> other.to_i
+      else
+        super
+      end
+    end
+
+    def ===(other)
+      if other.is_a?(Note)
+        (self - other) % 12 == 0
+      else
+        super
+      end
+    end
+
+    def inspect
+      "#{@name}#{@octave}"
+    end
+
+    PRETTY_NAMES = {
+      'C' => 'Ⓒ ',
+      'D' => 'Ⓓ ',
+      'E' => 'Ⓔ ',
+      'F' => 'Ⓕ ',
+      'G' => 'Ⓖ ',
+      'A' => 'Ⓐ ',
+      'B' => 'Ⓑ '
+    }
+
+    def pretty_name
+      if @name.size == 1
+        PRETTY_NAMES[@name]
+      else
+        "#{PRETTY_NAMES[@name[0]].strip}#{@name[1..-1]}"
+      end
+    end
+
+    def alias!
+      new_name, _ = MIDI_NUMBERS.find do |k, v|
+        n = 60 + (@number % 12)
+        v == n && k != name
+      end
+
+      @name = new_name if new_name
+    end
+
+    def scale(name = :major)
+      Scale.new(self, name)
+    end
+
+    private
+
+    def init_with_name_and_octave(name, octave)
+      @name   = name.to_s.capitalize.sub('#', '♯').sub('b', '♭')
+      @octave = octave.to_i
+
+      if number = MIDI_NUMBERS[@name]
+        @number = number + (@octave - DEFAULT_OCTAVE) * 12
+      else
+        fail "the note name #{name} is not valid"
+      end
+    end
+
+    def init_with_number(number)
+      octave = ((number - 60) / 12) + DEFAULT_OCTAVE
+      name   = MIDI_NUMBERS.key(60 + (number % 12))
+
+      init_with_name_and_octave(name, octave)
+    end
+  end
+end

data/lib/guitar/practice.rb

@@ -0,0 +1,82 @@
+require 'io/console'
+
+module Guitar
+  class Practice
+    attr_reader :size, :interval, :natural, :color, :string, :fret
+
+    def initialize(size: 13, interval: 1, natural: false, color: nil,
+                   string: 1..6, fret: 1..size)
+      @size     = size
+      @interval = interval
+      @natural  = natural
+      @color    = color
+      @string   = string.to_a
+      @fret     = fret.to_a
+    end
+
+    def random_note
+      loop_and_print { Note.random(natural).name }
+    end
+
+    def random_note_in_random_string
+      loop_and_print { "#{Note.random(natural).name} in string #{string.sample}" }
+    end
+
+    def random_note_in_random_fret
+      loop_and_print { "#{Note.random(natural).name} in fret #{fret.sample}" }
+    end
+
+    def random_note_in_fretboard
+      f = Guitar::Fretboard.new
+
+      loop do
+        clear_screen
+        f.clear
+
+        note, string = Note.random(natural), self.string.sample
+        puts f.show_notes(note, string: string, color: color) { 'X' }.inspect
+        print 'Please input the current note: '
+
+        begin
+          correct = Note.new(STDIN.gets.strip) === note
+
+          if correct
+            clear_screen
+            print f.show_notes(note, string: string, color: :green).inspect
+            sleep interval
+          else
+            print_error(f, note, string)
+          end
+        rescue
+          print_error(f, note, string)
+        end
+      end
+    end
+
+    private
+
+    def clear_screen
+      print "\x1b[2J\x1b[1;1H"
+    end
+
+    def loop_and_print(&b)
+      loop do
+        clear_screen
+        current = b.call
+        current = current.send(color) if color && current.respond_to?(color)
+
+        if current != @last
+          print @last = current
+          sleep interval
+        end
+      end
+    end
+
+    def print_error(fretboard, note, string)
+      clear_screen
+      print fretboard.show_notes(note, string: string, color: :red).inspect
+      print "\nPress ENTER to continue ..."
+      STDIN.gets
+    end
+  end
+end

data/lib/guitar/scale.rb

@@ -0,0 +1,42 @@
+module Guitar
+  class Scale
+    attr_reader :tonic, :type, :notes, :steps
+
+    STEPS = {
+      :major => [2, 2, 1, 2, 2, 2, 1].freeze,
+      :minor => [2, 1, 2, 2, 1, 2, 2].freeze
+    }
+
+    STEPS[:maj] = STEPS[:major]
+    STEPS[:m]   = STEPS[:minor]
+
+    def initialize(tonic = :C, type = :major)
+      type = type.to_sym
+
+      if steps = STEPS[type]
+        @type  = type
+        @steps = steps
+        @tonic = tonic.to_n
+      else
+        fail "the scale type #{type} is not valid"
+      end
+
+      @notes = @steps[0..-2].inject([@tonic]) do |ns, s|
+        last = ns.last
+        current = last + s
+        current.alias! if current.name.to_s[0] == last.name.to_s[0]
+        ns << current
+      end
+    end
+
+    def degree(note)
+      note = note.to_n
+      index = @notes.find_index { |n| note === n }
+      index && (index + 1)
+    end
+
+    def note_names
+      @notes.map(&:name)
+    end
+  end
+end

data/lib/guitar/string.rb

@@ -0,0 +1,102 @@
+require 'guitar/common'
+
+module Guitar
+  class String
+    include Common
+
+    attr_reader :note, :notes, :frets, :changes
+
+    def initialize(note, frets = Guitar.get_frets)
+      @note    = note.to_n
+      @frets   = frets
+      @notes   = size.times.inject([]) { |r, i| r << (@note + i + 1) }
+      @changes = []
+    end
+
+    def size
+      frets.size
+    end
+
+    def show_notes(notes = nil, fret: nil, color: nil, &b)
+      make_change do
+        if notes
+          show_given_notes(notes, fret, color, &b)
+        else
+          show_all_notes(fret, color, &b)
+        end
+      end
+    end
+
+    def mark(content = nil, fret: nil, color: nil)
+      make_change do
+        size.times { |i| mark_fret(i, content, color) if in?(i + 1, fret) }
+      end
+    end
+
+    def undo
+      if changes.size > 0
+        @frets = changes.pop
+      end
+
+      self
+    end
+
+    def clear
+      if changes.size > 0
+        @frets = changes[0]
+        changes.clear
+      end
+
+      self
+    end
+
+    def inspect
+      "#{@note.name} #{@frets.join('')}"
+    end
+
+    private
+
+    def mark_fret(i, e, color = nil)
+      if e
+        e = e.to_s
+        s = e.uncolorize.size
+        fail "#{e} is too long, the size should < #{WIDTH}" if s >= WIDTH
+
+        start_index = (WIDTH - s + 2) / 2
+        end_index   = (-WIDTH + s) / 2
+
+        @frets[i] = (@changes[0] ? @changes[0][i] : @frets[i]).dup
+        @frets[i][start_index..end_index] = colorize(e, color)
+      else
+        @frets[i] = colorize(@frets[i], color)
+      end
+    end
+
+    def record_change(&b)
+      old = @frets.dup
+      b.call
+    ensure
+      @changes << old if @frets != old
+    end
+
+    def show_all_notes(fret, color, &b)
+      @notes.each_with_index do |e, i|
+        if in?(i + 1, fret)
+          m = block_given? ? b.call(e, i + 1) : e.name
+          mark_fret(i, m, color)
+        end
+      end
+    end
+
+    def show_given_notes(notes, fret, color, &b)
+      notes = notes.respond_to?(:map) ? notes.map(&:to_n) : [notes.to_n]
+
+      @notes.each_with_index do |e, i|
+        if in?(i + 1, fret) && note = notes.find { |n| e === n }
+          m = block_given? ? b.call(note, i + 1) : note.name
+          mark_fret(i, m, color)
+        end
+      end
+    end
+  end
+end

data/lib/guitar/tonic_shape.rb

@@ -0,0 +1,173 @@
+module Guitar
+  module TonicShape
+    # E ╓─────┬─────┬─────┬─────┬─────┬─────┬─────┬──Ⓒ ─┬─────┬─────┬─────┬────
+    # B ╟─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼────
+    # G ╟─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼────
+    # D ╟─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼──Ⓒ ─┼─────┼────
+    # A ╟─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼────
+    # E ╙─────┴─────┴─────┴─────┴─────┴─────┴─────┴──Ⓒ ─┴─────┴─────┴─────┴────
+    #                  𝇈           𝇈           𝇈           𝇈                𝇈 𝇈
+    SHAPE_RIGHT_TRIANGLE = '>'
+
+    # E ╓─────┬─────┬─────┬─────┬─────┬─────┬─────┬──Ⓒ ─┬─────┬─────┬─────┬────
+    # B ╟─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼────
+    # G ╟─────┼─────┼─────┼─────┼──Ⓒ ─┼─────┼─────┼─────┼─────┼─────┼─────┼────
+    # D ╟─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼────
+    # A ╟─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼────
+    # E ╙─────┴─────┴─────┴─────┴─────┴─────┴─────┴──Ⓒ ─┴─────┴─────┴─────┴────
+    #                  𝇈           𝇈           𝇈           𝇈                𝇈 𝇈
+    SHAPE_LEFT_TRIANGLE = '<'
+
+    # E ╓─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬────
+    # B ╟─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼────
+    # G ╟─────┼─────┼─────┼─────┼──Ⓒ ─┼─────┼─────┼─────┼─────┼─────┼─────┼────
+    # D ╟─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼────
+    # A ╟─────┼─────┼──Ⓒ ─┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼────
+    # E ╙─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴────
+    #                  𝇈           𝇈           𝇈           𝇈                𝇈 𝇈
+    SHAPE_SLASH_BEFORE_TRIANGLE = '/<'
+
+    # E ┄┄┬─────┬─────┬─────╥─────┬──
+    # B ┄┄┼─────┼─────┼─────╫──Ⓒ ─┼──
+    # G ┄┄┼─────┼─────┼─────╫─────┼──
+    # D ┄┄┼──Ⓒ ─┼─────┼─────╫─────┼──
+    # A ┄┄┼─────┼─────┼─────╫─────┼──
+    # E ┄┄┴─────┴─────┴─────╨─────┴──
+    #                   𝇈 𝇈
+    SHAPE_SLASH_BEFORE_BACKSLASH = '/\\'
+
+    # E ┄┄┄┄┄╥─────┬─────┬─────┬─────
+    # B ┄┄┄┄┄╫──Ⓒ ─┼─────┼─────┼─────
+    # G ┄┄┄┄┄╫─────┼─────┼─────┼─────
+    # D ┄┄┄┄┄╫─────┼─────┼─────┼─────
+    # A ┄┄┄┄┄╫─────┼─────┼──Ⓒ ─┼─────
+    # E ┄┄┄┄┄╨─────┴─────┴─────┴─────
+    #    𝇈 𝇈                𝇈
+    SHAPE_BACKSLASH = '\\'
+
+    AS_PRETTY_NAME = :pretty_name
+    AS_DEGREE      = :degree
+    AS_FINGER      = :finger
+
+    DEGREES = %w(⑴  ⑵  ⑶  ⑷  ⑸  ⑹  ⑺)
+    FINGERS = %w(①  ②  ③  ④)
+
+    # TODO choose scale: major, minor ...
+    def show_tonic_shape(tonic, shape = nil, as: nil, color: [[:red, :bold], :yellow])
+      scale  = tonic.to_n.scale
+
+      case shape.to_s
+      when SHAPE_RIGHT_TRIANGLE
+        show_tonic_shape_right_triangle(as, scale, color)
+      when SHAPE_LEFT_TRIANGLE
+        show_tonic_shape_left_triangle(as, scale, color)
+      when SHAPE_BACKSLASH
+        show_tonic_shape_backslash(as, scale, color)
+      when SHAPE_SLASH_BEFORE_TRIANGLE
+        show_tonic_shape_slash_before_triangle(as, scale, color)
+      when SHAPE_SLASH_BEFORE_BACKSLASH
+        show_tonic_shape_slash_before_backslash(as, scale, color)
+      else
+        show_all_tonic_shapes(as, scale, color)
+      end
+    end
+
+    private
+
+    def show_all_tonic_shapes(as, scale, color)
+      show_notes(scale.notes) do |n|
+        get_note_in_tonic_shape(n, as, scale, color)
+      end
+    end
+
+    def show_tonic_shape_right_triangle(as, scale, color)
+      fret = strings[5].notes.find_index { |n| n === scale.tonic } + 1
+      fret += 12 if fret < 2
+
+      show_notes(scale.notes, fret: (fret - 1)..(fret + 2)) do |n, _, f|
+        get_note_in_tonic_shape(n, as, scale, color, f - fret + 1)
+      end
+    end
+
+    def show_tonic_shape_left_triangle(as, scale, color)
+      fret = strings[5].notes.find_index { |n| n === scale.tonic } + 1
+      fret += 12 if fret < 5
+
+      show_notes(scale.notes, fret: (fret - 4)..fret) do |n, s, f|
+        get_note_in_tonic_shape(n, as, scale, color,
+                                get_finger_in_left_triangle(s, fret, f))
+      end
+    end
+
+    def get_finger_in_left_triangle(string, root_fret, current_fret)
+      if string == 3
+        current_fret - root_fret + 4
+      else
+        current_fret - root_fret + 3
+      end
+    end
+
+    def show_tonic_shape_backslash(as, scale, color)
+      fret = strings[4].notes.find_index { |n| n === scale.tonic } + 1
+      fret += 12 if fret < 4
+
+      show_notes(scale.notes, fret: (fret - 3)..fret) do |n, _, f|
+        get_note_in_tonic_shape(n, as, scale, color, f - fret + 3)
+      end
+    end
+
+    def show_tonic_shape_slash_before_triangle(as, scale, color)
+      fret = strings[4].notes.find_index { |n| n === scale.tonic } + 1
+      fret += 12 if fret < 2
+
+      show_notes(scale.notes, fret: (fret - 1)..(fret + 3)) do |n, s, f|
+        get_note_in_tonic_shape(n, as, scale, color,
+                                get_finger_in_slash_before_triangle(s, fret, f))
+      end
+    end
+
+    def get_finger_in_slash_before_triangle(string, root_fret, current_fret)
+      if string < 3
+        current_fret - root_fret
+      else
+        current_fret - root_fret + 1
+      end
+    end
+
+    def show_tonic_shape_slash_before_backslash(as, scale, color)
+      fret = strings[3].notes.find_index { |n| n === scale.tonic } + 1
+      fret += 12 if fret < 2
+
+      show_notes(scale.notes, fret: (fret - 1)..(fret + 3)) do |n, s, f|
+        get_note_in_tonic_shape(n, as, scale, color,
+                                get_finger_in_slash_before_backslash(s, fret, f))
+      end
+    end
+
+    def get_finger_in_slash_before_backslash(string, root_fret, current_fret)
+      if string < 3 || string > 4
+        current_fret - root_fret
+      else
+        current_fret - root_fret + 1
+      end
+    end
+
+    def get_note_in_tonic_shape(note, as, scale, color, finger = nil)
+      str = case as && as.to_sym
+            when nil, AS_PRETTY_NAME
+              note.pretty_name
+            when AS_DEGREE
+              DEGREES[scale.degree(note) - 1] + ' '
+            when AS_FINGER
+              finger ? FINGERS[finger] + ' ' : '⓿ '
+            else
+              note.name
+            end
+
+      color = [color] unless color.is_a?(Array)
+      color = note === scale.tonic ? color[0] : color[1]
+
+      colorize(str, color)
+    end
+  end
+end

data/lib/guitar/version.rb

@@ -0,0 +1,3 @@
+module Guitar
+  VERSION = '0.2.0'
+end

data/lib/guitar.rb

@@ -0,0 +1,31 @@
+require 'colorize'
+
+require 'guitar/version'
+require 'guitar/note'
+require 'guitar/scale'
+require 'guitar/string'
+require 'guitar/fretboard'
+require 'guitar/practice'
+
+require 'guitar/core_ext/object'
+
+module Guitar
+  ASCII_ARRAY = '
+╓─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────╥─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────╖
+╟─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────╫─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────╢
+╟─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────╫─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────╢
+╟─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────╫─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────╢
+╟─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────╫─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────╢
+╙─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────╨─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────╜
+               𝇈           𝇈           𝇈           𝇈                𝇈 𝇈                𝇈           𝇈           𝇈           𝇈                𝇈 𝇈
+  '.split("\n")[1..-2].freeze
+
+  # Fretboard count
+  DEFAULT_SIZE = 13
+  # Text count in one fret
+  WIDTH = 6
+
+  def self.get_frets(string_number = 2, size = DEFAULT_SIZE)
+    ASCII_ARRAY[string_number - 1].scan(/.{#{WIDTH}}/)[0...size]
+  end
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: guitar
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Xin Luo
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-12-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Learn guitar the programmer's way.
+email:
+- luoxin.net@gmail.com
+executables:
+- guitar
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/guitar
+- guitar.gemspec
+- lib/guitar.rb
+- lib/guitar/commands.rb
+- lib/guitar/commands/console.rb
+- lib/guitar/commands/practice.rb
+- lib/guitar/commands/tonic_shape.rb
+- lib/guitar/common.rb
+- lib/guitar/core_ext/object.rb
+- lib/guitar/fretboard.rb
+- lib/guitar/note.rb
+- lib/guitar/practice.rb
+- lib/guitar/scale.rb
+- lib/guitar/string.rb
+- lib/guitar/tonic_shape.rb
+- lib/guitar/version.rb
+homepage: http://luoxin.net
+licenses:
+- MIT
+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.6.8
+signing_key: 
+specification_version: 4
+summary: Guitar learning assistant.
+test_files: []
+has_rdoc: