coltrane 3.4.2 → 4.0.3

data/lib/coltrane/commands/find_scale_by_notes.rb

@@ -0,0 +1,9 @@
+module Coltrane
+  module Commands
+    class FindScaleByNotes < Command
+      def run(notes)
+        Theory::Scale.having_notes(*notes)
+      end
+    end
+  end
+end

data/lib/coltrane/commands/get_chords_from_notable_progression.rb

@@ -0,0 +1,9 @@
+module Coltrane
+  module Commands
+    class GetChordsFromNotableProgression < Command
+      def run(progression, key)
+        Theory::Progression.send(progression.underscore, key).chords
+      end
+    end
+  end
+end

data/lib/coltrane/commands/get_chords_from_progression.rb

@@ -0,0 +1,9 @@
+module Coltrane
+  module Commands
+    class GetChordsFromProgression < Command
+      def run(notation, key)
+        Theory::Progression.new(notation, key: key).chords
+      end
+    end
+  end
+end

data/lib/coltrane/commands/get_chords_from_scale.rb

@@ -0,0 +1,9 @@
+module Coltrane
+  module Commands
+    class GetChordsFromScale < Command
+      def run(scale, type, size)
+        scale.send(type == 'tertians' ? :tertians : :chords)
+      end
+    end
+  end
+end

data/lib/coltrane/commands/get_chords_from_string.rb

@@ -0,0 +1,11 @@
+module Coltrane
+  module Commands
+    class GetChordsFromString < Command
+      def run(string)
+        string.split(' ').map do |chord|
+          Theory::Chord.new(name: chord)
+        end
+      end
+    end
+  end
+end

data/lib/coltrane/commands/get_classic_scale.rb

@@ -0,0 +1,9 @@
+module Coltrane
+  module Commands
+    class GetClassicScale < Command
+      def run(scale, tone)
+        Theory::Scale.fetch(scale, tone)
+      end
+    end
+  end
+end

data/lib/coltrane/commands/get_notes.rb

@@ -0,0 +1,9 @@
+module Coltrane
+  module Commands
+    class GetNotes < Command
+      def run(*notes)
+        Theory::NoteSet[*notes]
+      end
+    end
+  end
+end

data/lib/coltrane/commands/get_notes_from_string.rb

@@ -0,0 +1,9 @@
+module Coltrane
+  module Commands
+    class GetNotesFromString < Command
+      def run(string)
+        GetNotes.run(*string.split(' '))
+      end
+    end
+  end
+end

data/lib/coltrane/commands/get_representation_chords.rb

@@ -0,0 +1,18 @@
+module Coltrane
+  module Commands
+    class GetRepresentationChords < Command
+      def run(representation, chords)
+        chords.map do |chord|
+          if representation == 'GuitarChordChart'
+            {
+              chord.name => Representation::Guitar.find_chords(chord).first(4),
+              options: { layout: :horizontal, per_row: 4 }
+            }
+          else
+            { chord.name => GetRepresentationNotes.run(representation, chord.notes) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coltrane/commands/get_representation_notes.rb

@@ -0,0 +1,12 @@
+module Coltrane
+  module Commands
+    class GetRepresentationNotes < Command
+      def run(representation, notes)
+        return notes if representation == 'Text'
+        Object
+          .const_get("Coltrane::Representation::#{representation}")
+          .find_notes(notes)
+      end
+    end
+  end
+end

data/lib/coltrane/commands/render.rb

@@ -0,0 +1,9 @@
+module Coltrane
+  module Commands
+    class Render < Command
+      def run(object)
+        Renderers::TextRenderer.render(object)
+      end
+    end
+  end
+end

data/lib/coltrane/renderers/text_renderer/hash_drawer.rb

@@ -5,6 +5,7 @@ module Coltrane
         alias hash model
 
         def render
+          options = hash.delete(:options) || {}
           hash.map { |k, v|
             "#{k}: \n\n" +
             TextRenderer.render(v, **options)

data/lib/coltrane/renderers/text_renderer/theory_chord_drawer.rb

@@ -5,8 +5,7 @@ module Coltrane
         alias chord model
 
         def render
-          "#{chord.name}: ".ljust(5) +
-          TextRenderer.render(chord.notes, **options)
+          "#{chord.name}: ".ljust(5) + TextRenderer.render(chord.notes)
         end
       end
     end

data/lib/coltrane/theory/classic_scales.rb

@@ -45,7 +45,7 @@ module Coltrane
       alias blues         blues_major
 
       def known_scales
-        SCALES.keys + ['Major', 'Natural Minor']
+        ['Major', 'Natural Minor'] + SCALES.keys
       end
 
       # List of scales appropriate for search

data/lib/coltrane/ui.rb

@@ -0,0 +1,9 @@
+require 'active_support/inflector'
+require 'paint'
+require 'color'
+require 'cli/ui' # shopify cli
+
+require 'coltrane'
+require 'coltrane/commands'
+require 'coltrane/ui/views'
+require 'coltrane/ui/router'

data/lib/coltrane/ui/router.rb

@@ -0,0 +1,87 @@
+module Coltrane
+  module UI
+    class Router
+
+      class Route
+        attr_reader :path, :view, :last
+        attr_accessor :params
+
+        def initialize(path, to:, with: {})
+          @path   = path
+          @view   = to
+          @params = with
+        end
+
+        def render(**other_params)
+          view.render(**params, **other_params)
+        end
+      end
+
+      class History
+        attr_reader :routes
+
+        def initialize
+          @routes = []
+        end
+
+        def add(route)
+          @routes << route
+        end
+
+        def previous
+          routes[-2]&.path || ''
+        end
+
+        def current_route
+          routes[-1]
+        end
+
+        def back
+          routes.pop.render
+        end
+
+        def refresh(params={})
+          current_route.render(params)
+        end
+      end
+
+      attr_reader :path, :params, :routes, :history, :url
+
+      def initialize
+        @routes  = []
+        @history = History.new
+
+        draw_route '', to: Coltrane::UI::Views::Index
+        Views.constants.each do |view|
+          draw_route view.to_s.underscore.humanize.downcase, to: "Coltrane::UI::Views::#{view}".constantize
+        end
+      end
+
+      def get(**params)
+        path = params.delete(:path)
+        @url  = build_url(path || history.current_route.path, **params)
+        route = @routes.detect { |route| route.path == path }
+        return history.refresh(params) unless route
+        history.add(route)
+        route.render(**params)
+      end
+
+      def build_url(path, params)
+        [
+          path,
+          (params || {}).map do |k,v|
+            [k,v.gsub(' ', '-')].join(':')
+          end
+        ].compact.join(' ')
+      end
+
+      def previous_path
+        history.previous
+      end
+
+      def draw_route(*args, **keyword_args, &block)
+        @routes << Route.new(*args, **keyword_args, &block)
+      end
+    end
+  end
+end

data/lib/coltrane/ui/views.rb

@@ -0,0 +1,4 @@
+require 'coltrane/ui/views/view'
+Dir[File.expand_path('../views/*', __FILE__)].map do |f|
+  require(f)
+end

data/lib/coltrane/ui/views/chords.rb

@@ -0,0 +1,19 @@
+module Coltrane
+  module UI
+    module Views
+      class Chords < View
+        questions({
+          path: {
+            statement: 'What do you need',
+            options: [
+              'show chord',
+              'find chord by notes',
+              'find chords in scale',
+              'find common chords in scales'
+            ]
+          }
+        })
+      end
+    end
+  end
+end

data/lib/coltrane/ui/views/custom_progression.rb

@@ -0,0 +1,27 @@
+module Coltrane
+  module UI
+    module Views
+      class CustomProgression < View
+        questions({
+          progression_notation: {
+            statement: 'What is the progression? (Ex: I-vi-IV-V)'
+          },
+
+          representation: {
+            statement: 'How do you wanna see the chords?',
+            options: Commands::AvailableChordRepresentations.run
+          },
+
+          key: {
+            statement: 'What is the key?'
+          },
+        })
+
+        def render
+          chords = Commands::GetChordsFromProgression.run(*params.values_at(:progression_notation, :key))
+          Commands::GetRepresentationChords.run(params[:representation], chords)
+        end
+      end
+    end
+  end
+end

data/lib/coltrane/ui/views/find_chord_by_notes.rb

@@ -0,0 +1,16 @@
+module Coltrane
+  module UI
+    module Views
+      class FindChordByNotes < View
+        questions({
+          notes: { statement: 'Which Notes?' }
+        })
+
+        def render
+          notes = Commands::GetNotesFromString.run(params[:notes])
+          Commands::FindChordByNotes.run(*notes)
+        end
+      end
+    end
+  end
+end

data/lib/coltrane/ui/views/find_chords_in_scale.rb

@@ -0,0 +1,34 @@
+require 'coltrane/ui/views/show_scale'
+
+module Coltrane
+  module UI
+    module Views
+      class FindChordsInScale < ShowScale
+        questions({
+          chord_type: {
+            statement: 'Which kind of chords?',
+            options: ['tertian', 'all']
+          },
+
+          chord_size: {
+            statement: 'What is the size of the chords',
+            options: (3..7).to_a.map(&:to_s)
+          },
+
+          chord_representation: {
+            statement: 'How do you wanna see this',
+            options: Commands::AvailableChordRepresentations.run
+          }
+        })
+        def render
+          scale = Commands::GetClassicScale.run(*params.values_at(:scale, :tone))
+          chords = Commands::GetChordsFromScale.run(
+            scale,
+            *params.values_at(:chord_type, :chord_size)
+          )
+          Commands::GetRepresentationChords.run(params[:chord_representation], chords)
+        end
+      end
+    end
+  end
+end

data/lib/coltrane/ui/views/find_common_chords_in_scales.rb

@@ -0,0 +1,40 @@
+module Coltrane
+  module UI
+    module Views
+      class FindCommonChordsInScales < View
+        questions({
+          first_scale: {
+            statement: 'Choose the first scale',
+            options: Commands::AvailableClassicScales.run
+          },
+
+          first_scale_root: {
+            statement: 'Type the tone (note)'
+          },
+
+          second_scale: {
+            statement: 'Choose the second scale',
+            options: Commands::AvailableClassicScales.run
+          },
+
+          second_scale_root: {
+            statement: 'Type the tone (note)'
+          },
+
+          representation: {
+            statement: 'How do you wanna see the results?',
+            options: Commands::AvailableChordRepresentations.run
+          }
+        })
+
+        def render
+          scale_a    = Commands::GetClassicScale.run(*params.values_at(:first_scale, :first_scale_root))
+          scale_b    = Commands::GetClassicScale.run(*params.values_at(:second_scale, :second_scale_root))
+          chords     = Commands::FindCommonChords.run(scale_a, scale_b)
+          rep_chords = Commands::GetRepresentationChords.run(params[:representation], chords)
+          { "Chords that exist in #{scale_a.full_name} and #{scale_b.full_name}" => rep_chords }
+        end
+      end
+    end
+  end
+end

data/lib/coltrane/ui/views/find_progressions_from_chords.rb

@@ -0,0 +1,14 @@
+module Coltrane
+  module UI
+    module Views
+      class FindProgressionsFromChords < View
+        questions chords: { statement: 'Type the chords? (Ex: CM EM GM)' }
+
+        def render
+          chords = Commands::GetChordsFromString.run(params[:chords])
+          Commands::FindProgressionsFromChords.run(*chords)
+        end
+      end
+    end
+  end
+end

data/lib/coltrane/ui/views/find_scale.rb

@@ -0,0 +1,14 @@
+module Coltrane
+  module UI
+    module Views
+      class FindScale < View
+        questions({
+          path: {
+            statement: 'How do you wanna search',
+            options: ['find scale by chords', 'find scale by notes']
+          },
+        })
+      end
+    end
+  end
+end

data/lib/coltrane/ui/views/find_scale_by_chords.rb

@@ -0,0 +1,16 @@
+module Coltrane
+  module UI
+    module Views
+      class FindScaleByChords < View
+        questions({
+          chords: { statement: 'Which Chords?' }
+        })
+
+        def render
+          chords = Commands::GetChordsFromString.run(params[:chords])
+          Commands::FindScaleByChords.run(*chords)
+        end
+      end
+    end
+  end
+end