coltrane 2.2.1 → 3.0.0.pre

data/lib/coltrane/renderers/text_renderer.rb

@@ -0,0 +1,23 @@
+require 'paint'
+require 'color'
+
+require 'coltrane/renderers/text_renderer/base_drawer'
+require 'coltrane/renderers/text_renderer/array_drawer'
+require 'coltrane/renderers/text_renderer/hash_drawer'
+require 'coltrane/renderers/text_renderer/theory_note_set_drawer'
+require 'coltrane/renderers/text_renderer/theory_chord_drawer'
+require 'coltrane/renderers/text_renderer/theory_scale_drawer'
+require 'coltrane/renderers/text_renderer/theory_scale_set_drawer'
+require 'coltrane/renderers/text_renderer/theory_progression_drawer'
+require 'coltrane/renderers/text_renderer/theory_progression_set_drawer'
+require 'coltrane/renderers/text_renderer/representation_guitar_note_set_drawer'
+require 'coltrane/renderers/text_renderer/representation_guitar_chord_drawer'
+require 'coltrane/renderers/text_renderer/representation_piano_note_set_drawer'
+
+module Coltrane
+  module Renderers
+    module TextRenderer
+      extend Renderer
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Coltrane
+  module Renderers
+    module TextRenderer
+      class ArrayDrawer < BaseDrawer
+        alias array model
+
+        def render
+          public_send("render_#{layout}")
+        end
+
+        def renders
+          @renders ||= array.map {|it| TextRenderer.render(it, **options) }
+        end
+
+        def render_vertical
+          renders.join("\n")
+        end
+
+        def render_horizontal
+          array
+          .each_slice(per_row)
+          .map { |row|
+            row
+            .map { |element|
+              TextRenderer.render(element, **options)
+              .split("\n")
+              .yield_self { |lines|
+                lines
+                .map { |l| l.gsub(/\e\[(\d+)(;\d+)*m/, '').size }
+                .max
+                .yield_self { |column_w|
+                  lines
+                  .map { |l| l.ljust(column_w) }
+                  .+([' ' * column_w])
+                }
+              }
+            }
+            .transpose
+            .map(&:join)
+          }.join("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Coltrane
+  module Renderers
+    module TextRenderer
+      class BaseDrawer
+        include Paint
+        include Color
+
+        attr_reader :model, :options, :flavor, :layout, :per_row
+
+        def initialize(model, **options)
+          @model   = model
+          @options = options
+          @flavor  = options[:flavor]  || :notes
+          @layout  = options[:layout]  || :vertical
+          @per_row = options[:per_row] || 4
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Coltrane
+  module Renderers
+    module TextRenderer
+      class HashDrawer < BaseDrawer
+        alias hash model
+
+        def render
+          hash.map { |k, v|
+            "#{k}: \n\n" +
+            TextRenderer.render(v, **options)
+          }.join("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Coltrane
+  module Renderers
+    module TextRenderer
+      class RepresentationGuitarChordDrawer < BaseDrawer
+        alias chord model
+
+        def chord_height
+          chord.max_fret_span
+        end
+
+        def guitar
+          chord.guitar
+        end
+
+        def render
+          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 = [guitar.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 do |n|
+                n.string == s && n.fret == 0 end.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
+end

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

@@ -0,0 +1,76 @@
+module Coltrane
+  module Renderers
+    module TextRenderer
+      class RepresentationGuitarNoteSetDrawer < BaseDrawer
+        alias guitar_notes model
+
+        def guitar
+          @guitar ||= guitar_notes.guitar
+        end
+
+        def frets
+          guitar.frets
+        end
+
+        def render
+          [render_notes, render_special_frets].join("\n" * 2)
+        end
+
+        def render_notes
+          guitar_notes.strings.map.with_index.map do |string, str_i|
+            Array.new(frets + 2) do |i|
+              if i.zero?
+                Paint[
+                  string[:pitch].pitch_class.name,
+                  HSL.new(140 + str_i * 20, 50, 50).html
+                ]
+              else
+                (i - 1)
+                .yield_self { |fret|
+                  (string[:pitch] + fret)
+                  .yield_self { |pitch|
+                    if guitar_notes.notes.include?(pitch.pitch_class)
+                      place_mark(pitch.pitch_class)
+                    else
+                      place_empty(str_i)
+                    end
+                  }
+                  .yield_self { |mark| mark + (fret.zero? ? (' |') : '') }
+                }
+              end
+            end.join(' ')
+          end.join("\n")
+        end
+
+        def render_special_frets
+          '  ' +
+            Array.new(frets + 2) do |fret|
+              m = guitar.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 flavor
+                 when :notes     then note.pretty_name.ljust(2, ' ')
+                 when :intervals then (guitar_notes.root - note).name.ljust(2, '-')
+                 when :degrees   then guitar_notes.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
+end

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

@@ -0,0 +1,49 @@
+module Coltrane
+  module Renderers
+    module TextRenderer
+      class RepresentationPianoNoteSetDrawer < BaseDrawer
+        alias note_set model
+
+        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, Representation::Piano.black_notes, 1, ln - 2)
+            when 6    then replace_x(l, Representation::Piano.white_notes, 2)
+            else l
+            end
+          end.join
+        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 note_set.include?(note)
+            Paint[replacer(note)[size == 2 ? 0..2 : index], 'red']
+          end
+        end
+
+        def replacer(note)
+          case flavor
+          when :intervals then (note_set.root - note).name
+          when :marks then '◼ '
+          when :degrees then note_set.notes.degree(note).to_s.rjust(2, '0')
+          when :notes then note.pretty_name.to_s.ljust(2, "\u266E")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Coltrane
+  module Renderers
+    module TextRenderer
+      class TheoryChordDrawer < BaseDrawer
+        alias chord model
+
+        def render
+          "#{chord.name}: ".ljust(5) +
+          TextRenderer.render(chord.notes, **options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Coltrane
+  module Renderers
+    module TextRenderer
+      class TheoryNoteSetDrawer < BaseDrawer
+        def render
+          case flavor
+          when :marks, :notes, :degrees
+            model.pretty_names.join(' ')
+          when :intervals
+            model.map { |n| (model.first - n).name }.join(' ')
+          else raise WrongFlavorError
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Coltrane
+  module Renderers
+    module TextRenderer
+      class TheoryProgressionDrawer < BaseDrawer
+        alias progression model
+
+        def render
+          TextRenderer.render(progression.chords, **options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Coltrane
+  module Renderers
+    module TextRenderer
+      class TheoryProgressionSetDrawer < BaseDrawer
+        alias progression_set model
+
+        def render
+          progression_set.map do |progression|
+            "#{progression.notation.ljust(notation_width + 1, ' ')} in " \
+            "#{progression.scale} (#{progression.notes_out.size} notes out)"
+          end
+          .join("\n")
+        end
+
+        def notation_width
+          @notation_width ||=
+            progression_set.map(&:notation).map(&:size).max
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Coltrane
+  module Renderers
+    module TextRenderer
+      class TheoryScaleDrawer < BaseDrawer
+        alias scale model
+
+        def render
+          TextRenderer.render(scale.notes, **options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Coltrane
+  module Renderers
+    module TextRenderer
+      class TheoryScaleSetDrawer < BaseDrawer
+        alias scale_set model
+
+        def render
+          output = []
+          scale_width = scale_set.results.keys.map(&:size).max
+          scale_set.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 / scale_set.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["#{Theory::Note[tone_number].name}(#{notes.size})", color, und]
+              output << ' '
+            end
+            output << "\n"
+          end
+          output.join
+        end
+      end
+    end
+  end
+end