outro_rails 0.1.0

data/lib/outro_rails/theory/note_name.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module OutroRails
+  module Theory
+    # A spelled note name without an octave: a letter plus an accidental
+    # ('C', 'F#', 'Bbb'). Two NoteNames can share a pitch class but still be
+    # different notes (C# vs Db), which matters for keys, transposition and
+    # correct chord spelling.
+    class NoteName
+      include Comparable
+
+      LETTERS = %w[C D E F G A B].freeze
+
+      LETTERS_PER_OCTAVE = LETTERS.size
+
+      NATURAL_PITCH_CLASSES = {
+        "C" => 0,
+        "D" => 2,
+        "E" => 4,
+        "F" => 5,
+        "G" => 7,
+        "A" => 9,
+        "B" => 11
+      }.freeze
+
+      # Offset in semitones contributed by each accidental spelling.
+      ACCIDENTAL_OFFSETS = {
+        "bb" => -2,
+        "b"  => -1,
+        ""   =>  0,
+        "#"  =>  1,
+        "##" =>  2
+      }.freeze
+
+      ACCIDENTALS_BY_OFFSET = ACCIDENTAL_OFFSETS.invert.freeze
+
+      # The root names the app generates chords for - every pitch class,
+      # with both spellings where two are in common use.
+      CANONICAL_ROOTS = %w[C C# Db D D# Eb E F F# Gb G G# Ab A A# Bb B].freeze
+
+      # Preferred spelling of each pitch class in sharp and flat contexts.
+      SHARP_NAMES = %w[C C# D D# E F F# G G# A A# B].freeze
+      FLAT_NAMES  = %w[C Db D Eb E F Gb G Ab A Bb B].freeze
+
+      # Shared regex fragments - Pitch and Transposer build their note
+      # patterns from these so the spelling grammar lives in one place.
+      ACCIDENTAL_PATTERN = /##|bb|[#b]/
+      NAME_PATTERN = /[A-G](?:#{ACCIDENTAL_PATTERN})?/
+
+      PARSE_PATTERN = /\A([A-Ga-g])(#{ACCIDENTAL_PATTERN})?\z/
+
+      attr_reader :letter, :accidental
+
+      # Accepts a NoteName or a string like 'C', 'f#', 'Ebb'.
+      def self.parse(value)
+        return value if value.is_a?(self)
+
+        match = value.to_s.strip.match(PARSE_PATTERN)
+        raise ArgumentError, "Invalid note name: #{value.inspect}" unless match
+
+        new(match[1].upcase, match[2].to_s)
+      end
+
+      # Inverse of #path_slug: 'f-sharp' => F#, 'b-flat' => Bb, 'c' => C.
+      # Legacy underscore slugs ('f_sharp') are still accepted.
+      def self.from_slug(slug)
+        parse(slug.to_s
+                  .strip
+                  .downcase
+                  .tr("_", "-")
+                  .gsub("-sharp", "#")
+                  .gsub("-flat", "b"))
+      end
+
+      # :sharps when any of the spelled names uses a sharp, else :flats -
+      # the spelling that matches a set of notes, for naming pitches the
+      # set itself doesn't spell (keyboard ranges, fretboard labels).
+      def self.preferred_accidentals(names)
+        names.any? { |name| name.to_s.include?("#") } ? :sharps : :flats
+      end
+
+      # Names a bare pitch class (0..11), preferring sharp or flat spelling.
+      def self.for_pitch_class(pitch_class, prefer: :sharps)
+        table = prefer == :flats ? FLAT_NAMES : SHARP_NAMES
+        parse(table[pitch_class % Interval::SEMITONES_PER_OCTAVE])
+      end
+
+      def initialize(letter, accidental = "")
+        @letter = letter
+        @accidental = accidental
+
+        NATURAL_PITCH_CLASSES.fetch(letter) do
+          raise ArgumentError, "Unknown letter #{letter.inspect}"
+        end
+        ACCIDENTAL_OFFSETS.fetch(accidental) do
+          raise ArgumentError, "Unknown accidental #{accidental.inspect}"
+        end
+
+        freeze
+      end
+
+      def pitch_class
+        (NATURAL_PITCH_CLASSES.fetch(letter) +
+          ACCIDENTAL_OFFSETS.fetch(accidental)) % Interval::SEMITONES_PER_OCTAVE
+      end
+
+      def accidental_offset
+        ACCIDENTAL_OFFSETS.fetch(accidental)
+      end
+
+      # Semitones above the octave's C, accidental included and *not*
+      # wrapped: Cb => -1, B# => 12. Pitch relies on this so that the
+      # written octave follows the letter.
+      def letter_natural_midi_offset
+        NATURAL_PITCH_CLASSES.fetch(letter) + accidental_offset
+      end
+
+      def letter_index
+        LETTERS.index(letter)
+      end
+
+      # The correctly spelled note `semitones` above this one: the letter
+      # moves the number of scale-letter steps above the note that
+      # Interval defines for that many semitones, and the accidental is
+      # whatever makes the pitch come out right, e.g. E.at_interval(4) => G#,
+      # Db.at_interval(3) => Fb (not E).
+      # Double accidentals are respelled enharmonically (G## => A) to match
+      # how chord tones are conventionally written.
+      #
+      # Raises ArgumentError if Interval defines no letter step for
+      # `semitones` (an interval the app never spells, e.g. 1 or 12), or if
+      # the result would still need more than one accidental.
+      def at_interval(semitones)
+        step = Interval.letter_steps!(semitones)
+
+        index = (letter_index + step) % LETTERS.size
+        target = (pitch_class + semitones) % Interval::SEMITONES_PER_OCTAVE
+        diff = accidental_diff(target, index)
+
+        if diff.abs == 2
+          index = (index + (diff / 2)) % LETTERS.size
+          diff = accidental_diff(target, index)
+        end
+        if diff.abs > 1
+          raise ArgumentError,
+                "cannot spell interval #{semitones} above #{self}"
+        end
+
+        self.class.new(LETTERS[index], ACCIDENTALS_BY_OFFSET.fetch(diff))
+      end
+
+      # Spells the note `letter_steps` letters up whose pitch class is
+      # `pitch_class + semitones`. Unlike #at_interval this keeps double
+      # accidentals, which scale spelling needs (G# major contains F##).
+      def at_degree(semitones, letter_steps)
+        index = (letter_index + letter_steps) % LETTERS.size
+        target = (pitch_class + semitones) % Interval::SEMITONES_PER_OCTAVE
+        diff = accidental_diff(target, index)
+
+        accidental = ACCIDENTALS_BY_OFFSET.fetch(diff) do
+          raise ArgumentError,
+                "cannot spell #{semitones} semitones above #{self} on" \
+                "letter #{LETTERS[index]}"
+        end
+
+        self.class.new(LETTERS[index], accidental)
+      end
+
+      # Simple chromatic transposition; picks sharp or flat spelling for the
+      # result. Spelling-aware transposition should go through Key instead.
+      def transpose(semitones, prefer: :sharps)
+        self.class.for_pitch_class(pitch_class + semitones, prefer: prefer)
+      end
+
+      def to_s
+        "#{letter}#{accidental}"
+      end
+      alias name to_s
+
+      def inspect
+        "#<#{self.class.name} #{self}>"
+      end
+
+      # Used for URL segments, e.g. F# => 'f-sharp', Bb => 'b-flat'.
+      def path_slug
+        to_s.gsub("b", "-flat").gsub("#", "-sharp").downcase
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          letter == other.letter &&
+          accidental == other.accidental
+      end
+      alias eql? ==
+
+      def hash
+        [ letter, accidental ].hash
+      end
+
+      def <=>(other)
+        [
+          letter_index,
+          accidental_offset
+        ] <=> [
+          other.letter_index,
+          other.accidental_offset
+        ]
+      end
+
+      private
+
+      # Semitone difference between a target pitch class and a letter's
+      # natural pitch class, folded into -6..6.
+      def accidental_diff(target_pitch_class, index)
+        diff =
+          (target_pitch_class -
+            NATURAL_PITCH_CLASSES.fetch(LETTERS[index])) %
+          Interval::SEMITONES_PER_OCTAVE
+
+        diff > 6 ? diff - Interval::SEMITONES_PER_OCTAVE : diff
+      end
+    end
+  end
+end

data/lib/outro_rails/theory/pitch.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module OutroRails
+  module Theory
+    # A NoteName pinned to an octave - a concrete key you could play.
+    # MIDI convention C4 == 60.
+    #
+    # The written octave follows the letter, not the sounding pitch:
+    # Cb4 sounds as B3 (midi 59) and B#3 sounds as C4 (midi 60).
+    class Pitch
+      include Comparable
+
+      # The anchor of the octave numbering: middle C is midi 60 in octave 4.
+      MIDDLE_C_MIDI = 60
+      MIDDLE_C_OCTAVE = 4
+
+      # A letter with optional accidental followed by an octave, which may
+      # be negative: "C4", "F#3", "Bb-1".
+      PARSE_PATTERN =
+          /\A([A-Ga-g](?:#{NoteName::ACCIDENTAL_PATTERN})?)(-?\d+)\z/
+
+      # The spelled note and its written octave
+      attr_reader :note_name, :octave
+
+      # Accepts a Pitch or a string like 'C4', 'F#3', 'Bb-1'.
+      def self.parse(value)
+        return value if value.is_a?(self)
+
+        match = value.to_s.strip.match(PARSE_PATTERN)
+        unless match
+          raise ArgumentError,
+                "Invalid pitch: #{value.inspect} " \
+                '(expected e.g. "C3", "F#4")'
+        end
+
+        new(NoteName.parse(match[1]), Integer(match[2]))
+      end
+
+      # 60 => C4. Prefer :sharps (default) or :flats for black keys.
+      def self.from_midi(midi, prefer: :sharps)
+        note = NoteName.for_pitch_class(midi, prefer: prefer)
+        new(note, (midi / Interval::SEMITONES_PER_OCTAVE) - 1)
+      end
+
+      # The pitch that *writes* as note_name and *sounds* at midi - the
+      # inverse of #midi for a chosen spelling. The written octave follows
+      # the letter, so Cb sounding at 59 is Cb4 (not B3), and B# sounding
+      # at 60 is B#3.
+      def self.sounding(note_name, midi)
+        note_name = NoteName.parse(note_name)
+        octave =
+          ((midi - note_name.accidental_offset) /
+            Interval::SEMITONES_PER_OCTAVE) - 1
+
+        new(note_name, octave)
+      end
+
+      # Takes a NoteName (or anything it parses) and a written octave.
+      # Instances are immutable.
+      def initialize(note_name, octave)
+        @note_name = NoteName.parse(note_name)
+        @octave = Integer(octave)
+        freeze
+      end
+
+      # 'C4' => 60, 'F#3' => 54, 'Fb4' => 64, 'Cb4' => 59, 'B#3' => 60
+      def midi
+        (octave + 1) * Interval::SEMITONES_PER_OCTAVE +
+          note_name.letter_natural_midi_offset
+      end
+
+      # Sounding pitch class, 0-11, so Cb4 and B3 both give 11.
+      def pitch_class
+        midi % Interval::SEMITONES_PER_OCTAVE
+      end
+
+      # A new Pitch this many semitones away, respelled from midi - the
+      # original spelling is not preserved.
+      def transpose(semitones, prefer: :sharps)
+        self.class.from_midi(midi + semitones, prefer: prefer)
+      end
+
+      # As written, e.g. "F#3"
+      def to_s
+        "#{note_name}#{octave}"
+      end
+
+      # Shows both the spelling and what it sounds as
+      def inspect
+        "#<#{self.class.name} #{self} midi=#{midi}>"
+      end
+
+      # Equality is by spelling, not sound: Cb4 != B3.
+      def ==(other)
+        other.is_a?(self.class) &&
+          note_name == other.note_name &&
+          octave == other.octave
+      end
+      alias eql? ==
+
+      # Hashes on spelling too, to stay consistent with #eql?
+      def hash
+        [ note_name, octave ].hash
+      end
+
+      # Sounding-pitch comparison (Cb4 == B3).
+      def <=>(other)
+        midi <=> other.midi
+      end
+    end
+  end
+end

data/lib/outro_rails/theory/scale.rb

@@ -0,0 +1,338 @@
+# frozen_string_literal: true
+
+module OutroRails
+  module Theory
+    # A scale: a root NoteName plus a named pattern. Not persisted - scales
+    # are generated on demand from the pattern table.
+    #
+    #   Theory::Scale.new('A', :natural_minor).note_names.map(&:to_s)
+    #   # => ['A', 'B', 'C', 'D', 'E', 'F', 'G']
+    class Scale
+      # Each degree is [semitones above root, letter steps above root].
+      # Carrying the letter step makes spelling unambiguous (F# major gets
+      # E#, not F; G# major gets F#).
+      PATTERNS = {
+        major:            [ [ 0, 0 ], [ 2, 1 ], [ 4, 2 ], [ 5, 3 ], [ 7, 4 ], [ 9, 5 ], [ 11, 6 ] ],
+        natural_minor:    [ [ 0, 0 ], [ 2, 1 ], [ 3, 2 ], [ 5, 3 ], [ 7, 4 ], [ 8, 5 ], [ 10, 6 ] ],
+        harmonic_minor:   [ [ 0, 0 ], [ 2, 1 ], [ 3, 2 ], [ 5, 3 ], [ 7, 4 ], [ 8, 5 ], [ 11, 6 ] ],
+        melodic_minor:    [ [ 0, 0 ], [ 2, 1 ], [ 3, 2 ], [ 5, 3 ], [ 7, 4 ], [ 9, 5 ], [ 11, 6 ] ],
+        major_pentatonic: [ [ 0, 0 ], [ 2, 1 ], [ 4, 2 ], [ 7, 4 ], [ 9, 5 ] ],
+        minor_pentatonic: [ [ 0, 0 ], [ 3, 2 ], [ 5, 3 ], [ 7, 4 ], [ 10, 6 ] ],
+        major_blues:      [ [ 0, 0 ], [ 2, 1 ], [ 3, 2 ], [ 4, 2 ], [ 7, 4 ], [ 9, 5 ] ],
+        minor_blues:      [ [ 0, 0 ], [ 3, 2 ], [ 5, 3 ], [ 6, 4 ], [ 7, 4 ], [ 10, 6 ] ],
+        # Modes of the major scale (ionian == major, aeolian == natural_minor).
+        dorian:           [ [ 0, 0 ], [ 2, 1 ], [ 3, 2 ], [ 5, 3 ], [ 7, 4 ], [ 9, 5 ], [ 10, 6 ] ],
+        phrygian:         [ [ 0, 0 ], [ 1, 1 ], [ 3, 2 ], [ 5, 3 ], [ 7, 4 ], [ 8, 5 ], [ 10, 6 ] ],
+        lydian:           [ [ 0, 0 ], [ 2, 1 ], [ 4, 2 ], [ 6, 3 ], [ 7, 4 ], [ 9, 5 ], [ 11, 6 ] ],
+        mixolydian:       [ [ 0, 0 ], [ 2, 1 ], [ 4, 2 ], [ 5, 3 ], [ 7, 4 ], [ 9, 5 ], [ 10, 6 ] ],
+        locrian:          [ [ 0, 0 ], [ 1, 1 ], [ 3, 2 ], [ 5, 3 ], [ 6, 4 ], [ 8, 5 ], [ 10, 6 ] ]
+      }.freeze
+
+      # The minor-family patterns; all share the same relative major.
+      MINOR_PATTERNS = %i[natural_minor harmonic_minor melodic_minor].freeze
+
+      # Degree of the parent major scale each mode starts on (dorian is
+      # built on the 2nd degree, and so on).
+      MODE_PARENT_DEGREES = {
+        dorian:     2,
+        phrygian:   3,
+        lydian:     4,
+        mixolydian: 5,
+        locrian:    7
+      }.freeze
+
+      # A triad built on a scale degree, with its display forms.
+      DiatonicChord = Struct.new(:degree,
+                                 :root,
+                                 :quality,
+                                 keyword_init: true) do
+        # The chord symbol, e.g. "Dm"
+        def symbol
+          ChordVocabulary.symbol(root_name: root, quality: quality)
+        end
+
+        # URL slug matching Chord#slug in the chord library.
+        def slug
+          ChordVocabulary.slug(symbol)
+        end
+
+        # Whether the chord library has this root - the app only generates
+        # chords for NoteName::CANONICAL_ROOTS, so degrees spelled with
+        # double accidentals or E#/B#-style names (F# major's E#dim) have
+        # no library page to link to.
+        def in_library?
+          NoteName::CANONICAL_ROOTS.include?(root.to_s)
+        end
+
+        # Key-agnostic arabic form, e.g. "2m"
+        def nashville
+          NashvilleNumber.format(degree: degree, quality: quality)
+        end
+
+        # Key-agnostic roman form, e.g. "ii"
+        def roman
+          NashvilleNumber.roman(degree: degree, quality: quality)
+        end
+      end
+
+      # The tonic NoteName and the pattern key it was built with
+      attr_reader :root, :pattern_name
+
+      # Whether a pattern by this name exists, for validating user input
+      def self.pattern?(name)
+        PATTERNS.key?(name.to_s.to_sym)
+      end
+
+      # Parses the root and validates the pattern name up front, so an
+      # unknown scale raises here rather than on first use.
+      def initialize(root, pattern_name = :major)
+        @root = NoteName.parse(root)
+        @pattern_name = pattern_name.to_sym
+        PATTERNS.fetch(@pattern_name) do
+          raise ArgumentError, "unknown scale #{pattern_name.inspect}"
+        end
+      end
+
+      # The [semitones, letter steps] pairs for this scale
+      def pattern
+        PATTERNS.fetch(pattern_name)
+      end
+
+      # URL segment for the pattern, e.g. :major_blues => 'major-blues'
+      def slug
+        pattern_name.to_s.tr("_", "-")
+      end
+
+      # Semitones above the root, one per degree
+      def intervals
+        pattern.map(&:first)
+      end
+
+      # Number of degrees - 7 for the diatonic patterns, fewer otherwise
+      def size
+        pattern.size
+      end
+
+      # Spelled notes, one per degree.
+      def note_names
+        pattern.map { |semitones, steps| root.at_degree(semitones, steps) }
+      end
+
+      # Sounding pitch classes, 0-11, ignoring spelling
+      def pitch_classes
+        intervals.map do |i|
+          (root.pitch_class + i) % Interval::SEMITONES_PER_OCTAVE
+        end
+      end
+
+      # Whether a note belongs to the scale, compared by sound so
+      # enharmonics match (Gb counts in a scale spelling F#).
+      def include?(note)
+        pitch_classes.include?(NoteName.parse(note).pitch_class)
+      end
+
+      # 1-based scale degree => NoteName ("what's the 5th of D major?").
+      def degree(number)
+        note_names.fetch(number - 1) do
+          message =
+            "degree #{number} out of range for " \
+            "#{pattern_name} (1..#{size})"
+
+          raise ArgumentError, message
+        end
+      end
+
+      # Net accidentals across the spelled scale; negative leans flat.
+      # (Not a key signature: A harmonic minor scores +1 for its G#, and
+      # pentatonic/blues scales have no key signature at all - Key#signature
+      # is the key-signature reading of this number.)
+      def net_accidentals
+        note_names.sum(&:accidental_offset)
+      end
+      alias signature net_accidentals
+
+      # :flats or :sharps - the spelling that matches this scale, for
+      # naming pitches the scale itself doesn't spell (display padding,
+      # fretboard labels).
+      def preferred_accidentals
+        net_accidentals.negative? ? :flats : :sharps
+      end
+
+      # True only for the major pattern itself, not its modes.
+      def major?
+        pattern_name == :major
+      end
+
+      # True for the minor-family patterns (natural, harmonic, melodic).
+      def minor?
+        MINOR_PATTERNS.include?(pattern_name)
+      end
+
+      # True for the named modes of the major scale (excluding major itself
+      # and natural minor, which the app treats as keys in their own right).
+      # Named to avoid colliding with Key#mode, which means major/minor
+      # tonality, not a church mode.
+      def church_mode?
+        MODE_PARENT_DEGREES.key?(pattern_name)
+      end
+      alias mode? church_mode?
+
+      # True when the scale supports stacked-third diatonic triads (any
+      # seven-note pattern; pentatonic and blues scales don't).
+      def diatonic_chords?
+        size == 7
+      end
+
+      # The natural minor sharing this major's notes - built on the 6th
+      # degree, so the spelling is inherited from the scale itself:
+      #   Scale.new('C').relative_minor  # => A natural minor
+      #   Scale.new('Gb').relative_minor # => Eb natural minor
+      def relative_minor
+        unless major?
+          raise ArgumentError, "#{pattern_name} has no relative minor"
+        end
+
+        self.class.new(degree(6), :natural_minor)
+      end
+
+      # All three minor forms on the relative tonic (natural, harmonic,
+      # melodic) - the inverse of #relative_major.
+      def relative_minors
+        tonic = relative_minor.root
+        MINOR_PATTERNS.map { |pattern| self.class.new(tonic, pattern) }
+      end
+
+      # The major key sharing this minor's tonality - a minor third above
+      # the root, correctly spelled:
+      #   Scale.new('A', :natural_minor).relative_major   # => C major
+      #   Scale.new('Eb', :harmonic_minor).relative_major # => Gb major
+      def relative_major
+        unless minor?
+          raise ArgumentError, "#{pattern_name} has no relative major"
+        end
+
+        self.class.new(root.at_degree(Interval::MINOR_THIRD, 2), :major)
+      end
+
+      # The major scale a mode is drawn from, correctly spelled:
+      #   Scale.new('C', :dorian).parent_major   # => Bb major
+      #   Scale.new('F#', :lydian).parent_major  # => C# major
+      def parent_major
+        degree = MODE_PARENT_DEGREES.fetch(pattern_name) do
+          raise ArgumentError,
+                "#{pattern_name} is not a mode of the major scale"
+        end
+
+        # The mode root sits `semitones`/`steps` above its parent tonic, so
+        # the tonic is the complementary degree *up* from the root.
+        semitones, steps = PATTERNS.fetch(:major)[degree - 1]
+
+        semitone_offset =
+          (Interval::SEMITONES_PER_OCTAVE - semitones) %
+          Interval::SEMITONES_PER_OCTAVE
+
+        step_offset =
+          (NoteName::LETTERS_PER_OCTAVE - steps) %
+          NoteName::LETTERS_PER_OCTAVE
+
+        tonic = root.at_degree(semitone_offset, step_offset)
+
+        self.class.new(tonic, :major)
+      end
+
+      # The named modes built on this major scale's degrees, in degree
+      # order (dorian on the 2nd, and so on) - the inverse of
+      # #parent_major:
+      #   Scale.new('C').modes.map(&:to_s)
+      #   # => ['D dorian', 'E phrygian', 'F lydian', 'G mixolydian',
+      #   #     'B locrian']
+      def modes
+        unless major?
+          raise ArgumentError, "modes are derived from a major scale"
+        end
+
+        MODE_PARENT_DEGREES.map do |pattern, degree_number|
+          self.class.new(degree(degree_number), pattern)
+        end
+      end
+
+      # The triad on each degree, built by stacking alternate scale notes
+      # (1-3-5 within the scale). Works for any seven-note pattern, so
+      # modes and the altered minors get correct qualities (harmonic minor
+      # yields a major V and an augmented III):
+      #   Scale.new('C').diatonic_chords.map(&:symbol)
+      #   # => ['C', 'Dm', 'Em', 'F', 'G', 'Am', 'Bdim']
+      def diatonic_chords
+        unless diatonic_chords?
+          raise ArgumentError,
+                "no diatonic chords for #{pattern_name} " \
+                "(needs a seven-note scale)"
+        end
+
+        names = note_names
+
+        (1..size).map do |degree|
+          chord_root = names[degree - 1]
+          third = names[(degree + 1) % size]
+          fifth = names[(degree + 3) % size]
+
+          third_interval =
+            (third.pitch_class - chord_root.pitch_class) %
+            Interval::SEMITONES_PER_OCTAVE
+
+          fifth_interval =
+            (fifth.pitch_class - chord_root.pitch_class) %
+            Interval::SEMITONES_PER_OCTAVE
+
+          intervals = [
+            0,
+            third_interval,
+            fifth_interval
+          ]
+
+          quality = ChordVocabulary::QUALITIES.key(intervals)
+          unless quality
+            raise ArgumentError,
+                  "no triad quality for intervals #{intervals.inspect} on " \
+                  "degree #{degree} of #{self}"
+          end
+
+          DiatonicChord.new(degree: degree, root: chord_root, quality: quality)
+        end
+      end
+
+      # Diatonic triad quality for a 1-based degree, derived from the
+      # stacked-third triads (any seven-note pattern).
+      def diatonic_quality(number)
+        diatonic_chords.fetch(number - 1) do
+          raise ArgumentError,
+                "degree #{number} out of range for #{pattern_name} (1..#{size})"
+        end.quality
+      end
+
+      # Pitches for rendering on a keyboard: the scale laid out
+      # ascending from the root, spanning `octaves` octaves plus the top
+      # root. Written octaves follow the letter (a Cb is written in the
+      # octave above the B it sounds as).
+      def pitched_notes(start_octave: 4, octaves: 1)
+        root_midi = Pitch.new(root, start_octave).midi
+        names = note_names
+
+        pitches = octaves.times.flat_map do |octave|
+          pattern.each_with_index.map do |(semitones, _), index|
+            Pitch.sounding(names[index],
+                           root_midi + (octave * Interval::OCTAVE) + semitones)
+          end
+        end
+
+        pitches << Pitch.sounding(root,
+                                  root_midi + (octaves * Interval::OCTAVE))
+      end
+
+      # Display name, e.g. "A natural minor"
+      def to_s
+        "#{root} #{pattern_name.to_s.tr('_', ' ')}"
+      end
+    end
+  end
+end