coltrane 2.2.1 → 3.0.0.pre

data/lib/cli/bass_guitar.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  module Cli
-    # Renders notes in a bass guitar scheme
-    class BassGuitar < Guitar
-      def initialize(notes, tuning: %w[E A D G])
-        super
-      end
-    end
-  end
-end

data/lib/cli/chord.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  module Cli
-    # Interfaces chord functionality with the lib
-    class Chord
-      def initialize(*chords, notes: nil)
-        Cli.config do |c|
-          if c.on == :guitar
-            c.on = :guitar_chords
-          elsif c.on == :guitar_arm
-            c.on = :guitar
-          end
-        end
-
-        @chords =
-          if !chords.empty?
-            if chords[0].is_a?(String)
-              chords.map { |c| Coltrane::Chord.new(name: c) }
-            else
-              chords
-            end
-          elsif !notes.nil?
-            [Coltrane::Chord.new(notes: notes)]
-          end
-
-        raise BadChordError unless @chords
-
-        @chords.each do |chord|
-          desc = "#{chord.name} chord:"
-          Coltrane::Cli::Notes.new chord.notes, desc: desc
-          # ColtraneSynth::Base.play(chord, 1) if Cli.config.sound
-        end
-      end
-    end
-  end
-end
-
-# rubocop:enable Metrics/MethodLength

data/lib/cli/config.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  module Cli
-    class Config
-      DEFAULTS = {
-        flavor: :notes,
-        sound: false,
-        on: :text
-      }.freeze
-
-      attr_accessor :flavor, :degrees, :sound
-      attr_reader :on
-
-      def initialize(defaults = DEFAULTS)
-        defaults.each do |key, val|
-          instance_variable_set(:"@#{key}", val)
-        end
-      end
-
-      def on=(instrument)
-        @on = case instrument
-              when :ukelele then :ukulele
-              when :bass then :bass_guitar
-              else instrument
-              end
-      end
-    end
-
-    def self.config
-      @config = Config.new if @config.nil?
-      block_given? ? yield(@config) : @config
-    end
-
-    def self.erase_config
-      @config = nil
-    end
-  end
-end

data/lib/cli/errors.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-# rubocop:disable Style/Documentation
-
-module Coltrane
-  module Cli
-    class ColtraneCliError < StandardError
-      def initialize(msg)
-        super msg
-      end
-    end
-
-    class WrongFlavorError < ColtraneCliError
-      def initialize(msg = nil)
-        super msg || 'Wrong flavor. Check possible flavors with `coltrane list flavors`.'
-      end
-    end
-
-    class BadFindScales < ColtraneCliError
-      def initialize(msg = nil)
-        super msg || 'Provide --notes or --chords. Ex: `coltrane find-scale --notes C-E-G`.'
-      end
-    end
-
-    class WrongRepresentationTypeError < ColtraneCliError
-      def initialize(type)
-        super "The provided representation type (#{type}) "\
-              'is not available at the moment.'
-      end
-    end
-
-    class BadScaleError < ColtraneCliError
-      def initialize(msg = nil)
-        super msg || 'Incorrect scale, please specify scale and root separated by `-`. Ex: `coltrane scale major-C'
-      end
-    end
-
-    class BadChordError < ColtraneCliError
-      def initialize(msg = nil)
-        super msg || 'Incorrect chord, please specify a set of chords separated by `-`. Ex: coltrane chord CM7'
-      end
-    end
-  end
-end
-
-# rubocop:enable Style/Documentation

data/lib/cli/guitar.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  module Cli
-    # Renders notes in a common most popular ukulele scheme
-    class Guitar < Representation
-      SPECIAL_FRETS = [3, 5, 7, 9, 12, 15, 17, 19].freeze
-
-      include Color
-      def initialize(notes, tuning: %w[E A D G B E], frets: 22)
-        @notes    = notes
-        @tuning   = tuning.reverse
-        @frets    = frets
-        @ref_note = @notes.first
-      end
-
-      def render
-        [render_notes, render_special_frets, hint].join("\n" * 2)
-      end
-
-      def render_notes
-        @tuning.each_with_index.map do |string, str_i|
-          string_note = Note[string]
-          Array.new(@frets + 2) do |i|
-            if i.zero?
-              Paint[string, HSL.new(140 + str_i * 20, 50, 50).html]
-            else
-              fret = i - 1
-              note = string_note + fret
-              m = (@notes.include?(note) ? place_mark(note) : place_empty(str_i))
-              fret.zero? ? (m + ' |') : m
-            end
-          end.join(' ')
-        end.join("\n")
-      end
-
-      def render_special_frets
-        '  ' +
-          Array.new(@frets + 2) do |fret|
-            m = SPECIAL_FRETS.include?(fret) ? fret.to_s.rjust(2, 0.to_s) : '  '
-            "#{m}#{'  ' if fret.zero?}"
-          end.join(' ')
-      end
-
-      def place_empty(str_i)
-        Paint['--', HSL.new(180 + str_i * 3, 50, 30).html]
-      end
-
-      def place_mark(note)
-        mark = case Cli.config.flavor
-               when :notes     then note.pretty_name.ljust(2, ' ')
-               when :intervals then (@ref_note - note).name.ljust(2, '-')
-               when :degrees   then @notes.degree(note).to_s.rjust(2, '0')
-               when :marks     then '  ' # '◼◼'
-               else raise WrongFlavorError
-               end
-
-        base_hue = (180 + note.integer * 10) % 360 # + 260
-        Paint[
-          mark,
-          HSL.new(0, 0, 100).html,
-          HSL.new(base_hue, 100, 30).html
-        ]
-      end
-    end
-  end
-end

data/lib/cli/guitar_chords.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  module Cli
-    # Renders notes in a common most popular ukulele scheme
-    class GuitarChords < Representation
-      include Color
-
-      def initialize(notes, tuning: %w[E2 A2 D3 G3 B3 E4], frets: 23)
-        @notes    = notes
-        @tuning   = tuning.reverse
-        @frets    = frets
-
-        target_chord = Coltrane::Chord.new(notes: @notes)
-        chords = ColtraneInstruments::Guitar::Base.find_chords(target_chord)
-        @chords = chords.sort[-6..-1].reverse
-        # @chords.each { |c| ColtraneSynth::Base.play(c.voicing) } if false
-      end
-
-      def chord_height
-        ColtraneInstruments::Guitar::Chord::MAX_FRET_SPAN
-      end
-
-      def render
-        render_horizontally
-        # render_vertically
-      end
-
-      def render_vertically
-        @chords.map { |c| render_chord(c) }
-      end
-
-      def render_horizontally
-        rchords = @chords.map { |c| render_chord(c).split("\n") }
-        rchords.max_by(&:size).size.times.reduce('') do |memo1, l|
-          memo1 +
-            rchords.reduce('') do |memo2, c|
-              memo2 +
-                (c[l].nil? ? ' ' * c.map(&:size).max + '  ' : "#{c[l]}  ")
-            end +
-            "\n"
-        end
-      end
-
-      def render_chord(chord)
-        render_top(chord) +
-          (chord.lowest_fret..chord.lowest_fret + chord_height)
-          .each_with_index.reduce('') do |memo1, (f, y)|
-              memo1 +
-                '   ' +
-                (chord.guitar.strings.size * 2).times.map { |x| base_color border(x, y) }.join('') +
-                "\n" +
-              chord.guitar.strings.reduce(base_color(f.to_s.ljust(2, ' '))) do |memo2, s|
-                memo2 +
-                  ' ' +
-                render_note(chord.guitar_notes.select do |n|
-                  n.string == s && n.fret == f
-                end.any?)
-              end +
-                " \n"
-            end + '   ' +
-          (chord.guitar.strings.size * 2).times.map do |x|
-            base_color border(x, chord_height + 1)
-          end.join('')
-      end
-
-      def border(x, y)
-        edge = [@tuning.size * 2 - 2, chord_height + 1]
-        x_on_start  = x == 0
-        y_on_start  = y == 0
-        x_on_edge   = x == edge[0]
-        y_on_edge   = y == edge[1]
-        x_on_middle = (0...edge[0]).cover?(x)
-        y_on_middle = (0...edge[1]).cover?(y)
-
-        if    x_on_start  && y_on_start  then '┍'
-        elsif x_on_middle && y_on_start  then x.odd? ? '━' : '┯'
-        elsif x_on_edge   && y_on_start  then '┑'
-        elsif x_on_start  && y_on_middle then '┝'
-        elsif x_on_middle && y_on_middle then x.odd? ? '━' : '┿'
-        elsif x_on_edge   && y_on_middle then '┥'
-        elsif x_on_start  && y_on_edge   then '┕'
-        elsif x_on_middle && y_on_edge   then x.odd? ? '━' : '┷'
-        elsif x_on_edge   && y_on_edge   then '┙'
-        else ' '
-        end
-        # puts edge.inspect
-        # "#{x},#{y} "
-      end
-
-      def base_color(str)
-        Paint[str, '#6A4AC2']
-      end
-
-      def highlight(str)
-        Paint[str, '#E67831']
-      end
-
-      def alt(str)
-        Paint[str, '#2DD380']
-      end
-
-      def render_top(chord)
-        chord.guitar.strings.reduce('   ') do |memo, s|
-          memo +
-            if chord.guitar_notes.select { |n|
-              n.string == s && n.fret == 0 }.any?
-              highlight '⬤ '
-            elsif chord.guitar_notes.select { |n| n.string == s && n.fret.nil? }.any?
-              alt 'x '
-            else
-              '  '
-            end
-        end + "\n"
-      end
-
-      def render_note(found)
-        found ? highlight('⬤') : base_color('│')
-      end
-    end
-  end
-end

data/lib/cli/notes.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  module Cli
-    # Interfaces notes outputting functionality with the lib
-    class Notes
-      def initialize(notes, desc: nil)
-        @desc   = desc || 'The notes you supplied:'
-        notes   = Coltrane::NoteSet.new(notes)
-        @representation = Representation.build(notes)
-        render
-        # notes.each {|n| ColtraneSynth::Base.play(n, 0.1) } if Cli.config.sound
-      end
-
-      def render
-        puts "\n" + [@desc, @representation.render].join("\n" * 2)
-      end
-    end
-  end
-end

data/lib/cli/piano.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  module Cli
-    # It allows rendering notes in an ASCII piano
-    class Piano < Representation
-      PIANO_TEMPLATE = <<~ASCII
-        ┌─┬─┬┬─┬─╥─┬─┬┬─┬┬─┬─╥─┬─┬┬─┬─╥─┬─┬┬─┬┬─┬─┐
-        │ │ ││ │ ║ │ ││ ││ │ ║ │ ││ │ ║ │ ││ ││ │ │
-        │ │X││X│ ║ │X││X││X│ ║ │X││X│ ║ │X││X││X│ │
-        │ │X││X│ ║ │X││X││X│ ║ │X││X│ ║ │X││X││X│ │
-        │ ┕╥┙┕╥┙ ║ ┕╥┙┕╥┙┕╥┙ ║ ┕╥┙┕╥┙ ║ ┕╥┙┕╥┙┕╥┙ │
-        │  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  │
-        │XX║XX║XX║XX║XX║XX║XX║XX║XX║XX║XX║XX║XX║XX│
-        └──╨──╨──╨──╨──╨──╨──╨──╨──╨──╨──╨──╨──╨──┘
-      ASCII
-
-      def render
-        PIANO_TEMPLATE.each_line.map.each_with_index do |l, ln|
-          case ln
-          when 2, 3 then replace_x(l, black_notes, 1, ln - 2)
-          when 6 then replace_x(l, white_notes, 2)
-          else l
-          end
-        end.join + "\n#{hint}"
-      end
-
-      private
-
-      def replace_x(line, notes, size, index = 0)
-        line.gsub('X' * size).with_index do |_match, i|
-          note = notes[i % notes.size]
-          next ' ' * size unless @notes.include?(note)
-          Paint[replacer(note)[size == 2 ? 0..2 : index], 'red']
-        end
-      end
-
-      def replacer(note)
-        # TODO: Maybe extract this method into its own class/module
-        case Cli.config.flavor
-        when :intervals then (@ref_note - note).name
-        when :marks then '◼ '
-        when :degrees then @notes.degree(note).to_s.rjust(2, '0')
-        when :notes then note.pretty_name.to_s.ljust(2, "\u266E")
-        end
-      end
-
-      def white_notes
-        Coltrane::Scale.major.notes
-      end
-
-      def black_notes
-        Coltrane::Scale.pentatonic_major('C#', 4).notes
-      end
-    end
-  end
-end

data/lib/cli/scale.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  module Cli
-    # Interfaces commands with the scales functionality
-    class Scale
-      def self.parse(str)
-        raise BadScaleError unless str&.include?('-')
-        *scale_name, tone = str.split('-')
-        Coltrane::Scale.fetch(scale_name.join('_'), tone)
-      end
-
-      def self.find(notes: [], chords: [])
-        if notes.any?
-          puts "\nSearching for scales containing #{notes.join(', ')}:\n\n"
-          notes = NoteSet[*notes]
-        elsif chords.any?
-          puts "\nSearching for scales containing #{chords.join(', ')}:\n\n"
-          notes = chords.reduce(NoteSet[]) do |memo, c|
-            memo + Coltrane::Chord.new(name: c).notes
-          end
-        else raise BadFindScales
-        end
-        render_search(notes)
-        puts "\nUnderlined means the scale has all notes"
-      end
-
-      def self.render_search(searched_notes)
-        search = Coltrane::Scale.having_notes(searched_notes)
-        output = []
-        scale_width = search[:results].keys.map(&:size).max
-        search[:results].each do |name, scales_by_tone|
-          output << name.ljust(scale_width + 1, ' ')
-          scales_by_tone.each do |tone_number, notes|
-            p     = (notes.size.to_f / searched_notes.size) * 100
-            l     = p == 100 ? p : (p + 20) * 0.4
-            und   = p == 100 ? :underline : nil
-            color = Color::HSL.new(30, p, l / 2).html
-            output << Paint["#{Note[tone_number].name}(#{notes.size})", color, und]
-            output << ' '
-          end
-          output << "\n"
-        end
-        puts output.join
-      end
-
-      def initialize(scale)
-        desc = "This is the #{scale.tone.name} #{scale.name} scale:"
-        Coltrane::Cli::Notes.new(scale.notes)
-      end
-    end
-  end
-end