head_music 17.2.0 → 17.4.0

data/lib/head_music/rudiment/key.rb

@@ -2,37 +2,22 @@
 module HeadMusic::Rudiment; end
 
 # Represents a musical key (major or minor)
-class HeadMusic::Rudiment::Key < HeadMusic::Rudiment::DiatonicContext
-  include HeadMusic::Named
-
+class HeadMusic::Rudiment::Key < HeadMusic::Rudiment::QualifiedDiatonicContext
   QUALITIES = %i[major minor].freeze
 
-  attr_reader :quality
-
-  def self.get(identifier)
-    return identifier if identifier.is_a?(HeadMusic::Rudiment::Key)
-
-    @keys ||= {}
-    tonic_spelling, quality_name = parse_identifier(identifier)
-    hash_key = HeadMusic::Utilities::HashKey.for(identifier)
-    @keys[hash_key] ||= new(tonic_spelling, quality_name)
+  def self.default_qualifier
+    :major
   end
 
-  def self.parse_identifier(identifier)
-    tonic_spelling, quality_name = identifier.to_s.strip.split(/\s+/)
-    quality_name ||= "major"
-    [tonic_spelling, quality_name]
+  def self.valid_qualifiers
+    QUALITIES
   end
 
-  def initialize(tonic_spelling, quality = :major)
-    super(tonic_spelling)
-    @quality = quality.to_s.downcase.to_sym
-    raise ArgumentError, "Quality must be :major or :minor" unless QUALITIES.include?(@quality)
+  def self.invalid_qualifier_message
+    "Quality must be :major or :minor"
   end
 
-  def scale_type
-    @scale_type ||= HeadMusic::Rudiment::ScaleType.get(quality)
-  end
+  alias_method :quality, :qualifier
 
   def major?
     quality == :major
@@ -61,17 +46,4 @@ class HeadMusic::Rudiment::Key < HeadMusic::Rudiment::DiatonicContext
       self.class.get("#{tonic_spelling} major")
     end
   end
-
-  def name
-    "#{tonic_spelling} #{quality}"
-  end
-
-  def to_s
-    name
-  end
-
-  def ==(other)
-    other = self.class.get(other)
-    tonic_spelling == other.tonic_spelling && quality == other.quality
-  end
 end

data/lib/head_music/rudiment/key_signature/enharmonic_equivalence.rb

@@ -1,26 +1,32 @@
 # Key signatures are enharmonic when they represent the same set of altered pitch classes but with different spellings.
-class HeadMusic::Rudiment::KeySignature::EnharmonicEquivalence
-  attr_reader :key_signature
-
-  def self.get(key_signature)
-    key_signature = HeadMusic::Rudiment::KeySignature.get(key_signature)
-    @enharmonic_equivalences ||= {}
-    @enharmonic_equivalences[key_signature.to_s] ||= new(key_signature)
+class HeadMusic::Rudiment::KeySignature::EnharmonicEquivalence < HeadMusic::Rudiment::EnharmonicEquivalence
+  def self.subject_class
+    HeadMusic::Rudiment::KeySignature
   end
 
-  def initialize(key_signature)
-    @key_signature = HeadMusic::Rudiment::KeySignature.get(key_signature)
-  end
+  alias_method :key_signature, :subject
 
   def enharmonic_equivalent?(other)
     other = HeadMusic::Rudiment::KeySignature.get(other)
 
-    key_signature.pitch_classes.map(&:to_i).sort == other.pitch_classes.map(&:to_i).sort &&
-      key_signature.alterations.map(&:to_s).sort != other.alterations.map(&:to_s).sort
+    same_pitch_classes?(other) && different_spelling?(other)
   end
 
-  alias_method :enharmonic?, :enharmonic_equivalent?
-  alias_method :equivalent?, :enharmonic_equivalent?
+  private
 
-  private_class_method :new
+  def same_pitch_classes?(other)
+    sorted_pitch_class_numbers(key_signature) == sorted_pitch_class_numbers(other)
+  end
+
+  def different_spelling?(other)
+    sorted_alteration_names(key_signature) != sorted_alteration_names(other)
+  end
+
+  def sorted_pitch_class_numbers(key_signature)
+    key_signature.pitch_classes.map(&:to_i).sort
+  end
+
+  def sorted_alteration_names(key_signature)
+    key_signature.alterations.map(&:to_s).sort
+  end
 end

data/lib/head_music/rudiment/key_signature.rb

@@ -51,27 +51,19 @@ class HeadMusic::Rudiment::KeySignature < HeadMusic::Rudiment::Base
   end
 
   def sharps
-    spellings.select(&:sharp?).sort_by do |spelling|
-      ORDERED_LETTER_NAMES_OF_SHARPS.index(spelling.letter_name.to_s)
-    end
+    altered_spellings(:sharp?, ORDERED_LETTER_NAMES_OF_SHARPS)
   end
 
   def double_sharps
-    spellings.select(&:double_sharp?).sort_by do |spelling|
-      ORDERED_LETTER_NAMES_OF_SHARPS.index(spelling.letter_name.to_s)
-    end
+    altered_spellings(:double_sharp?, ORDERED_LETTER_NAMES_OF_SHARPS)
   end
 
   def flats
-    spellings.select(&:flat?).sort_by do |spelling|
-      ORDERED_LETTER_NAMES_OF_FLATS.index(spelling.letter_name.to_s)
-    end
+    altered_spellings(:flat?, ORDERED_LETTER_NAMES_OF_FLATS)
   end
 
   def double_flats
-    spellings.select(&:double_flat?).sort_by do |spelling|
-      ORDERED_LETTER_NAMES_OF_FLATS.index(spelling.letter_name.to_s)
-    end
+    altered_spellings(:double_flat?, ORDERED_LETTER_NAMES_OF_FLATS)
   end
 
   def num_sharps
@@ -102,13 +94,10 @@ class HeadMusic::Rudiment::KeySignature < HeadMusic::Rudiment::Base
   end
 
   def to_s
-    if sharps.any?
-      (sharps.length == 1) ? "1 sharp" : "#{sharps.length} sharps"
-    elsif flats.any?
-      (flats.length == 1) ? "1 flat" : "#{flats.length} flats"
-    else
-      "no sharps or flats"
-    end
+    return pluralize(sharps.length, "sharp") if sharps.any?
+    return pluralize(flats.length, "flat") if flats.any?
+
+    "no sharps or flats"
   end
 
   def enharmonic_equivalent?(other)
@@ -117,6 +106,16 @@ class HeadMusic::Rudiment::KeySignature < HeadMusic::Rudiment::Base
 
   private
 
+  def altered_spellings(predicate, letter_name_order)
+    spellings.select(&predicate).sort_by do |spelling|
+      letter_name_order.index(spelling.letter_name.to_s)
+    end
+  end
+
+  def pluralize(count, noun)
+    (count == 1) ? "1 #{noun}" : "#{count} #{noun}s"
+  end
+
   def enharmonic_equivalence
     @enharmonic_equivalence ||= HeadMusic::Rudiment::KeySignature::EnharmonicEquivalence.get(self)
   end

data/lib/head_music/rudiment/meter.rb

@@ -88,17 +88,26 @@ class HeadMusic::Rudiment::Meter < HeadMusic::Rudiment::Base
   end
 
   def beat_value
-    @beat_value ||=
-      if compound?
-        HeadMusic::Rudiment::RhythmicValue.new(HeadMusic::Rudiment::RhythmicUnit.for_denominator_value(bottom_number / 2), dots: 1)
-      else
-        HeadMusic::Rudiment::RhythmicValue.new(count_unit)
-      end
+    @beat_value ||= compound? ? dotted_denominator_value(bottom_number / 2) : count_unit_value
   end
 
   # for consistency with conversational usage
   alias_method :beat_unit, :beat_value
 
+  # The span of one default beam group for this meter, as a RhythmicValue.
+  # This is a distinct concern from #beat_value: it is the boundary unit used
+  # to decide where beams break.
+  def beam_group_unit
+    @beam_group_unit ||=
+      if compound?
+        beat_value
+      elsif bottom_number >= 8
+        whole_bar_beam_group_unit
+      else
+        count_unit_value
+      end
+  end
+
   def to_s
     [top_number, bottom_number].join("/")
   end
@@ -119,6 +128,30 @@ class HeadMusic::Rudiment::Meter < HeadMusic::Rudiment::Base
 
   private
 
+  # For simple meters with an eighth-or-shorter denominator (e.g. 2/8, 3/8),
+  # the whole bar is a single beam group. A triple grouping (3/8) is a dotted
+  # value of the half-denominator unit; a duple grouping (2/8) spans the bar.
+  # Asymmetric meters (5/8, 7/16, ...) are out of scope: their bar has no
+  # single power-of-two unit, so the group unit falls back to the count unit
+  # (each count its own group) rather than raising on a nil unit.
+  def whole_bar_beam_group_unit
+    return dotted_denominator_value(bottom_number / 2) if (top_number % 3).zero?
+
+    unit = HeadMusic::Rudiment::RhythmicUnit.for_denominator_value(bottom_number / top_number)
+    HeadMusic::Rudiment::RhythmicValue.new(unit || count_unit)
+  end
+
+  def count_unit_value
+    HeadMusic::Rudiment::RhythmicValue.new(count_unit)
+  end
+
+  # A dotted value of the rhythmic unit for the given denominator (e.g. the
+  # dotted-quarter beat of a 6/8 meter for denominator 4).
+  def dotted_denominator_value(denominator)
+    unit = HeadMusic::Rudiment::RhythmicUnit.for_denominator_value(denominator)
+    HeadMusic::Rudiment::RhythmicValue.new(unit, dots: 1)
+  end
+
   def downbeat?(count, tick = 0)
     beat?(tick) && count == 1
   end

data/lib/head_music/rudiment/mode.rb

@@ -2,59 +2,38 @@
 module HeadMusic::Rudiment; end
 
 # Represents a musical mode (church modes)
-class HeadMusic::Rudiment::Mode < HeadMusic::Rudiment::DiatonicContext
-  include HeadMusic::Named
-
+class HeadMusic::Rudiment::Mode < HeadMusic::Rudiment::QualifiedDiatonicContext
   MODES = %i[ionian dorian phrygian lydian mixolydian aeolian locrian].freeze
 
-  attr_reader :mode_name
-
-  def self.get(identifier)
-    return identifier if identifier.is_a?(HeadMusic::Rudiment::Mode)
-
-    @modes ||= {}
-    tonic_spelling, mode_name = parse_identifier(identifier)
-    hash_key = HeadMusic::Utilities::HashKey.for(identifier)
-    @modes[hash_key] ||= new(tonic_spelling, mode_name)
+  def self.default_qualifier
+    :ionian
   end
 
-  def self.parse_identifier(identifier)
-    identifier = identifier.to_s.strip
-    parts = identifier.split(/\s+/)
-    tonic_spelling = parts[0]
-    mode_name = parts[1] || "ionian"
-    [tonic_spelling, mode_name]
+  def self.valid_qualifiers
+    MODES
   end
 
-  def initialize(tonic_spelling, mode_name = :ionian)
-    super(tonic_spelling)
-    @mode_name = mode_name.to_s.downcase.to_sym
-    raise ArgumentError, "Mode must be one of: #{MODES.join(", ")}" unless MODES.include?(@mode_name)
+  def self.invalid_qualifier_message
+    "Mode must be one of: #{MODES.join(", ")}"
   end
 
-  def scale_type
-    @scale_type ||= HeadMusic::Rudiment::ScaleType.get(mode_name)
-  end
+  alias_method :mode_name, :qualifier
 
-  def relative_major
-    case mode_name
-    when :ionian
-      return HeadMusic::Rudiment::Key.get("#{tonic_spelling} major")
-    when :dorian
-      relative_pitch = tonic_pitch + -2
-    when :phrygian
-      relative_pitch = tonic_pitch + -4
-    when :lydian
-      relative_pitch = tonic_pitch + -5
-    when :mixolydian
-      relative_pitch = tonic_pitch + -7
-    when :aeolian
-      relative_pitch = tonic_pitch + -9
-    when :locrian
-      relative_pitch = tonic_pitch + -11
-    end
+  # Semitones from a mode's tonic down to its relative major tonic.
+  # Ionian is omitted because its own tonic spelling is the relative major.
+  RELATIVE_MAJOR_SEMITONES_BELOW_TONIC = {
+    dorian: -2, phrygian: -4, lydian: -5,
+    mixolydian: -7, aeolian: -9, locrian: -11
+  }.freeze
 
-    HeadMusic::Rudiment::Key.get("#{relative_pitch.spelling} major")
+  # The major or minor quality of each mode's parallel key.
+  PARALLEL_QUALITIES = {
+    ionian: :major, dorian: :minor, phrygian: :minor, lydian: :major,
+    mixolydian: :major, aeolian: :minor, locrian: :minor
+  }.freeze
+
+  def relative_major
+    HeadMusic::Rudiment::Key.get("#{relative_major_tonic_spelling} major")
   end
 
   def relative
@@ -62,31 +41,20 @@ class HeadMusic::Rudiment::Mode < HeadMusic::Rudiment::DiatonicContext
   end
 
   def parallel
-    # Return the parallel major or minor key
-    case mode_name
-    when :ionian
-      HeadMusic::Rudiment::Key.get("#{tonic_spelling} major")
-    when :aeolian
-      HeadMusic::Rudiment::Key.get("#{tonic_spelling} minor")
-    when :dorian, :phrygian
-      HeadMusic::Rudiment::Key.get("#{tonic_spelling} minor")
-    when :lydian, :mixolydian
-      HeadMusic::Rudiment::Key.get("#{tonic_spelling} major")
-    when :locrian
-      HeadMusic::Rudiment::Key.get("#{tonic_spelling} minor")
-    end
-  end
+    quality = PARALLEL_QUALITIES[mode_name]
+    return unless quality
 
-  def name
-    "#{tonic_spelling} #{mode_name}"
+    HeadMusic::Rudiment::Key.get("#{tonic_spelling} #{quality}")
   end
 
-  def to_s
-    name
-  end
+  private
+
+  def relative_major_tonic_spelling
+    return tonic_spelling if mode_name == :ionian
 
-  def ==(other)
-    other = self.class.get(other)
-    tonic_spelling == other.tonic_spelling && mode_name == other.mode_name
+    offset = RELATIVE_MAJOR_SEMITONES_BELOW_TONIC[mode_name]
+    relative_pitch = tonic_pitch + offset if offset
+    # An unrecognized mode leaves relative_pitch nil, raising NoMethodError (preserved behavior).
+    relative_pitch.spelling
   end
 end

data/lib/head_music/rudiment/note.rb

@@ -22,30 +22,27 @@ class HeadMusic::Rudiment::Note < HeadMusic::Rudiment::RhythmicElement
 
   def self.get(pitch, rhythmic_value = nil)
     return pitch if pitch.is_a?(HeadMusic::Rudiment::Note)
+    return get_from_string(pitch) if rhythmic_value.nil? && pitch.is_a?(String)
 
-    if rhythmic_value.nil? && pitch.is_a?(String)
-      # Try to parse as "pitch rhythmic_value" format (e.g., "F#4 dotted-quarter")
-      match = pitch.match(MATCHER)
-      if match
-        pitch_str = match[1] # The full pitch part
-        rhythmic_value_str = match[5] # The rhythmic value part
-
-        pitch_obj = HeadMusic::Rudiment::Pitch.get(pitch_str)
-        rhythmic_value_obj = HeadMusic::Rudiment::RhythmicValue.get(rhythmic_value_str)
+    pitch = HeadMusic::Rudiment::Pitch.get(pitch)
+    rhythmic_value = HeadMusic::Rudiment::RhythmicValue.get(rhythmic_value || :quarter)
+    fetch_or_create(pitch, rhythmic_value)
+  end
 
-        return fetch_or_create(pitch_obj, rhythmic_value_obj) if pitch_obj && rhythmic_value_obj
-      end
+  # Parse a lone string as "pitch rhythmic_value" (e.g., "F#4 dotted-quarter"),
+  # falling back to just a pitch with a default quarter note.
+  def self.get_from_string(string)
+    match = string.match(MATCHER)
+    if match
+      pitch_obj = HeadMusic::Rudiment::Pitch.get(match[1])
+      rhythmic_value_obj = HeadMusic::Rudiment::RhythmicValue.get(match[5])
+      return fetch_or_create(pitch_obj, rhythmic_value_obj) if pitch_obj && rhythmic_value_obj
+    end
 
-      # If parsing fails, treat it as just a pitch with default quarter note
-      pitch_obj = HeadMusic::Rudiment::Pitch.get(pitch)
-      return fetch_or_create(pitch_obj, HeadMusic::Rudiment::RhythmicValue.get(:quarter)) if pitch_obj
+    pitch_obj = HeadMusic::Rudiment::Pitch.get(string)
+    return fetch_or_create(pitch_obj, HeadMusic::Rudiment::RhythmicValue.get(:quarter)) if pitch_obj
 
-      nil
-    else
-      pitch = HeadMusic::Rudiment::Pitch.get(pitch)
-      rhythmic_value = HeadMusic::Rudiment::RhythmicValue.get(rhythmic_value || :quarter)
-      fetch_or_create(pitch, rhythmic_value)
-    end
+    nil
   end
 
   def self.fetch_or_create(pitch, rhythmic_value)
@@ -108,5 +105,5 @@ class HeadMusic::Rudiment::Note < HeadMusic::Rudiment::RhythmicElement
     true
   end
 
-  private_class_method :fetch_or_create
+  private_class_method :fetch_or_create, :get_from_string
 end

data/lib/head_music/rudiment/pitch/enharmonic_equivalence.rb

@@ -1,26 +1,15 @@
 # An enharmonic equivalent pitch is the same frequency spelled differently, such as D# and Eb.
-class HeadMusic::Rudiment::Pitch::EnharmonicEquivalence
-  def self.get(pitch)
-    pitch = HeadMusic::Rudiment::Pitch.get(pitch)
-    @enharmonic_equivalences ||= {}
-    @enharmonic_equivalences[pitch.to_s] ||= new(pitch)
+class HeadMusic::Rudiment::Pitch::EnharmonicEquivalence < HeadMusic::Rudiment::EnharmonicEquivalence
+  def self.subject_class
+    HeadMusic::Rudiment::Pitch
   end
 
-  attr_reader :pitch
+  alias_method :pitch, :subject
 
   delegate :pitch_class, to: :pitch
 
-  def initialize(pitch)
-    @pitch = HeadMusic::Rudiment::Pitch.get(pitch)
-  end
-
   def enharmonic_equivalent?(other)
     other = HeadMusic::Rudiment::Pitch.get(other)
     pitch.midi_note_number == other.midi_note_number && pitch.spelling != other.spelling
   end
-
-  alias_method :enharmonic?, :enharmonic_equivalent?
-  alias_method :equivalent?, :enharmonic_equivalent?
-
-  private_class_method :new
 end

data/lib/head_music/rudiment/pitch/natural_step.rb

@@ -0,0 +1,36 @@
+class HeadMusic::Rudiment::Pitch
+  # Computes where a signed number of diatonic (letter-name) steps lands
+  # relative to a starting letter name: the destination letter and how many
+  # octaves the move crosses. Register-agnostic — it works purely from the
+  # letter name's position in the scale, so the Pitch supplies the register.
+  class NaturalStep
+    attr_reader :letter_name, :num_steps
+
+    def initialize(letter_name, num_steps)
+      @letter_name = letter_name
+      @num_steps = num_steps
+    end
+
+    def target_letter_name
+      @target_letter_name ||= letter_name.steps_up(num_steps)
+    end
+
+    def octaves_delta
+      whole_octaves = (num_steps.abs / 7) * (num_steps.negative? ? -1 : 1)
+      return whole_octaves - 1 if wrapped_down?
+      return whole_octaves + 1 if wrapped_up?
+
+      whole_octaves
+    end
+
+    private
+
+    def wrapped_down?
+      num_steps.negative? && target_letter_name.position > letter_name.position
+    end
+
+    def wrapped_up?
+      num_steps.positive? && target_letter_name.position < letter_name.position
+    end
+  end
+end

data/lib/head_music/rudiment/pitch/parser.rb

@@ -42,11 +42,22 @@ class HeadMusic::Rudiment::Pitch::Parser
 
   def parse_components
     match = identifier.match(PATTERN)
+    return unless match
 
-    if match
-      @letter_name = LetterName.get(match[1].upcase) unless match[1].to_s.empty?
-      @alteration = Alteration.get(match[2] || "") unless match[2].to_s.empty?
-      @register = Register.get(match[3]&.to_i) unless match[3].to_s.empty?
-    end
+    @letter_name = parse_letter_name(match[1])
+    @alteration = parse_alteration(match[2])
+    @register = parse_register(match[3])
+  end
+
+  def parse_letter_name(token)
+    LetterName.get(token.upcase) unless token.to_s.empty?
+  end
+
+  def parse_alteration(token)
+    Alteration.get(token || "") unless token.to_s.empty?
+  end
+
+  def parse_register(token)
+    Register.get(token.to_i) unless token.to_s.empty?
   end
 end

data/lib/head_music/rudiment/pitch.rb

@@ -137,16 +137,16 @@ class HeadMusic::Rudiment::Pitch < HeadMusic::Rudiment::Base
   end
 
   def -(other)
-    case other
-    when HeadMusic::Analysis::DiatonicInterval
-      # return a pitch
-      other.below(self)
-    when HeadMusic::Rudiment::Pitch
-      # return an interval
-      HeadMusic::Rudiment::ChromaticInterval.get(to_i - other.to_i)
+    # a diatonic interval below this pitch resolves to another pitch
+    return other.below(self) if other.is_a?(HeadMusic::Analysis::DiatonicInterval)
+
+    difference = to_i - other.to_i
+    if other.is_a?(HeadMusic::Rudiment::Pitch)
+      # the distance between two pitches is an interval
+      HeadMusic::Rudiment::ChromaticInterval.get(difference)
     else
-      # assume value represents an interval in semitones and return another pitch
-      HeadMusic::Rudiment::Pitch.get(to_i - other.to_i)
+      # otherwise treat the value as a number of semitones and return another pitch
+      HeadMusic::Rudiment::Pitch.get(difference)
     end
   end
 
@@ -164,7 +164,8 @@ class HeadMusic::Rudiment::Pitch < HeadMusic::Rudiment::Base
   end
 
   def natural_steps(num_steps)
-    HeadMusic::Rudiment::Pitch.get([target_letter_name(num_steps), register + octaves_delta(num_steps)].join)
+    step = NaturalStep.new(letter_name, num_steps)
+    HeadMusic::Rudiment::Pitch.get([step.target_letter_name, register + step.octaves_delta].join)
   end
 
   def frequency
@@ -202,29 +203,6 @@ class HeadMusic::Rudiment::Pitch < HeadMusic::Rudiment::Base
     @tuning ||= HeadMusic::Rudiment::Tuning.new
   end
 
-  def octaves_delta(num_steps)
-    octaves_delta = (num_steps.abs / 7) * ((num_steps >= 0) ? 1 : -1)
-    if wrapped_down?(num_steps)
-      octaves_delta -= 1
-    elsif wrapped_up?(num_steps)
-      octaves_delta += 1
-    end
-    octaves_delta
-  end
-
-  def wrapped_down?(num_steps)
-    num_steps.negative? && target_letter_name(num_steps).position > letter_name.position
-  end
-
-  def wrapped_up?(num_steps)
-    num_steps.positive? && target_letter_name(num_steps).position < letter_name.position
-  end
-
-  def target_letter_name(num_steps)
-    @target_letter_name ||= {}
-    @target_letter_name[num_steps] ||= letter_name.steps_up(num_steps)
-  end
-
   def helmholtz_letter_name
     spelling_str = spelling.to_s
     return spelling_str.downcase if HeadMusic::Rudiment::Register.get(register).helmholtz_case == :lower

data/lib/head_music/rudiment/qualified_diatonic_context.rb

@@ -0,0 +1,61 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
+# Shared behavior for diatonic contexts identified by a tonic spelling and a
+# named qualifier -- a key's quality (major/minor) or a mode's name.
+# Subclasses declare their valid qualifiers, default qualifier, and the
+# message raised for an invalid qualifier, and implement #relative and #parallel.
+class HeadMusic::Rudiment::QualifiedDiatonicContext < HeadMusic::Rudiment::DiatonicContext
+  include HeadMusic::Named
+
+  def self.get(identifier)
+    return identifier if identifier.is_a?(self)
+
+    @cache ||= {}
+    tonic_spelling, qualifier = parse_identifier(identifier)
+    hash_key = HeadMusic::Utilities::HashKey.for(identifier)
+    @cache[hash_key] ||= new(tonic_spelling, qualifier)
+  end
+
+  def self.parse_identifier(identifier)
+    tonic_spelling, qualifier = identifier.to_s.strip.split(/\s+/)
+    [tonic_spelling, qualifier || default_qualifier.to_s]
+  end
+
+  def self.default_qualifier
+    raise NotImplementedError, "Subclasses must implement .default_qualifier"
+  end
+
+  def self.valid_qualifiers
+    raise NotImplementedError, "Subclasses must implement .valid_qualifiers"
+  end
+
+  def self.invalid_qualifier_message
+    raise NotImplementedError, "Subclasses must implement .invalid_qualifier_message"
+  end
+
+  attr_reader :qualifier
+
+  def initialize(tonic_spelling, qualifier = nil)
+    super(tonic_spelling)
+    @qualifier = (qualifier || self.class.default_qualifier).to_s.downcase.to_sym
+    raise ArgumentError, self.class.invalid_qualifier_message unless self.class.valid_qualifiers.include?(@qualifier)
+  end
+
+  def scale_type
+    @scale_type ||= HeadMusic::Rudiment::ScaleType.get(qualifier)
+  end
+
+  def name
+    "#{tonic_spelling} #{qualifier}"
+  end
+
+  def to_s
+    name
+  end
+
+  def ==(other)
+    other = self.class.get(other)
+    tonic_spelling == other.tonic_spelling && qualifier == other.qualifier
+  end
+end