coltrane 2.2.1 → 3.0.0.pre

data/lib/coltrane/commands.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'coltrane'
+require 'coltrane/representation'
+require 'coltrane/renderers'
+
+require 'coltrane/commands/command'
+require 'coltrane/commands/notes'
+require 'coltrane/commands/chords'
+require 'coltrane/commands/scale'
+require 'coltrane/commands/progression'
+require 'coltrane/commands/common_chords'
+require 'coltrane/commands/find_scale'
+require 'coltrane/commands/find_progression'

data/lib/coltrane/commands/chords.rb

@@ -0,0 +1,77 @@
+module Coltrane
+  module Commands
+    class Chords < Command
+      attr_reader :chord, :flavor, :on, :preface
+
+      def initialize(chord = nil,
+                     flavor: :notes,
+                     on: :text,
+                     notes: nil,
+                     preface: nil,
+                     **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
+      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(6)
+        when :ukulele, :ukelele then Representation::Ukulele.find_chords(chord).first(6)
+        when :bass              then Representation::Bass.find_chords(chord).first(6)
+        when :piano             then Representation::Piano.find_notes(chord.notes)
+        end
+      end
+
+      def layout_horizontal?
+        [:guitar, :ukulele, :ukelele, :bass, :piano].include?(on)
+      end
+
+      def renderer_options
+        [
+          { flavor: flavor },
+          (
+            {
+              layout: :horizontal,
+              per_row: 6,
+            } 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.alias(:chords)
+          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)
+          c.action { |(chords), **options|
+            (chords&.split('-') || [nil]).each { |chord| new(chord, **options).render }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/coltrane/commands/command.rb

@@ -0,0 +1,45 @@
+module Coltrane
+  module Commands
+    class Command
+      COMMON_OPTIONS = {
+        on: [
+          '--on guitar INSTRUMENT',
+          'Shows the notes on the given instrument/representation type. ' \
+          'Can be piano, guitar, ukulele, bass or text'
+        ],
+
+        flavor: [
+          '--flavor FLAVOR',
+          'Chooses which additional information to display: ' \
+          'marks, notes, intervals or degrees'
+        ]
+      }
+
+      def render
+        puts "\n" + Renderers::TextRenderer.render(
+          representation, **renderer_options
+        )
+      end
+
+      def renderer_options
+        {}
+      end
+
+      class << self
+
+        def subclasses
+          @subclasses ||= []
+        end
+
+        def inherited(base)
+          subclasses << base
+          super(base)
+        end
+
+        def add_shared_option(option_name, mercenary_command)
+          mercenary_command.option(option_name, *COMMON_OPTIONS[option_name])
+        end
+      end
+    end
+  end
+end

data/lib/coltrane/commands/common_chords.rb

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,44 @@
+# 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_progression.rb

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,44 @@
+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 :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 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(: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

@@ -0,0 +1,27 @@
+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)
+          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

@@ -0,0 +1,46 @@
+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)
+
+          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
+                scale.notes
+                .yield_self {|notes| Commands::Notes.new(notes, **options.merge(preface: scale.full_name)).render }
+              end
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/coltrane/renderers.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'coltrane'
+require 'coltrane/representation'
+require 'coltrane/renderers/renderer'
+require 'coltrane/renderers/text_renderer'

data/lib/coltrane/renderers/renderer.rb

@@ -0,0 +1,42 @@
+module Coltrane
+  module Renderers
+    module Renderer
+      include Dry::Monads::Try::Mixin
+
+      def render(model, **options)
+        model
+          .yield_self { |model| model_class_list(model) }
+          .yield_self { |model_classes| renderer_class(*model_classes) }
+          .value_or   { raise("Renderer doesn't implements #{model.class}") }
+          .new(model, **options)
+          .render
+      end
+
+      private
+
+      def model_class_list(model)
+        model
+          .class
+          .ancestors
+          .yield_self { |classes| classes[0...classes.index(Object)]  }
+      end
+
+      def renderer_class(*classes)
+        return if classes.empty?
+        Try() { classes }
+          .fmap { |classes|
+             classes
+              .first
+              .to_s
+              .gsub('Coltrane::', '')
+              .gsub('::', '')
+              .prepend("#{self.name}::")
+              .concat('Drawer')
+              .yield_self {|class_name| Object.const_get(class_name) }
+          }
+          .to_maybe
+          .or(renderer_class(*classes[1..-1]))
+      end
+    end
+  end
+end