coltrane 3.4.2 → 4.1.0

data/lib/coltrane/commands/chords.rb

@@ -1,93 +0,0 @@
-module Coltrane
-  module Commands
-    class Chords < Command
-      attr_reader :chord, :flavor, :on, :preface, :voicings
-
-      def initialize(chord = nil,
-                     flavor: :notes,
-                     on: :text,
-                     notes: nil,
-                     preface: nil,
-                     voicings: 4,
-                     **options)
-        if chord
-          @chord = chord.is_a?(Theory::Chord) ? chord : Theory::Chord.new(name: chord)
-        elsif notes
-          @chord = Theory::Chord.new(notes: notes&.split('-'))
-        else
-          raise 'Provide chord names or notes. Ex: coltrane chords Cm7-Db7, ' \
-                'or coltrane chords --notes C-E-G'
-        end
-
-        @flavor   = flavor.to_sym
-        @preface  = preface || @chord.name
-        @on       = on.to_sym
-        @voicings = voicings.to_i
-      end
-
-      def representation
-        return on_model if on == :text
-        { preface => on_model }
-      end
-
-      def on_model
-        case on
-        when :text                  then chord
-        when :guitar                then Representation::Guitar.find_chords(chord).first(voicings)
-        when :ukulele, :ukelele     then Representation::Ukulele.find_chords(chord).first(voicings)
-        when :bass                  then Representation::Bass.find_notes(chord.notes)
-        when :piano                 then Representation::Piano.find_notes(chord.notes)
-        when :'guitar-frets'        then Representation::Guitar.find_notes(chord.notes)
-        when :'ukulele-frets',      :'ukelele-frets' then Representation::Ukulele.find_notes(chord.notes)
-        when /custom_guitar_frets/  then custom_guitar_notes
-        when /custom_guitar/        then custom_guitar_chords.first(voicings)
-        end
-      end
-
-      def custom_guitar_notes
-        Representation::Guitar::NoteSet.new(chord.notes, guitar: custom_guitar)
-      end
-
-      def custom_guitar_chords
-        Representation::Guitar::Chord.find(chord, guitar: custom_guitar)
-      end
-
-      def layout_horizontal?
-        on.to_s =~ /guitar|ukulele|ukelele|bass|piano/
-      end
-
-      def renderer_options
-        [
-          { flavor: flavor },
-          (
-            {
-              layout: :horizontal,
-              per_row: 4,
-            } if layout_horizontal?
-          )
-        ]
-        .compact
-        .reduce({}, :merge)
-      end
-
-      def self.mercenary_init(program)
-        program.command(:chords) do |c|
-          c.alias(:chord)
-          c.syntax 'chords [<chord-name>] [--on <instrument>]'
-          c.description 'Shows the given chord. Ex: coltrane chord Cmaj7 --on piano'
-          c.option :notes, '--notes C-D-E', 'finds chords with those notes, ' \
-                           'provided they are separated by dashes'
-
-          add_shared_option(:flavor, c)
-          add_shared_option(:on, c)
-          add_shared_option(:voicings, c)
-          c.action { |(chords), **options|
-            (chords&.split('-') || [nil]).each { |chord|
-              new(chord, **options).render
-            }
-          }
-        end
-      end
-    end
-  end
-end

data/lib/coltrane/commands/common_chords.rb

@@ -1,33 +0,0 @@
-module Coltrane
-  module Commands
-    class CommonChords < Command
-      def self.parse(scale_notation)
-        scale_notation
-        .split(' ', 2)
-        .yield_self { |(tone, scale_name)|
-          Theory::Scale.fetch(scale_name.gsub(' ', '_'), tone)
-        }
-      end
-
-      def self.mercenary_init(program)
-        program.command(:'common-chords') do |c|
-          c.alias(:'common-chord')
-          add_shared_option(:flavor, c)
-          add_shared_option(:on, c)
-          c.syntax 'common-chords [TONE_1 SCALE_NAME_1], [TONE_2 SCALE_NAME_2], [...]'
-          c.description 'Finds chords that are shared between the given scales'
-          c.action do |(*scale_strings), **options|
-            scale_strings
-            .join(' ')
-            .split(',')
-            .map { |scale_notation|
-              Commands::Scale.parse(scale_notation).all_chords
-            }
-            .reduce(:&)
-            .each   { |chord| Commands::Chords.new(chord, **options).render }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/coltrane/commands/errors.rb

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

data/lib/coltrane/commands/find_guitar_chord.rb

@@ -1,25 +0,0 @@
-module Coltrane
-  module Commands
-    class FindGuitarChord < Command
-      attr_reader :notation
-
-      def initialize(notation)
-        @notation = notation
-      end
-
-      def representation
-        Representation::Guitar.find_chord_by_notation(notation)
-      end
-
-      def self.mercenary_init(program)
-        program.command(:'find-guitar-chord') do |c|
-          c.syntax 'find-guitar-chord x-2-2-4-5-x'
-          c.description 'find the chord name assuming the standard tuning (EADGBE)'
-          c.action do |(notation)|
-            new(notation).render
-          end
-        end
-      end
-    end
-  end
-end

data/lib/coltrane/commands/find_progression.rb

@@ -1,28 +0,0 @@
-module Coltrane
-  module Commands
-    class FindProgression < Command
-      attr_reader :progression_set
-
-      def initialize(progression_set, **options)
-        @progression_set = progression_set
-      end
-
-      def representation
-        progression_set
-      end
-
-      def self.mercenary_init(program)
-        program.command(:'find-progression') do |c|
-          c.syntax 'find-progression <list of chords>'
-          c.description 'Find progressions in scales. Ex: coltrane find-progression AM-DM-F#m-EM'
-          c.action do |(chord_notation)|
-            chord_notation
-            .split('-')
-            .yield_self { |chords| Theory::Progression.find(*chords) }
-            .yield_self { |progression_set| new(progression_set).render }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/coltrane/commands/find_scale.rb

@@ -1,39 +0,0 @@
-module Coltrane
-  module Commands
-    class FindScale < Command
-      attr_reader :scale_set
-
-      def initialize(scale_set)
-        @scale_set = scale_set
-      end
-
-      def representation
-        scale_set
-      end
-
-      def self.mercenary_init(program)
-        program.command(:'find-scale') do |c|
-          c.syntax 'find-scale --notes C-D-E-...] OR --chord Cmaj7-Db7'
-          c.description 'finds scales with the provided --notes or --chord'
-          c.option :notes, '--notes C-D-E', 'Find scales with those notes'
-          c.option :chords, '--chords Cmaj7-D11', 'find scales with those chords'
-          c.action do |(_), notes: nil, chords: nil|
-            begin
-              if notes
-                Theory::Scale.having_notes(
-                  Theory::NoteSet[*notes.to_s.split('-')]
-                )
-              elsif chords
-                Theory::Scale.having_chords(*chords.to_s.split('-'))
-              else
-                raise 'Provide --notes or --chords separated by dashes.' \
-                      'For example coltrane find-scale --notes C-E-F#'
-              end
-            end
-            .yield_self { |scale_set| new(scale_set).render }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/coltrane/commands/notes.rb

@@ -1,50 +0,0 @@
-module Coltrane
-  module Commands
-    class Notes < Command
-      attr_reader :notes, :flavor, :on, :preface
-
-      def initialize(notes, flavor: :notes, on: :text, preface: nil)
-        raise 'Provide some notes. Ex: coltrane notes C-D-Gb' if notes.nil?
-        @notes   = notes.is_a?(Theory::NoteSet) ? notes : Theory::NoteSet[*notes.split('-')]
-        @flavor  = flavor.to_sym
-        @preface = preface || 'Here are the notes you asked for'
-        @on      = on
-      end
-
-      def representation
-        { preface => on_model }
-      end
-
-      def renderer_options
-        { flavor: flavor }
-      end
-
-      def on_model
-        case on.to_sym
-        when /custom_guitar/    then custom_guitar_notes
-        when :text              then notes
-        when :guitar            then Representation::Guitar.find_notes(notes)
-        when :ukulele, :ukelele then Representation::Ukulele.find_notes(notes)
-        when :bass              then Representation::Bass.find_notes(notes)
-        when :piano             then Representation::Piano.find_notes(notes)
-        end
-      end
-
-      def custom_guitar_notes
-        Representation::Guitar::NoteSet.new(notes, guitar: custom_guitar)
-      end
-
-      def self.mercenary_init(program)
-        program.command(:notes) do |c|
-          c.alias(:note)
-          c.syntax 'notes <notes separated by space> [--on <instrument>]'
-          c.description 'Shows the given notes.'
-          add_shared_option(:voicings, c)
-          add_shared_option(:flavor, c)
-          add_shared_option(:on, c)
-          c.action { |(notes), **options| new(notes, **options).render }
-        end
-      end
-    end
-  end
-end

data/lib/coltrane/commands/progression.rb

@@ -1,28 +0,0 @@
-module Coltrane
-  module Commands
-    class Progression < Command
-      def self.mercenary_init(program)
-        program.command(:progression) do |c|
-          c.syntax 'progression <roman numeral notation> in <key> [--on <instrument>]'
-          c.description 'Gives you chords of a progression in a key. Ex: coltrane progression I-IV-iv-V in Am --on guitar'
-          add_shared_option(:flavor, c)
-          add_shared_option(:on, c)
-          add_shared_option(:voicings, c)
-          c.action do |(prog, _, key), **options|
-            prog
-            .tr('-', '_')
-            .yield_self { |possible_method|
-              if Theory::Progression.respond_to?(possible_method)
-                Theory::Progression.send(possible_method, key)
-              else
-                Theory::Progression.new(prog, key: key)
-              end
-            }
-            .chords
-            .each { |chord| Commands::Chords.new(chord, **options).render }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/coltrane/commands/scale.rb

@@ -1,46 +0,0 @@
-module Coltrane
-  module Commands
-    class Scale < Command
-      def representation
-        return on_model if on == :text
-        { preface => on_model }
-      end
-
-      def self.parse(scale_notation)
-        scale_notation
-        .split(' ', 2)
-        .yield_self { |(tone, scale_name)|
-          Theory::Scale.fetch(scale_name.gsub(' ', '_'), tone)
-        }
-      end
-
-      def self.mercenary_init(program)
-        program.command(:scale) do |c|
-          c.syntax 'scale <root_note> <scale name> [--on <instrument>]'
-          c.description 'Gives you information about a scale. Ex: coltrane scale D Natural Minor --on guitar'
-          c.option :tertians, '--tertians <SIZE>', 'Outputs all tertian chords from the given size from the scale'
-          c.option :chords,   '--chords [SIZE]', 'Outputs all chords from given size from the scale. Leave size empty to retrieve all'
-          add_shared_option(:flavor, c)
-          add_shared_option(:on, c)
-          add_shared_option(:voicings, c)
-
-          c.action { |scale_notation, **options|
-            parse(scale_notation.join(' '))
-            .yield_self { |scale|
-              if options[:tertians]
-                scale
-                .tertians(options[:tertians].to_i)
-                .each { |chord| Commands::Chords.new(chord, **options).render }
-              elsif options[:chords]
-                scale.chords(options[:chords].to_i)
-                .each { |chord| Commands::Chords.new(chord, **options).render }
-              else
-                Commands::Notes.new(scale.notes, **options.merge(preface: scale.full_name)).render
-              end
-            }
-          }
-        end
-      end
-    end
-  end
-end