outro_rails 0.1.0

data/app/helpers/outro_rails/chords_helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module OutroRails
+  module ChordsHelper
+    def chord_root_options
+      Theory::NoteName::CANONICAL_ROOTS
+    end
+
+    def chord_quality_options
+      Theory::ChordVocabulary::QUALITIES.keys.map do |quality|
+        [ quality.to_s.humanize, quality ]
+      end
+    end
+
+    def chord_extension_options
+      [ [ "(none)", "none" ] ] +
+        Theory::ChordVocabulary::EXTENSIONS.keys.map do |extension|
+          [ extension.to_s, extension ]
+        end
+    end
+
+    def chord_alteration_options
+      Theory::ChordVocabulary::ALTERATIONS.keys.map(&:to_s)
+    end
+
+    def chord_added_tone_options
+      Theory::ChordVocabulary::ADDED_TONE_INTERVALS.keys.map(&:to_s)
+    end
+  end
+end

data/app/helpers/outro_rails/circle_of_fifths_helper.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module OutroRails
+  module CircleOfFifthsHelper
+    WEDGE_DEGREES = 360.0 / 12
+    WEDGE_GAP_DEGREES = 1.0
+
+    def circle_point(cx, cy, radius, degrees)
+      radians = (degrees - 90) * Math::PI / 180
+
+      [ (cx + radius * Math.cos(radians)).round(2),
+        (cy + radius * Math.sin(radians)).round(2) ]
+    end
+
+    def wedge_path(cx, cy, inner_radius, outer_radius, index)
+      from = (index * WEDGE_DEGREES) - (WEDGE_DEGREES / 2) + WEDGE_GAP_DEGREES
+      to   = (index * WEDGE_DEGREES) + (WEDGE_DEGREES / 2) - WEDGE_GAP_DEGREES
+
+      o1 = circle_point(cx, cy, outer_radius, from)
+      o2 = circle_point(cx, cy, outer_radius, to)
+      i2 = circle_point(cx, cy, inner_radius, to)
+      i1 = circle_point(cx, cy, inner_radius, from)
+
+      "M #{o1[0]} #{o1[1]} " \
+        "A #{outer_radius} #{outer_radius} 0 0 1 #{o2[0]} #{o2[1]} " \
+        "L #{i2[0]} #{i2[1]} " \
+        "A #{inner_radius} #{inner_radius} 0 0 0 #{i1[0]} #{i1[1]} Z"
+    end
+
+    def wedge_label_point(cx, cy, inner_radius, outer_radius, index)
+      circle_point(cx,
+                   cy,
+                   (inner_radius + outer_radius) / 2.0,
+                   index * WEDGE_DEGREES)
+    end
+
+    def key_signature_label(key)
+      count = key.signature
+      return "no sharps or flats" if count.zero?
+
+      pluralize(count.abs, count.positive? ? "sharp" : "flat")
+    end
+  end
+end

data/app/helpers/outro_rails/instruments_helper.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module OutroRails
+  module InstrumentsHelper
+    GUITAR_STANDARD_TUNING = Instruments::Guitar::STANDARD_TUNING
+
+    def guitar_tunings
+      Instruments::Guitar::Tunings.all
+    end
+
+    def guitar_tuning_options
+      guitar_tunings.map { |tuning| [ tuning.label, tuning.slug ] }
+    end
+
+    def note_to_midi(note)
+      Theory::Pitch.parse(note).midi
+    end
+    alias piano_note_to_midi note_to_midi # legacy name
+
+    def midi_to_note(midi, prefer: :sharps)
+      Theory::Pitch.from_midi(midi, prefer: prefer).to_s
+    end
+    alias piano_midi_to_note midi_to_note # legacy name
+
+    def midi_to_note_name(midi, prefer: :sharps)
+      Theory::Pitch.from_midi(midi, prefer: prefer).note_name.to_s
+    end
+
+    def guitar_open_midis(tuning = GUITAR_STANDARD_TUNING)
+      Instruments::Guitar.new(tuning: tuning).open_midis
+    end
+
+    def guitar_positions(positions)
+      Instruments::Guitar.normalize_positions(positions)
+    end
+
+    def piano_keys_between(start_note, end_note, prefer: :sharps)
+      Instruments::Piano.keys_between(start_note, end_note, prefer: prefer)
+    end
+  end
+end

data/app/helpers/outro_rails/scales_helper.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module OutroRails
+  module ScalesHelper
+    def scale_root_options
+      Theory::NoteName::CANONICAL_ROOTS.map do |name|
+        note = Theory::NoteName.parse(name)
+        [ note.to_s, note.path_slug ]
+      end
+    end
+
+    def scale_type_options
+      Theory::Scale::PATTERNS.keys.map do |name|
+        [ name.to_s.humanize, name.to_s.tr("_", "-") ]
+      end
+    end
+
+    def scale_instrument_label(instrument)
+      instrument.to_s.titleize
+    end
+
+    def scale_path_for(scale, instrument, tuning: nil)
+      if instrument == "guitar" && tuning && !tuning.standard?
+        guitar_tuning_scale_path(scale.root.path_slug, scale.slug, tuning.slug)
+      else
+        instrument_scale_path(instrument, scale.root.path_slug, scale.slug)
+      end
+    end
+
+    def scale_link(scale, instrument, tuning: nil)
+      link_to scale.to_s, scale_path_for(scale, instrument, tuning: tuning)
+    end
+  end
+end

data/app/helpers/outro_rails/transposer_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module OutroRails
+  module TransposerHelper
+    def transposer_mode_options
+      [
+        [ "Chords → Chords (new key)", "chords_to_chords" ],
+        [ "Chords → Nashville Numbers", "chords_to_nashville" ],
+        [ "Nashville Numbers → Chords", "nashville_to_chords" ]
+      ]
+    end
+
+    def transposer_key_options
+      {
+        "Major keys" => Theory::Key.canonical(:major).map(&:to_s),
+        "Minor keys" => Theory::Key.canonical(:minor).map(&:to_s)
+      }
+    end
+
+    def semitone_shift_label(semitones)
+      return "same key (0 semitones)" if semitones.zero?
+
+      label = "+#{semitones} #{"semitone".pluralize(semitones)} up"
+      semitones > 6 ? "#{label} (−#{12 - semitones} down)" : label
+    end
+  end
+end

data/app/jobs/outro_rails/application_job.rb

@@ -0,0 +1,4 @@
+module OutroRails
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/outro_rails/application_mailer.rb

@@ -0,0 +1,6 @@
+module OutroRails
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/outro_rails/application_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module OutroRails
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/outro_rails/chord.rb

@@ -0,0 +1,85 @@
+module OutroRails
+  class Chord < ApplicationRecord
+    QUALITIES = {
+      major: 0,
+      minor: 1,
+      diminished: 2,
+      augmented: 3,
+      suspended_2: 4,
+      suspended_4: 5,
+      power: 6
+    }.freeze
+
+    EXTENSIONS  = %w[6 7 maj7 dim7 9 11 13].freeze
+    ALTERATIONS = %w[b5 #5 b9 #9 #11 b13].freeze
+    ADDED_TONES = %w[add2 add4 add6 add9 add11 add13].freeze
+
+    enum :quality, QUALITIES
+
+    serialize :alterations, coder: JSON, type: Array
+    serialize :added_tones, coder: JSON, type: Array
+    serialize :intervals,   coder: JSON, type: Array
+
+    has_many :voicings,
+             class_name: "OutroRails::ChordVoicing",
+             inverse_of: :chord,
+             dependent: :destroy
+
+    validate :added_tones_are_known
+    validate :alterations_are_known
+    validates :extension,
+              inclusion: { in: EXTENSIONS },
+              allow_nil: true
+    validates :quality, presence: true
+    validates :root_name, presence: true
+    validates :root_pitch_class,
+              presence: true,
+              inclusion: { in: 0..11 }
+    validates :slug,
+              presence: true,
+              uniqueness: true
+    validates :symbol,
+              presence: true,
+              uniqueness: true
+
+    scope :for_root_pitch_class, ->(pitch_class) { where(root_pitch_class: pitch_class) }
+
+    def to_param
+      slug
+    end
+
+    def display_extension
+      extension.presence || "-"
+    end
+
+    def display_alterations
+      Array(alterations).any? ? alterations.join(", ") : "-"
+    end
+
+    def display_added_tones
+      Array(added_tones).any? ? added_tones.join(", ") : "-"
+    end
+
+    def display_intervals
+      Array(intervals).join(" - ")
+    end
+
+    private
+
+    def alterations_are_known
+      unknown = Array(alterations) - ALTERATIONS
+      if unknown.any?
+        errors.add(:alterations,
+                   "contains unknown values: #{unknown.join(', ')}")
+      end
+    end
+
+    def added_tones_are_known
+      unknown = Array(added_tones) - ADDED_TONES
+      if unknown.any?
+        errors.add(:added_tones,
+                   "contains unknown values: #{unknown.join(', ')}")
+      end
+    end
+  end
+end

data/app/models/outro_rails/chord_chart/voicing.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module OutroRails
+  class ChordChart
+    class Voicing < ApplicationRecord
+      self.table_name = "outro_rails_chord_chart_voicings"
+
+      enum :instrument, Instruments::ENUM_VALUES
+
+      belongs_to :chord_chart,
+                 class_name: "OutroRails::ChordChart",
+                 inverse_of: :voicings
+      belongs_to :chord, class_name: "OutroRails::Chord"
+      belongs_to :chord_voicing, class_name: "OutroRails::ChordVoicing"
+
+      before_validation :normalize_bass
+
+      validates :instrument, presence: true
+      validates :bass,
+                format: { with: /\A(?:#{Theory::NoteName::NAME_PATTERN})?\z/,
+                          message: "must be a note name or blank" },
+                allow_nil: false
+      validates :chord_id,
+                uniqueness: { scope: %i[chord_chart_id instrument bass] }
+      validate :chord_voicing_matches_chord_and_instrument
+
+      def self.normalize_bass(value)
+        return "" if value.to_s.strip.empty?
+
+        Theory::NoteName.parse(value).to_s
+      rescue ArgumentError
+        value.to_s
+      end
+
+      private
+
+      def normalize_bass
+        self.bass = self.class.normalize_bass(bass)
+      end
+
+      def chord_voicing_matches_chord_and_instrument
+        return if chord_voicing.blank? || chord.blank?
+
+        if chord_voicing.chord_id != chord_id
+          errors.add(:chord_voicing, "must be a voicing of the selected chord")
+        end
+
+        if chord_voicing.instrument != instrument
+          errors.add(:chord_voicing, "must be a #{instrument} voicing")
+        end
+      end
+    end
+  end
+end

data/app/models/outro_rails/chord_chart.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module OutroRails
+  class ChordChart < ApplicationRecord
+    self.table_name = "outro_rails_chord_charts"
+
+    KEY_OPTIONS = (
+      Theory::Key.canonical(:major).map(&:to_s) +
+      Theory::Key.canonical(:minor).map(&:to_s)
+    ).freeze
+
+    belongs_to :record, polymorphic: true, touch: true
+
+    has_many :voicings,
+             class_name: "OutroRails::ChordChart::Voicing",
+             foreign_key: :chord_chart_id,
+             inverse_of: :chord_chart,
+             dependent: :destroy
+
+    before_validation :apply_defaults
+
+    validates :name, presence: true
+    validates :artist, presence: true
+    validates :song, presence: true
+    validates :body, presence: true
+    validates :tuning,
+              inclusion: { in: Instruments::Guitar::Tunings.slugs },
+              allow_blank: true
+    validates :capo,
+              inclusion: { in: Instruments::Guitar::Capo::FRETS },
+              allow_nil: true
+    validates :key, inclusion: { in: KEY_OPTIONS }, allow_blank: true
+
+    def to_key
+      Theory::Key.parse(key.presence || "C")
+    end
+
+    def to_tuning
+      Instruments::Guitar::Tunings.fetch(tuning)
+    end
+
+    def chord_symbols
+      Theory::Transposer.scan_chords(body.to_s)
+    end
+
+    def display_chord_symbols(to_key: nil)
+      target = to_key.presence || key
+      symbols = chord_symbols
+      return symbols if symbols.empty? || target.to_s == key.to_s
+
+      Theory::Transposer.transpose_chords(symbols.join(" "),
+                                          from: self.to_key,
+                                          to: target).split(/\s+/)
+    end
+
+    def display_chords(to_key: nil)
+      symbols = display_chord_symbols(to_key: to_key)
+      base_symbols = symbols.index_with do |symbol|
+        Theory::Transposer.split_bass(symbol).first
+      end
+      chords = Chord.where(symbol: base_symbols.values.uniq).index_by(&:symbol)
+
+      symbols.each_with_object({}) do |symbol, found|
+        chord = chords[base_symbols[symbol]]
+        found[symbol] = chord if chord
+      end
+    end
+
+    def voicing_for(chord, instrument, transposed: false, bass: nil)
+      unless transposed
+        selection_bass = Voicing.normalize_bass(bass)
+        selection = voicings.detect do |candidate|
+          candidate.chord_id == chord.id &&
+            candidate.instrument == instrument.to_s &&
+            candidate.bass == selection_bass
+        end
+        return selection.chord_voicing if selection
+      end
+
+      default_voicing_for(chord, instrument, bass: bass)
+    end
+
+    def default_voicing_for(chord, instrument, bass: nil)
+      voicings = chord.voicings
+                      .where(instrument: instrument)
+                      .order(:position)
+
+      if bass.present?
+        bass_pitch_class = Theory::NoteName.parse(bass).pitch_class
+        slash_voicing = voicings.detect do |voicing|
+                          voicing.bass_pitch_class == bass_pitch_class
+                        end
+        return slash_voicing if slash_voicing
+      end
+
+      voicings.first
+    end
+
+    private
+
+    def apply_defaults
+      self.tuning = Instruments::Guitar::Tunings::DEFAULT_SLUG if tuning.blank?
+      self.key = "C" if key.blank?
+    end
+  end
+end

data/app/models/outro_rails/chord_voicing.rb

@@ -0,0 +1,45 @@
+module OutroRails
+  class ChordVoicing < ApplicationRecord
+    enum :instrument, Instruments::ENUM_VALUES
+
+    serialize :display_data, coder: JSON
+    serialize :notes, coder: JSON, type: Array
+
+    belongs_to :chord,
+               class_name: "OutroRails::Chord",
+               inverse_of: :voicings
+
+    validates :bass_pitch_class,
+              inclusion: { in: 0..11 },
+              allow_nil: true
+    validates :instrument, presence: true
+    validates :position,
+              presence: true,
+              uniqueness: {
+                scope: %i[chord_id instrument],
+                message: "already exists for this chord and instrument"
+              }
+    validates :symbol, presence: true
+
+    scope :for_instrument, ->(instrument) { where(instrument: instrument) }
+
+    def self.find_by_param(param)
+      *slug_parts, instrument, position = param.to_s.split("-")
+      chord = Chord.find_by(slug: slug_parts.join("-"))
+
+      chord&.voicings&.find_by(instrument: instrument, position: position.to_i)
+    end
+
+    def to_param
+      "#{chord.slug}-#{instrument}-#{position}"
+    end
+
+    def preferred_accidentals
+      Theory::NoteName.preferred_accidentals(Array(notes))
+    end
+
+    def display_notes
+      Array(notes).join(" - ")
+    end
+  end
+end

data/app/views/layouts/outro_rails/application.html.erb

@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>
+      <% if content_for?(:title) %>
+        <%= yield(:title) %> | Outro
+      <% else %>
+        Outro
+      <% end %>
+    </title>
+
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+
+    <%= csrf_meta_tags %>
+    <%= csp_meta_tag %>
+
+    <%= stylesheet_link_tag 'outro_rails/outro_rails' %>
+    <%= javascript_include_tag 'outro_rails/outro_rails', defer: true %>
+
+    <%= yield :head %>
+  </head>
+
+  <body class="outro-page">
+    <main>
+      <%= yield %>
+    </main>
+  </body>
+</html>

data/app/views/outro_rails/caged/show.html.erb

@@ -0,0 +1,78 @@
+<% content_for :title, "CAGED - #{@root} · #{@letter} shape" %>
+
+<div class="outro outro-container">
+
+  <%= render "outro_rails/shared/header",
+          title: 'CAGED Shapes',
+          subtitle: "#{@letter}-shape chords rooted on #{@root}."
+      %>
+
+  <%= render "outro_rails/shared/breadcrumb", trail: [
+        [ "Outro Home", root_path ],
+        [ "CAGED Shapes", caged_path ],
+        [ "#{@root} · #{@letter} shape" ]
+      ] %>
+
+  <%= form_with url: caged_picker_path, method: :get,
+        class: "outro-picker" do %>
+    <label class="outro-picker__field">
+      <span class="outro-label">Root</span>
+      <%= select_tag :root,
+            options_for_select(scale_root_options, @root.path_slug),
+            class: "outro-select",
+            onchange: "this.form.requestSubmit()" %>
+    </label>
+
+    <label class="outro-picker__field">
+      <span class="outro-label">Shape</span>
+      <%= select_tag :shape,
+            options_for_select(
+              OutroRails::Instruments::Guitar::ChordShapes::CAGED_LETTERS
+                .map { |l| [ "#{l} shape", l.downcase ] },
+              @letter.downcase
+            ),
+            class: "outro-select",
+            onchange: "this.form.requestSubmit()" %>
+    </label>
+
+    <%= button_tag type: :submit, name: nil,
+      class: "outro-button",
+      "aria-label": "Show Shapes" do %>
+      <%= image_tag "outro_rails/shapes.svg", class: 'outro-button__icon' %>
+      Show Shapes
+    <% end %>
+  <% end %>
+
+  <div class="outro-grid outro-grid--wide">
+    <% @entries.each do |entry| %>
+      <%
+        frets = entry.positions.map(&:last)
+        start_fret = frets.min.positive? ? frets.min - 1 : 0
+        end_fret = [ frets.max + 1, start_fret + 4 ].max
+
+        slug = OutroRails::Theory::ChordVocabulary.slug(entry.symbol)
+
+        detail = entry.quality.to_s.humanize.downcase
+        detail += " #{entry.extension}" if entry.extension
+      %>
+      <section class="outro-card outro-caged-chord">
+        <h2 class="outro-caged-chord__heading">
+          <%= link_to entry.symbol,
+                chord_path(slug),
+                class: "outro-caged-chord__symbol" %>
+          <small class="outro-caged-chord__detail">
+            <%= detail %>
+            · <%= entry.shape.name.to_s.tr("_", " ") %> shape
+          </small>
+        </h2>
+
+        <%= render "outro_rails/instruments/guitar_midi",
+              start_fret: start_fret,
+              end_fret: end_fret,
+              highlight_frets: entry.positions,
+              root_frets: entry.root_positions,
+              prefer: @prefer.to_s %>
+      </section>
+    <% end %>
+  </div>
+</div>

data/app/views/outro_rails/capo/show.html.erb

@@ -0,0 +1,62 @@
+<% content_for :title, "Capo Chart - #{capo_fret_label(@fret)}" %>
+
+<div class="outro outro-container">
+
+  <%= render "outro_rails/shared/header",
+          title: 'Guitar Capo Chart',
+          subtitle: 'Pick a capo position to see what each open shape actually
+                    sounds like.'
+      %>
+
+  <%= render "outro_rails/shared/breadcrumb", trail: [
+        [ "Outro Home", root_path ],
+        [ "Guitar Capo Chart" ]
+      ] %>
+
+  <div class="outro-panel outro-filters">
+    <span class="outro-label" id="capo-position-label">Capo position</span>
+    <nav class="outro-chip-row outro-capo-frets"
+         aria-labelledby="capo-position-label">
+      <% OutroRails::Instruments::Guitar::Capo::FRETS.each do |fret| %>
+        <% if fret == @fret %>
+          <span class="outro-chip outro-chip--current" aria-current="true">
+            <span class="outro-chip__label"><%= capo_fret_label(fret) %></span>
+          </span>
+        <% else %>
+          <%= link_to capo_fret_path(fret),
+                class: "outro-chip outro-chip--link" do %>
+            <span class="outro-chip__label"><%= capo_fret_label(fret) %></span>
+          <% end %>
+        <% end %>
+      <% end %>
+    </nav>
+  </div>
+
+  <section class="outro-card">
+    <h2 class="outro-section-heading">
+      <%= @fret.zero? ? "Capo off" : "Capo on fret #{@fret}" %>
+      <% if @fret.zero? %>
+        <span class="outro-symbol-list__detail">open position</span>
+      <% end %>
+    </h2>
+
+    <div class="outro-table-scroll">
+      <table class="outro-table outro-capo-chart">
+        <thead>
+          <tr>
+            <th scope="col">Shape</th>
+            <th scope="col">Sounds like</th>
+          </tr>
+        </thead>
+        <tbody>
+          <% @rows.each do |shape, sounding| %>
+            <tr>
+              <td>Shape <%= shape.caged_letter %></td>
+              <td class="outro-table__symbol"><%= sounding %></td>
+            </tr>
+          <% end %>
+        </tbody>
+      </table>
+    </div>
+  </section>
+</div>