outro_rails 0.1.0

data/app/controllers/concerns/outro_rails/guitar_tuning_selectable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module OutroRails
+  module GuitarTuningSelectable
+    extend ActiveSupport::Concern
+
+    private
+
+    def guitar_tuning_or_default(instrument)
+      return Instruments::Guitar::Tunings.default unless instrument == "guitar"
+
+      Instruments::Guitar::Tunings.fetch(params[:tuning])
+    rescue ArgumentError
+      Instruments::Guitar::Tunings.default
+    end
+  end
+end

data/app/controllers/concerns/outro_rails/instrument_selectable.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module OutroRails
+  module InstrumentSelectable
+    extend ActiveSupport::Concern
+
+    INSTRUMENTS = OutroRails::Instruments::ALL
+
+    private
+
+    def instrument_or_default(value)
+      INSTRUMENTS.include?(value) ? value : INSTRUMENTS.first
+    end
+  end
+end

data/app/controllers/concerns/outro_rails/invalid_params_redirectable.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module OutroRails
+  module InvalidParamsRedirectable
+    extend ActiveSupport::Concern
+
+    included do
+      rescue_from ArgumentError, with: :redirect_invalid_params
+    end
+
+    class_methods do
+      def invalid_params_redirect(&fallback)
+        define_method(:invalid_params_fallback_path, &fallback)
+      end
+    end
+
+    private
+
+    def redirect_invalid_params
+      redirect_to invalid_params_fallback_path
+    end
+
+    def permitted!(value, allowed, label)
+      return value if allowed.include?(value)
+
+      raise ArgumentError, "unknown #{label} #{value.inspect}"
+    end
+  end
+end

data/app/controllers/concerns/outro_rails/root_selectable.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module OutroRails
+  module RootSelectable
+    extend ActiveSupport::Concern
+
+    DEFAULT_ROOT = "c"
+
+    private
+
+    def root_from_params
+      Theory::NoteName.from_slug(params[:root].presence || DEFAULT_ROOT)
+    end
+
+    def root_slug_from_params
+      (params[:root].presence || DEFAULT_ROOT).to_s.tr("_", "-")
+    end
+  end
+end

data/app/controllers/outro_rails/application_controller.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module OutroRails
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/controllers/outro_rails/caged/pickers_controller.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module OutroRails
+  module Caged
+    class PickersController < ApplicationController
+      include RootSelectable
+
+      def show
+        redirect_to caged_shape_path(
+          root_slug_from_params,
+          (params[:shape].presence || CagedController::DEFAULT_SHAPE).downcase
+        )
+      end
+    end
+  end
+end

data/app/controllers/outro_rails/caged_controller.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module OutroRails
+  class CagedController < ApplicationController
+    include InvalidParamsRedirectable
+    include RootSelectable
+
+    helper ScalesHelper
+    helper InstrumentsHelper
+
+    DEFAULT_SHAPE = "c"
+
+    invalid_params_redirect { caged_path }
+
+    ChordEntry = Struct.new(
+      :quality, :extension, :shape, :symbol, :positions, :root_positions,
+      keyword_init: true
+    )
+
+    def show
+      @root = root_from_params
+      @letter = permitted!(
+        (params[:shape].presence || DEFAULT_SHAPE).to_s.upcase,
+        Instruments::Guitar::ChordShapes::CAGED_LETTERS,
+        "shape"
+      )
+
+      @guitar = Instruments::Guitar.new
+      @prefer = @root.accidental_offset.negative? ? :flats : :sharps
+
+      @entries = Instruments::Guitar::ChordShapes
+        .chords_for_letter(@letter)
+        .map do |quality, extension, shape|
+          positions = Instruments::Guitar::ChordShapes.positions(
+            shape,
+            @root,
+            guitar: @guitar
+          )
+
+          ChordEntry.new(
+            quality: quality,
+            extension: extension,
+            shape: shape,
+            symbol: Theory::ChordVocabulary.symbol(
+              root_name: @root,
+              quality: quality,
+              extension: extension
+            ),
+            positions: positions,
+            root_positions: positions.select do |string, fret|
+              @guitar.pitch_class_at(string, fret) == @root.pitch_class
+            end
+          )
+        end
+    end
+  end
+end

data/app/controllers/outro_rails/capo_controller.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module OutroRails
+  class CapoController < ApplicationController
+    include InvalidParamsRedirectable
+
+    invalid_params_redirect { capo_path }
+
+    def show
+      @fret = Integer(params[:fret].presence || 0)
+      @rows = Instruments::Guitar::Capo.chart(@fret)
+    end
+  end
+end

data/app/controllers/outro_rails/chord_charts/voicings_controller.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module OutroRails
+  module ChordCharts
+    class VoicingsController < ApplicationController
+      before_action :set_chord_chart
+      before_action :authorize_chord_chart!
+      before_action :set_chord
+      before_action :set_instrument
+      before_action :set_bass
+
+      def index
+        set_voicings
+      end
+
+      def create
+        voicing = @chord.voicings.find(params.require(:chord_voicing_id))
+        selection = @chord_chart.voicings.find_or_initialize_by(
+          chord: @chord, instrument: @instrument, bass: @bass.to_s
+        )
+        selection.chord_voicing = voicing
+
+        if selection.save
+          redirect_to after_change_path,
+                      notice: "Now showing #{voicing.symbol} " \
+                        "for #{@chord.symbol}."
+        elsif return_to_path
+          redirect_to return_to_path,
+                      alert: selection.errors.full_messages.to_sentence
+        else
+          set_voicings
+          flash.now[:alert] = selection.errors.full_messages.to_sentence
+          render :index, status: :unprocessable_entity
+        end
+      end
+
+      def destroy
+        @chord_chart.voicings.find(params[:id]).destroy
+
+        redirect_to after_change_path,
+                    notice: "Reverted to the default voicing."
+      end
+
+      private
+
+      def set_chord_chart
+        @chord_chart = OutroRails::ChordChart.find(params[:chord_chart_id])
+      end
+
+      def authorize_chord_chart!
+        authorized = OutroRails.chord_chart_voicing_authorized?(
+          chord_chart: @chord_chart,
+          controller: self
+        )
+
+        return if authorized
+
+        head :forbidden
+      end
+
+      def set_chord
+        @chord = OutroRails::Chord.find(params[:chord_id])
+      end
+
+      def set_instrument
+        @instrument = OutroRails::ChordVoicing.instruments.key?(
+          params[:instrument]
+        ) ? params[:instrument] : "guitar"
+      end
+
+      def set_bass
+        @bass = Theory::NoteName.parse(params[:bass]).to_s
+      rescue ArgumentError
+        @bass = nil
+      end
+
+      def set_voicings
+        @voicings = @chord.voicings
+                          .where(instrument: @instrument).order(:position)
+        @selection = @chord_chart.voicings
+                                 .find_by(chord: @chord,
+                                          instrument: @instrument,
+                                          bass: @bass.to_s)
+        @default_voicing = @chord_chart.default_voicing_for(@chord,
+                                                            @instrument,
+                                                            bass: @bass)
+      end
+
+      def after_change_path
+        return_to_path || voicings_screen_path
+      end
+
+      def return_to_path
+        return @return_to_path if defined?(@return_to_path)
+
+        @return_to_path = url_from(params[:return_to])
+      end
+
+      def voicings_screen_path
+        chord_chart_voicings_path(
+          @chord_chart,
+          chord_id: @chord.id,
+          instrument: @instrument,
+          bass: @bass
+        )
+      end
+    end
+  end
+end

data/app/controllers/outro_rails/chord_voicings_controller.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module OutroRails
+  class ChordVoicingsController < ApplicationController
+    def show
+      @voicing = ChordVoicing.find_by_param(params[:id])
+      raise ActiveRecord::RecordNotFound, "no voicing #{params[:id].inspect}" unless @voicing
+
+      @chord = @voicing.chord
+    end
+  end
+end

data/app/controllers/outro_rails/chords/pickers_controller.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module OutroRails
+  module Chords
+    class PickersController < ApplicationController
+      def show
+        query = params[:q].to_s.strip
+        return redirect_to chords_path if query.empty?
+
+        chord = Chord.where(slug: lookup_candidates(query)).first
+
+        if chord
+          redirect_to chord_path(chord)
+        else
+          redirect_to chords_path(missing: query)
+        end
+      end
+
+      private
+
+      def lookup_candidates(query)
+        capitalized = query.sub(/\A([a-g])/) { Regexp.last_match(1).upcase }
+
+        [
+          query.downcase,
+          Theory::ChordVocabulary.slug(query),
+          Theory::ChordVocabulary.slug(capitalized)
+        ].uniq
+      end
+    end
+  end
+end

data/app/controllers/outro_rails/chords_controller.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module OutroRails
+  class ChordsController < ApplicationController
+    def index
+      @filters = filter_params
+
+      chords = Chord.order(:root_pitch_class, :symbol)
+      if @filters[:root].present?
+        chords = chords.where(root_name: @filters[:root])
+      end
+      if @filters[:quality].present?
+        chords = chords.where(quality: @filters[:quality])
+      end
+      chords =
+        case @filters[:extension]
+        when "none" then chords.where(extension: [ nil, "" ])
+        when nil, "" then chords
+        else chords.where(extension: @filters[:extension])
+        end
+      chords = chords.to_a
+
+      if @filters[:alteration].present?
+        chords.select! do |chord|
+          value_tokens(chord.alterations).include?(@filters[:alteration])
+        end
+      end
+
+      if @filters[:added_tone].present?
+        chords.select! do |chord|
+          value_tokens(chord.added_tones).include?(@filters[:added_tone])
+        end
+      end
+
+      @chords_by_root = chords.group_by(&:root_name)
+      @missing_query = params[:missing]
+    end
+
+    def show
+      @chord = Chord.find_by!(slug: params[:id])
+      @voicings = @chord.voicings.order(:instrument, :symbol)
+    end
+
+    private
+
+    def filter_params
+      params.permit(:root, :quality, :extension, :alteration, :added_tone)
+    end
+
+    def filters_active?
+      filter_params.to_h.values.any?(&:present?)
+    end
+    helper_method :filters_active?
+
+    def value_tokens(value)
+      return value.map(&:to_s) if value.is_a?(Array)
+
+      value.to_s.scan(/(?:add\d+|[b#]\d+)/)
+    end
+  end
+end

data/app/controllers/outro_rails/circle_of_fifths_controller.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module OutroRails
+  class CircleOfFifthsController < ApplicationController
+    include InvalidParamsRedirectable
+    include RootSelectable
+
+    helper ScalesHelper
+
+    MODES = %w[major minor].freeze
+
+    LINK_INSTRUMENT = Instruments::ALL.first
+
+    invalid_params_redirect { circle_of_fifths_path }
+
+    def show
+      mode = permitted!(params[:mode].presence || "major", MODES, "mode")
+
+      @key = Theory::Key.new(root_from_params, mode.to_sym)
+      @scale = @key.scale
+
+      @positions = Theory::Key.circle_positions
+      @selected_index = @positions.index do |position|
+        position.pitch_class == wheel_pitch_class
+      end
+      @dominant_index = (@selected_index + 1) % @positions.size
+      @subdominant_index = (@selected_index - 1) % @positions.size
+      @subdominant = Theory::Key.new(@scale.degree(4), @key.mode)
+      @dominant = Theory::Key.new(@scale.degree(5), @key.mode)
+    end
+
+    private
+
+    def wheel_pitch_class
+      (@key.major? ? @key : @key.relative).tonic.pitch_class
+    end
+  end
+end

data/app/controllers/outro_rails/home_controller.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module OutroRails
+  class HomeController < ApplicationController
+    def index
+    end
+  end
+end

data/app/controllers/outro_rails/instruments/pickers_controller.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module OutroRails
+  module Instruments
+    class PickersController < ApplicationController
+      include InstrumentSelectable
+      include GuitarTuningSelectable
+
+      def show
+        instrument = instrument_or_default(params[:instrument])
+        tuning = guitar_tuning_or_default(instrument)
+
+        if instrument == "guitar" && !tuning.standard?
+          redirect_to guitar_tuning_instrument_path(tuning.slug)
+        else
+          redirect_to instrument_path(instrument)
+        end
+      end
+    end
+  end
+end

data/app/controllers/outro_rails/instruments_controller.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module OutroRails
+  class InstrumentsController < ApplicationController
+    include InvalidParamsRedirectable
+    include InstrumentSelectable
+
+    invalid_params_redirect { instrument_path(@instrument ||
+                              INSTRUMENTS.first) }
+
+    def index
+      @instruments = OutroRails::Instruments::ALL
+    end
+
+    def show
+      @instrument = INSTRUMENTS.detect { |i| i == params[:instrument] }
+      raise ActionController::RoutingError, "Not Found" unless @instrument
+
+      if @instrument == "guitar"
+        @tuning = Instruments::Guitar::Tunings.fetch(params[:tuning])
+      end
+    end
+  end
+end

data/app/controllers/outro_rails/scales/pickers_controller.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module OutroRails
+  module Scales
+    class PickersController < ApplicationController
+      include InstrumentSelectable
+      include RootSelectable
+      include GuitarTuningSelectable
+
+      def show
+        instrument = instrument_or_default(params[:instrument])
+        root       = root_slug_from_params
+        type = (
+                  params[:type].presence ||
+                  ScalesController::DEFAULT_TYPE
+                ).tr("_", "-")
+        tuning     = guitar_tuning_or_default(instrument)
+
+        if instrument == "guitar" && !tuning.standard?
+          redirect_to guitar_tuning_scale_path(root, type, tuning.slug)
+        else
+          redirect_to instrument_scale_path(instrument, root, type)
+        end
+      end
+    end
+  end
+end

data/app/controllers/outro_rails/scales_controller.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module OutroRails
+  class ScalesController < ApplicationController
+    include InvalidParamsRedirectable
+    include RootSelectable
+    include InstrumentSelectable
+
+    helper InstrumentsHelper
+
+    DEFAULT_TYPE = "major"
+
+    invalid_params_redirect { instrument_scales_path(@instrument) }
+
+    def index
+    end
+
+    def show
+      @instrument = params.fetch(:instrument)
+      @scale = Theory::Scale.new(root_from_params, type_param)
+
+      case @instrument
+      when "piano"  then prepare_piano
+      when "guitar" then prepare_guitar
+      end
+    end
+
+    private
+
+    def type_param
+      type = (params[:type].presence || DEFAULT_TYPE).to_s.tr("-", "_").to_sym
+      unless Theory::Scale.pattern?(type)
+        raise ArgumentError, "unknown scale #{type.inspect}"
+      end
+
+      type
+    end
+
+    def tuning_param
+      Instruments::Guitar::Tunings.fetch(params[:tuning])
+    end
+
+    def prepare_piano
+      @pitches = @scale.pitched_notes(start_octave: 4, octaves: 1)
+      @root_pitches = @pitches.select { |pitch| pitch.note_name == @scale.root }
+      @start_note, @end_note = Instruments::Piano.display_range(
+        @pitches, prefer: @scale.preferred_accidentals
+      )
+    end
+
+    def prepare_guitar
+      @tuning = tuning_param
+      @guitar = Instruments::Guitar.in_tuning(@tuning)
+      @positions = @guitar.positions_in(@scale)
+      @root_positions = @guitar.positions_of(@scale.root)
+    end
+  end
+end

data/app/controllers/outro_rails/transposer_controller.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module OutroRails
+  class TransposerController < ApplicationController
+    include InvalidParamsRedirectable
+
+    MODES = %w[chords_to_chords chords_to_nashville nashville_to_chords].freeze
+    DEFAULT_MODE = "chords_to_chords"
+
+    invalid_params_redirect { transposer_path }
+
+    def show
+      @mode = MODES.include?(params[:mode]) ? params[:mode] : DEFAULT_MODE
+      @text = params[:text].to_s
+      @from_key = Theory::Key.parse(params[:from_key].presence || "C")
+      @to_key = Theory::Key.parse(params[:to_key].presence || "C")
+
+      return if @text.blank?
+
+      case @mode
+      when "chords_to_chords"
+        @result = Theory::Transposer.transpose_chords(@text,
+                                                      from: @from_key,
+                                                      to: @to_key)
+        @semitones = @from_key.interval_to(@to_key)
+      when "chords_to_nashville"
+        @result = Theory::Transposer.chords_to_nashville(@text, key: @from_key)
+      when "nashville_to_chords"
+        @result = Theory::Transposer.nashville_to_chords(@text, key: @to_key)
+      end
+    end
+  end
+end

data/app/helpers/outro_rails/application_helper.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module OutroRails
+  module ApplicationHelper
+    include InstrumentsHelper
+  end
+end

data/app/helpers/outro_rails/capo_helper.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module OutroRails
+  module CapoHelper
+    def capo_fret_label(fret)
+      fret.zero? ? "Open" : "Fret #{fret}"
+    end
+  end
+end

data/app/helpers/outro_rails/chord_charts_helper.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module OutroRails
+  module ChordChartsHelper
+    include CapoHelper
+    include InstrumentsHelper
+    include TransposerHelper
+
+    def chord_chart_tuning_options
+      guitar_tuning_options
+    end
+
+    def chord_chart_capo_options
+      Instruments::Guitar::Capo::FRETS.map do |fret|
+        [ capo_fret_label(fret), fret ]
+      end
+    end
+
+    def chord_chart_key_options
+      transposer_key_options
+    end
+
+    def chord_chart_instrument_options
+      Instruments::ALL.map { |instrument| [ instrument.titleize, instrument ] }
+    end
+
+    def chord_chart_area(form, method, **options)
+      chord_chart = form.object.public_send(method)
+
+      form.fields_for(:"chord_chart_#{method}",
+                      chord_chart, **options) do |chord_chart_form|
+        render partial: "outro_rails/chord_charts/fields",
+               locals: { f: chord_chart_form }
+      end
+    end
+
+    def chord_chart_body(chord_chart, to_key: nil)
+      target = to_key.presence || chord_chart.key
+      escaped = ERB::Util.html_escape(chord_chart.body.to_s)
+
+      Theory::Transposer.annotate_chords(escaped,
+                                         from: chord_chart.to_key,
+                                         to: target) do |symbol|
+        content_tag(:span,
+                    symbol,
+                    class: "outro-chord-chart__chord",
+                    data: { chord: symbol })
+      end.html_safe
+    end
+  end
+end