fretboard 1.0.0 → 1.4.1

data/bin/fretboard

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+unless File.exist?('./Gemfile')
+  abort 'Please run fretboard from the root of the project'
+end
+
+require 'rubygems'
+
+begin
+  require 'bundler'
+  Bundler.setup
+rescue StandardError
+end
+
+$LOAD_PATH << "#{__dir__}/../lib"
+
+require 'fretboard/parser'
+
+Fretboard::Parser.parse(ARGV)

data/fretboard.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
@@ -14,12 +16,12 @@ Gem::Specification.new do |spec|
   spec.summary       = 'Tools for working with the guitar fretboard'
   spec.description   = 'Tools for working with the guitar fretboard'
 
-  spec.files         = `git ls-files -z *.md *.gemspec bin lib images`.split("\x0")
+  spec.files         = `git ls-files -z *.md *.gemspec bin lib`.split("\x0")
   spec.require_paths = ['lib']
 
-  # spec.executables   = ['fretboard']
+  spec.executables   = ['fretboard']
 
-  # spec.add_dependency 'colorize', '~> 0.8.1'
+  spec.add_dependency 'colorize', '~> 0.8.1'
   spec.add_dependency 'terminal-table', '~> 1.8.0'
-  spec.add_development_dependency 'rubocop', '= 0.88'
+  spec.add_development_dependency 'rubocop', '~> 1.3.0'
 end

data/lib/fretboard.rb

@@ -1,7 +1,10 @@
-require 'fretboard/constants'
+# frozen_string_literal: true
+
+require 'fretboard/builder'
+# require 'fretboard/constants'
 require 'fretboard/note'
 require 'fretboard/notes'
-require 'fretboard/builder'
+require 'fretboard/tunings'
 
 module Fretboard
   # extend Constants

data/lib/fretboard/builder.rb

@@ -1,33 +1,206 @@
-require 'terminal-table'
+# frozen_string_literal: true
+
+# require 'active_support/core_ext/hash'
+
+require 'fretboard/console'
 
 module Fretboard
   class Builder
     # fretboard = Fretboard::Builder.new(:standart)
     # fretboard = Fretboard::Builder.standart
+    # fretboard = Fretboard::Builder.tuning_a
+    # fretboard = Fretboard::Builder.open_a
+    # fretboard = Fretboard::Builder.drop_a
+    # fretboard = Fretboard::Builder.drop_a_sharp
+    # fretboard = Fretboard::Builder.drop_a_flat
+    # fretboard = Fretboard::Builder.tuning_b
+    # fretboard = Fretboard::Builder.open_b
+    # fretboard = Fretboard::Builder.drop_b
+    # fretboard = Fretboard::Builder.drop_b_flat
+    # fretboard = Fretboard::Builder.tuning_c
+    # fretboard = Fretboard::Builder.open_c
+    # fretboard = Fretboard::Builder.drop_c
+    # fretboard = Fretboard::Builder.tuning_d
+    # fretboard = Fretboard::Builder.open_d
+    # fretboard = Fretboard::Builder.open_d_minor
+    # fretboard = Fretboard::Builder.drop_d
+    # fretboard = Fretboard::Builder.double_drop_d
+    # fretboard = Fretboard::Builder.modal_d
+    # fretboard = Fretboard::Builder.open_e
+    # fretboard = Fretboard::Builder.tuning_f
+    # fretboard = Fretboard::Builder.open_f
+    # fretboard = Fretboard::Builder.tuning_g
+    # fretboard = Fretboard::Builder.open_g
+    # fretboard = Fretboard::Builder.open_g_minor
+    # fretboard = Fretboard::Builder.drop_g_sharp
+    # fretboard = Fretboard::Builder.modal_g
+
     # fretboard.build
     # fretboard.data
     # fretboard.draw
 
+    DEFAULT_NUMBER_OF_FRETS = 12
+
+    # METHODS_NAMES = %i[
+    #   standart
+    #   tuning_a
+    #   open_a
+    #   drop_a
+    #   drop_a_sharp
+    #   drop_a_flat
+    #   tuning_b
+    #   open_b
+    #   drop_b
+    #   drop_b_flat
+    #   tuning_c
+    #   open_c
+    #   drop_c
+    #   tuning_d
+    #   open_d
+    #   open_d_minor
+    #   drop_d
+    #   double_drop_d
+    #   modal_d
+    #   open_e
+    #   tuning_f
+    #   open_f
+    #   tuning_g
+    #   open_g
+    #   open_g_minor
+    #   drop_g_sharp
+    #   modal_g
+    # ].freeze
+
     attr_reader :data
 
-    def self.standart(number_of_frets = 12)
+    # METHODS_NAMES.each do |method_name|
+    #   define_method(method_name) do |number_of_frets = DEFAULT_NUMBER_OF_FRETS|
+    #     new(method_name, number_of_frets)
+    #   end
+    # end
+
+    def self.standart(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
       new(:standart, number_of_frets)
     end
 
-    def initialize(tuning, number_of_frets = 12)
+    def self.tuning_a(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:tuning_a, number_of_frets)
+    end
+
+    def self.open_a(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:open_a, number_of_frets)
+    end
+
+    def self.drop_a(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:drop_a, number_of_frets)
+    end
+
+    def self.drop_a_sharp(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:drop_a_sharp, number_of_frets)
+    end
+
+    def self.drop_a_flat(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:drop_a_flat, number_of_frets)
+    end
+
+    def self.tuning_b(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:tuning_b, number_of_frets)
+    end
+
+    def self.open_b(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:open_b, number_of_frets)
+    end
+
+    def self.drop_b(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:drop_b, number_of_frets)
+    end
+
+    def self.drop_b_flat(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:drop_b_flat, number_of_frets)
+    end
+
+    def self.tuning_c(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:tuning_c, number_of_frets)
+    end
+
+    def self.open_c(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:open_c, number_of_frets)
+    end
+
+    def self.drop_c(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:drop_c, number_of_frets)
+    end
+
+    def self.tuning_d(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:tuning_d, number_of_frets)
+    end
+
+    def self.open_d(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:open_d, number_of_frets)
+    end
+
+    def self.open_d_minor(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:open_d_minor, number_of_frets)
+    end
+
+    def self.drop_d(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:drop_d, number_of_frets)
+    end
+
+    def self.double_drop_d(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:double_drop_d, number_of_frets)
+    end
+
+    def self.modal_d(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:modal_d, number_of_frets)
+    end
+
+    def self.open_e(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:open_e, number_of_frets)
+    end
+
+    def self.tuning_f(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:tuning_f, number_of_frets)
+    end
+
+    def self.open_f(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:open_f, number_of_frets)
+    end
+
+    def self.tuning_g(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:tuning_g, number_of_frets)
+    end
+
+    def self.open_g(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:open_g, number_of_frets)
+    end
+
+    def self.open_g_minor(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:open_g_minor, number_of_frets)
+    end
+
+    def self.drop_g_sharp(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:drop_g_sharp, number_of_frets)
+    end
+
+    def self.modal_g(number_of_frets = DEFAULT_NUMBER_OF_FRETS)
+      new(:modal_g, number_of_frets)
+    end
+
+    def initialize(tuning, number_of_frets = DEFAULT_NUMBER_OF_FRETS)
       @tuning = tuning.upcase.to_sym
       @number_of_frets = number_of_frets
 
       @data = {}
     end
 
-    def build
-      unless Fretboard::Constants::GUITAR_TUNINGS.key?(@tuning)
-        puts 'Unable to detect guitar tuning'
+    def build(sharp_or_flat: :both)
+      unless Fretboard::Tunings.exists?(@tuning)
+        Fretboard::Console.danger('Unable to detect guitar tuning')
         return
       end
 
-      tuning = Fretboard::Constants::GUITAR_TUNINGS[@tuning]
+      tuning = Fretboard::Tunings.get(@tuning)
       strings = tuning[:STRINGS]
       number_of_strings = strings.size
 
@@ -47,8 +220,7 @@ module Fretboard
         (1..@number_of_frets).each do |fret|
           next_note = Fretboard::Note.next_for(
             current_note,
-            sharp_or_flat: :both,
-            formated: true
+            sharp_or_flat: sharp_or_flat
           )
 
           puts "Fret: #{fret} (#{next_note})"
@@ -63,7 +235,12 @@ module Fretboard
       puts 'done'
     end
 
-    def draw
+    def draw(sharp_or_flat: :both)
+      unless @data.any?
+        Fretboard::Console.danger('Create the data')
+        return
+      end
+
       headings = []
       rows = []
 
@@ -74,7 +251,21 @@ module Fretboard
         row << string_number
 
         headings << 0
-        row << string_notes[0]
+
+        open_note = string_notes[0]
+
+        if open_note.is_a?(Array)
+          open_note = case sharp_or_flat
+                      when :both
+                        open_note.join('/')
+                      when :sharp
+                        open_note.first
+                      else
+                        open_note.last
+                      end
+        end
+
+        row << open_note
 
         string_notes.except(0).each_pair do |fret, note|
           headings << fret
@@ -84,13 +275,7 @@ module Fretboard
         rows << row
       end
 
-      table = Terminal::Table.new(
-        headings: headings.uniq,
-        rows: rows,
-        style: { border_x: '~', border_i: '~' }
-      )
-
-      puts table
+      Fretboard::Console.print_table(headings.uniq, rows)
 
       nil
     end

data/lib/fretboard/console.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'colorize'
+require 'terminal-table'
+
+module Fretboard
+  class Console
+    def self.log(text)
+      new(text, nil).print
+    end
+
+    # def self.success(text)
+    #   new(text, :green).print
+    # end
+
+    # def self.warning(text)
+    #   new(text, :yellow).print
+    # end
+
+    def self.danger(text)
+      new(text, :red).print
+    end
+
+    def self.print_table(headings, rows)
+      table = Terminal::Table.new(
+        headings: headings,
+        rows: rows,
+        style: { border_x: '~', border_i: '~' }
+      )
+
+      new(table.to_s, nil).print
+    end
+
+    def initialize(text, color = nil)
+      @text = text
+      @color = color
+    end
+
+    def print
+      puts @text.colorize(@color)
+    end
+  end
+end

data/lib/fretboard/constants.rb

@@ -1,44 +1,7 @@
+# frozen_string_literal: true
+
 module Fretboard
   module Constants
     # Fretboard::Constants.constants
-
-    # SPN   =>  Scientific pitch notation
-
-    GUITAR_TUNINGS = {
-      STANDART: {
-        STRINGS: {
-          1 => {
-            NOTE: 'E',
-            FREQUENCY: '329.63 Hz',
-            SPN: 'E4'
-          },
-          2 => {
-            NOTE: 'B',
-            FREQUENCY: '246.94 Hz',
-            SPN: 'B3'
-          },
-          3 => {
-            NOTE: 'G',
-            FREQUENCY: '196.00 Hz',
-            SPN: 'G3'
-          },
-          4 => {
-            NOTE: 'D',
-            FREQUENCY: '146.83 Hz',
-            SPN: 'D3'
-          },
-          5 => {
-            NOTE: 'A',
-            FREQUENCY: '110.00 Hz',
-            SPN: 'A2'
-          },
-          6 => {
-            NOTE: 'E',
-            FREQUENCY: '82.41 Hz',
-            SPN: 'E2'
-          }
-        }
-      }
-    }.freeze
   end
 end

data/lib/fretboard/note.rb

@@ -1,15 +1,29 @@
+# frozen_string_literal: true
+
 require 'fretboard/notes'
 
 module Fretboard
   class Note
     # Fretboard::Note.next_for('C')
+    # Fretboard::Note.next_for(['F#', 'Gb'])
+    # Fretboard::Note.next_for('F#/Gb')
 
-    def self.next_for(note, sharp_or_flat: :sharp, formated: false)
+    def self.next_for(note, sharp_or_flat: :both)
       all_notes = Fretboard::Notes.all(
-        sharp_or_flat,
-        formated: formated
+        sharp_or_flat
       )
 
+      if note.is_a?(Array)
+        note = case sharp_or_flat
+               when :both
+                 note.join('/')
+               when :sharp
+                 note.first
+               else
+                 note.last
+               end
+      end
+
       current_index = all_notes.find_index(note)
       next_index = current_index + 1
 
@@ -19,24 +33,8 @@ module Fretboard
       next_note
     end
 
-    def self.formated(note)
-      new(note).formated
-    end
-
     def initialize(note)
       @note = note
     end
-
-    def formated
-      result = @note
-
-      result = result.gsub('sharp', '#') if result.include?('sharp')
-
-      if result.include?('flat')
-        result = result.gsub('flat', 'b') # ♭
-      end
-
-      result.gsub(' ', '')
-    end
   end
 end