head_music 8.2.1 → 9.0.1

data/lib/head_music/rudiment/rhythmic_element.rb

@@ -0,0 +1,53 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
+# Abstract base class for rhythmic elements that have a rhythmic value.
+# This includes notes (pitched), rests (silence), and unpitched notes (percussion).
+class HeadMusic::Rudiment::RhythmicElement < HeadMusic::Rudiment::Base
+  include Comparable
+
+  LetterName = HeadMusic::Rudiment::LetterName
+  Alteration = HeadMusic::Rudiment::Alteration
+  Register = HeadMusic::Rudiment::Register
+  RhythmicValue = HeadMusic::Rudiment::RhythmicValue
+
+  attr_reader :rhythmic_value
+
+  delegate :unit, :dots, :tied_value, :ticks, to: :rhythmic_value
+
+  # Make new private to prevent direct instantiation of abstract class
+  private_class_method :new
+
+  def initialize(rhythmic_value)
+    @rhythmic_value = rhythmic_value
+  end
+
+  # Create a new instance with a different rhythmic value
+  def with_rhythmic_value(new_rhythmic_value)
+    self.class.get(new_rhythmic_value)
+  end
+
+  def ==(other)
+    return false unless other.is_a?(self.class)
+    rhythmic_value == other.rhythmic_value
+  end
+
+  def <=>(other)
+    return nil unless other.is_a?(HeadMusic::Rudiment::RhythmicElement)
+    rhythmic_value <=> other.rhythmic_value
+  end
+
+  def to_s
+    name
+  end
+
+  # Abstract method - must be implemented by subclasses
+  def name
+    raise NotImplementedError, "Subclasses must implement the name method"
+  end
+
+  # Abstract method - must be implemented by subclasses
+  def sounded?
+    raise NotImplementedError, "Subclasses must implement the sounded? method"
+  end
+end

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

@@ -0,0 +1,86 @@
+class HeadMusic::Rudiment::RhythmicUnit::Parser
+  attr_reader :rhythmic_unit, :identifier
+
+  RHYTHMIC_UNITS_DATA = HeadMusic::Rudiment::RhythmicUnit::RHYTHMIC_UNITS_DATA
+
+  TEMPO_SHORTHAND_PATTERN = RHYTHMIC_UNITS_DATA.map { |unit| unit["tempo_shorthand"] }.compact.uniq.sort_by { |s| -s.length }.join("|")
+
+  def self.parse(identifier)
+    return nil if identifier.nil? || identifier.to_s.strip.empty?
+    new(identifier).parsed_name
+  end
+
+  def initialize(identifier)
+    @identifier = identifier.to_s.strip
+    parse
+  end
+
+  def parse
+    @unit_data = from_american_name || from_british_name || from_tempo_shorthand || from_duration
+    @rhythmic_unit = @unit_data ? HeadMusic::Rudiment::RhythmicUnit.get_by_name(@unit_data["american_name"]) : nil
+  end
+
+  def parsed_name
+    # Return the name format that was used in input
+    return nil unless @unit_data
+
+    # Check which type matched
+    if from_british_name == @unit_data && @unit_data["british_name"]
+      @unit_data["british_name"]
+    else
+      @unit_data["american_name"]
+    end
+  end
+
+  def american_name
+    # Always return the American name if a unit was found
+    @unit_data&.fetch("american_name", nil)
+  end
+
+  def normalized_identifier
+    @normalized_identifier ||= identifier.downcase.strip.gsub(/[^a-z0-9]/, "_").gsub(/_+/, "_").gsub(/^_|_$/, "")
+  end
+
+  def from_american_name
+    RHYTHMIC_UNITS_DATA.find do |unit|
+      normalize_name(unit["american_name"]) == normalized_identifier
+    end
+  end
+
+  def from_british_name
+    RHYTHMIC_UNITS_DATA.find do |unit|
+      normalize_name(unit["british_name"]) == normalized_identifier
+    end
+  end
+
+  def from_tempo_shorthand
+    # Handle shorthand with dots (e.g., "q." should match "q")
+    clean_identifier = identifier.downcase.strip.gsub(/\.*$/, "")
+    RHYTHMIC_UNITS_DATA.find do |unit|
+      unit["tempo_shorthand"] && unit["tempo_shorthand"].downcase == clean_identifier
+    end
+  end
+
+  def from_duration
+    RHYTHMIC_UNITS_DATA.find do |unit|
+      # Match decimal duration (e.g., "0.25")
+      return unit if unit["duration"].to_s == identifier.strip
+
+      # Match fraction notation (e.g., "1/4" = 0.25)
+      if identifier.match?(%r{^\d+/\d+$})
+        numerator, denominator = identifier.split("/").map(&:to_f)
+        calculated_duration = numerator / denominator
+        return unit if (calculated_duration - unit["duration"]).abs < 0.0001
+      end
+
+      false
+    end
+  end
+
+  private
+
+  def normalize_name(name)
+    return nil if name.nil?
+    name.to_s.downcase.strip.gsub(/[^a-z0-9]/, "_").gsub(/_+/, "_").gsub(/^_|_$/, "")
+  end
+end

data/lib/head_music/rudiment/rhythmic_unit.rb

@@ -2,32 +2,85 @@
 module HeadMusic::Rudiment; end
 
 # A rhythmic unit is a rudiment of duration consisting of doublings and divisions of a whole note.
-class HeadMusic::Rudiment::RhythmicUnit
+class HeadMusic::Rudiment::RhythmicUnit < HeadMusic::Rudiment::Base
   include HeadMusic::Named
+  include Comparable
 
-  MULTIPLES = ["whole", "double whole", "longa", "maxima"].freeze
-  FRACTIONS = [
+  RHYTHMIC_UNITS_DATA = YAML.load_file(File.expand_path("rhythmic_units.yml", __dir__)).freeze
+
+  AMERICAN_MULTIPLES_NAMES = [
+    "whole", "double whole", "longa", "maxima"
+  ].freeze
+
+  AMERICAN_DIVISIONS_NAMES = [
     "whole", "half", "quarter", "eighth", "sixteenth", "thirty-second",
     "sixty-fourth", "hundred twenty-eighth", "two hundred fifty-sixth"
   ].freeze
 
-  BRITISH_MULTIPLE_NAMES = %w[semibreve breve longa maxima].freeze
-  BRITISH_DIVISION_NAMES = %w[
+  AMERICAN_DURATIONS = (AMERICAN_MULTIPLES_NAMES + AMERICAN_DIVISIONS_NAMES).freeze
+
+  PATTERN = /#{Regexp.union(AMERICAN_DURATIONS)}/i
+
+  # British terminology for note values longer than a whole note
+  BRITISH_MULTIPLES_NAMES = %w[semibreve breve longa maxima].freeze
+
+  # British terminology for standard note divisions
+  BRITISH_DIVISIONS_NAMES = %w[
     semibreve minim crotchet quaver semiquaver demisemiquaver
     hemidemisemiquaver semihemidemisemiquaver demisemihemidemisemiquaver
   ].freeze
 
+  # Notehead symbols used for different note values
+  NOTEHEADS = {
+    maxima: 8.0,
+    longa: 4.0,
+    breve: 2.0,
+    open: [0.5, 1.0],
+    closed: :default
+  }.freeze
+
   def self.for_denominator_value(denominator)
-    get(FRACTIONS[Math.log2(denominator).to_i])
+    return nil unless denominator.is_a?(Numeric) && denominator > 0
+    return nil unless (denominator & (denominator - 1)) == 0  # Check if power of 2
+
+    index = Math.log2(denominator).to_i
+    return nil if index >= AMERICAN_DIVISIONS_NAMES.length
+
+    get(AMERICAN_DIVISIONS_NAMES[index])
   end
 
   attr_reader :numerator, :denominator
 
   def self.get(name)
-    get_by_name(name)
+    # Use the parser to handle tempo shorthand and other formats
+    parsed_name = HeadMusic::Rudiment::RhythmicUnit::Parser.parse(name)
+    return nil unless parsed_name
+
+    get_by_name(parsed_name)
+  end
+
+  def self.all
+    @all ||= (AMERICAN_MULTIPLES_NAMES.reverse + AMERICAN_DIVISIONS_NAMES).uniq.map { |name| get(name) }.compact
+  end
+
+  # Check if a name represents a valid rhythmic unit
+  def self.valid_name?(name)
+    normalized = normalize_name(name)
+    all_normalized_names.include?(normalized)
+  end
+
+  def self.all_normalized_names
+    @all_normalized_names ||= (
+      AMERICAN_MULTIPLES_NAMES.map { |n| normalize_name(n) } +
+      AMERICAN_DIVISIONS_NAMES.map { |n| normalize_name(n) } +
+      BRITISH_MULTIPLES_NAMES.map { |n| normalize_name(n) } +
+      BRITISH_DIVISIONS_NAMES.map { |n| normalize_name(n) }
+    ).uniq
   end
 
   def initialize(canonical_name)
+    raise ArgumentError, "Name cannot be nil or empty" if canonical_name.to_s.strip.empty?
+
     self.name = canonical_name
     @numerator = 2**numerator_exponent
     @denominator = 2**denominator_exponent
@@ -38,69 +91,91 @@ class HeadMusic::Rudiment::RhythmicUnit
   end
 
   def ticks
-    HeadMusic::Rudiment::Rhythm::PPQN * 4 * relative_value
+    (HeadMusic::Rudiment::Rhythm::PPQN * 4 * relative_value).to_i
   end
 
   def notehead
-    return :maxima if relative_value == 8
-    return :longa if relative_value == 4
-    return :breve if relative_value == 2
-    return :open if [0.5, 1].include? relative_value
+    value = relative_value
+    return :maxima if value == NOTEHEADS[:maxima]
+    return :longa if value == NOTEHEADS[:longa]
+    return :breve if value == NOTEHEADS[:breve]
+    return :open if NOTEHEADS[:open].include?(value)
 
     :closed
   end
 
   def flags
-    FRACTIONS.include?(name) ? [FRACTIONS.index(name) - 2, 0].max : 0
+    AMERICAN_DIVISIONS_NAMES.include?(name) ? [AMERICAN_DIVISIONS_NAMES.index(name) - 2, 0].max : 0
   end
 
   def stemmed?
     relative_value < 1
   end
 
+  # Returns true if this note value is commonly used in modern notation
+  def common?
+    AMERICAN_DIVISIONS_NAMES[0..6].include?(name) || BRITISH_DIVISIONS_NAMES[0..6].include?(name)
+  end
+
+  def <=>(other)
+    return nil unless other.is_a?(self.class)
+
+    relative_value <=> other.relative_value
+  end
+
   def british_name
-    if multiple?
-      BRITISH_MULTIPLE_NAMES[MULTIPLES.index(name)]
-    elsif fraction?
-      BRITISH_DIVISION_NAMES[FRACTIONS.index(name)]
-    elsif BRITISH_MULTIPLE_NAMES.include?(name) || BRITISH_DIVISION_NAMES.include?(name)
-      name
+    if has_american_multiple_name?
+      index = AMERICAN_MULTIPLES_NAMES.index(name)
+      return BRITISH_MULTIPLES_NAMES[index] unless index.nil?
+    elsif has_american_division_name?
+      index = AMERICAN_DIVISIONS_NAMES.index(name)
+      return BRITISH_DIVISIONS_NAMES[index] unless index.nil?
+    elsif BRITISH_MULTIPLES_NAMES.include?(name) || BRITISH_DIVISIONS_NAMES.include?(name)
+      return name
     end
+
+    nil # Return nil if no British equivalent found
   end
 
   private_class_method :new
 
+  def self.normalize_name(name)
+    name.to_s.gsub(/\W+/, "_")
+  end
+
   private
 
-  def multiple?
-    MULTIPLES.include?(name)
+  def has_american_multiple_name?
+    AMERICAN_MULTIPLES_NAMES.include?(name)
   end
 
-  def fraction?
-    FRACTIONS.include?(name)
+  def has_american_division_name?
+    AMERICAN_DIVISIONS_NAMES.include?(name)
   end
 
   def numerator_exponent
-    multiples_keys.index(name.gsub(/\W+/, "_")) || british_multiples_keys.index(name.gsub(/\W+/, "_")) || 0
+    normalized_name = self.class.normalize_name(name)
+    multiples_keys.index(normalized_name) || british_multiples_keys.index(normalized_name) || 0
   end
 
   def multiples_keys
-    MULTIPLES.map { |multiple| multiple.gsub(/\W+/, "_") }
+    AMERICAN_MULTIPLES_NAMES.map { |multiple| self.class.normalize_name(multiple) }
   end
 
   def british_multiples_keys
-    BRITISH_MULTIPLE_NAMES.map { |multiple| multiple.gsub(/\W+/, "_") }
+    BRITISH_MULTIPLES_NAMES.map { |multiple| self.class.normalize_name(multiple) }
   end
 
   def denominator_exponent
-    fractions_keys.index(name.gsub(/\W+/, "_")) || british_fractions_keys.index(name.gsub(/\W+/, "_")) || 0
+    normalized_name = self.class.normalize_name(name)
+    fractions_keys.index(normalized_name) || british_fractions_keys.index(normalized_name) || 0
   end
 
   def fractions_keys
-    FRACTIONS.map { |fraction| fraction.gsub(/\W+/, "_") }
+    AMERICAN_DIVISIONS_NAMES.map { |fraction| self.class.normalize_name(fraction) }
   end
 
   def british_fractions_keys
-    BRITISH_DIVISION_NAMES.map { |fraction| fraction.gsub(/\W+/, "_") }
+    BRITISH_DIVISIONS_NAMES.map { |fraction| self.class.normalize_name(fraction) }
   end
 end

data/lib/head_music/rudiment/rhythmic_units.yml

@@ -0,0 +1,80 @@
+- american_name: maxima
+  british_name: maxima
+  duration: 8.0
+  stem: false
+  flags: 0
+  notehead: maxima
+- american_name: longa
+  british_name: longa
+  duration: 4.0
+  stem: false
+  flags: 0
+  notehead: longa
+- american_name: double whole
+  british_name: breve
+  duration: 2.0
+  stem: false
+  flags: 0
+  notehead: breve
+- american_name: whole
+  british_name: semibreve
+  duration: 1.0
+  stem: false
+  flags: 0
+  notehead: open
+  tempo_shorthand: w
+- american_name: half
+  british_name: minim
+  duration: 0.5
+  stem: true
+  flags: 0
+  notehead: open
+  tempo_shorthand: h
+- american_name: quarter
+  british_name: crotchet
+  duration: 0.25
+  stem: true
+  flags: 0
+  notehead: closed
+  tempo_shorthand: q
+- american_name: eighth
+  british_name: quaver
+  duration: 0.125
+  stem: true
+  flags: 1
+  notehead: closed
+  tempo_shorthand: e
+- american_name: sixteenth
+  british_name: semiquaver
+  duration: 0.0625
+  stem: true
+  flags: 2
+  notehead: closed
+  tempo_shorthand: s
+- american_name: thirty-second
+  british_name: demisemiquaver
+  duration: 0.03125
+  stem: true
+  flags: 3
+  notehead: closed
+  tempo_shorthand: t
+- american_name: sixty-fourth
+  british_name: hemidemisemiquaver
+  duration: 0.015625
+  stem: true
+  flags: 4
+  notehead: closed
+  tempo_shorthand: x
+- american_name: hundred twenty-eighth
+  british_name: semihemidemisemiquaver
+  duration: 0.0078125
+  stem: true
+  flags: 5
+  notehead: closed
+  tempo_shorthand: o
+- american_name: two hundred fifty-sixth
+  british_name: demisemihemidemisemiquaver
+  duration: 0.00390625
+  stem: true
+  flags: 6
+  notehead: closed

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

@@ -0,0 +1,77 @@
+class HeadMusic::Rudiment::RhythmicValue::Parser
+  attr_reader :identifier, :rhythmic_value
+
+  RhythmicUnit = HeadMusic::Rudiment::RhythmicUnit
+  RhythmicValue = HeadMusic::Rudiment::RhythmicValue
+
+  PATTERN = /((double|triple)\W?)?(dotted)?.?(#{HeadMusic::Rudiment::RhythmicUnit::PATTERN})/
+
+  # For stuff like the "q." in "q. = 108"
+  SHORTHAND_PATTERN = /\A(#{HeadMusic::Rudiment::RhythmicUnit::Parser::TEMPO_SHORTHAND_PATTERN})(\.*)?\z/i
+
+  # Parse a rhythmic value identifier and return a RhythmicValue object
+  # Returns nil if the identifier cannot be parsed
+  def self.parse(identifier)
+    return nil if identifier.nil?
+    new(identifier).rhythmic_value
+  end
+
+  def initialize(identifier)
+    @identifier = identifier.to_s.strip
+    parse_components
+  end
+
+  private
+
+  def parse_components
+    # First check for shorthand patterns like "q." to avoid infinite recursion
+    match = identifier.match(SHORTHAND_PATTERN)
+    if match && match[1]
+      unit_name = RhythmicUnit::Parser.parse(match[1].to_s.strip)
+      dots = match[2] ? match[2].strip.length : 0
+      @rhythmic_value = RhythmicValue.new(unit_name, dots: dots) if unit_name
+      return
+    end
+
+    # Try RhythmicUnit::Parser directly first (handles fractions, decimals, British names, etc.)
+    parser = RhythmicUnit::Parser.new(identifier)
+    if parser.american_name
+      @rhythmic_value = RhythmicValue.new(parser.american_name, dots: 0)
+      return
+    end
+
+    # Then try to parse with dots extracted for formats like "1/4."
+    # Count and strip dots (e.g., "1/4." -> "1/4" with 1 dot)
+    # But skip this if identifier looks like a decimal number
+    unless identifier.match?(/^\d+\.\d+$/)
+      dots = identifier.scan(".").count
+      base_identifier = identifier.gsub(".", "").strip
+
+      # Try RhythmicUnit::Parser on the base identifier
+      parser = RhythmicUnit::Parser.new(base_identifier)
+      if parser.american_name
+        @rhythmic_value = RhythmicValue.new(parser.american_name, dots: dots)
+        return
+      end
+    end
+
+    # Finally check the word pattern for things like "dotted quarter"
+    match = identifier.match(PATTERN)
+    if match
+      matched_string = match[0].to_s.strip
+      # Extract unit and dots from the matched string
+      unit_part = matched_string.gsub(/^\W*(double|triple)?\W*(dotted)?\W*/, "")
+      unit = RhythmicUnit.get(unit_part)
+      if unit
+        dots = if matched_string.include?("triple")
+          3
+        elsif matched_string.include?("double")
+          2
+        else
+          matched_string.include?("dotted") ? 1 : 0
+        end
+        @rhythmic_value = RhythmicValue.new(unit, dots: dots)
+      end
+    end
+  end
+end

data/lib/head_music/{content → rudiment}/rhythmic_value.rb

@@ -1,8 +1,12 @@
 # A module for musical content
-module HeadMusic::Content; end
+module HeadMusic::Rudiment; end
 
 # A rhythmic value is a duration composed of a rhythmic unit, any number of dots, and a tied value.
-class HeadMusic::Content::RhythmicValue
+class HeadMusic::Rudiment::RhythmicValue
+  include Comparable
+
+  RhythmicUnit = HeadMusic::Rudiment::RhythmicUnit
+
   attr_reader :unit, :dots, :tied_value
 
   delegate :name, to: :unit, prefix: true
@@ -10,13 +14,23 @@ class HeadMusic::Content::RhythmicValue
 
   def self.get(identifier)
     case identifier
-    when HeadMusic::Content::RhythmicValue
+    when HeadMusic::Rudiment::RhythmicValue
       identifier
     when HeadMusic::Rudiment::RhythmicUnit
       new(identifier)
     when Symbol, String
-      identifier = identifier.to_s.downcase.strip.gsub(/\W+/, "_")
-      from_words(identifier)
+      original_identifier = identifier.to_s.strip
+      # First try the new parser which handles all formats
+      parsed = Parser.parse(original_identifier)
+      return parsed if parsed
+
+      # Then try the word-based approach as fallback
+      identifier = original_identifier.downcase.gsub(/\W+/, "_")
+      begin
+        from_words(identifier)
+      rescue
+        nil
+      end
     end
   end
 
@@ -102,4 +116,8 @@ class HeadMusic::Content::RhythmicValue
   def to_s
     name.tr("_", "-")
   end
+
+  def <=>(other)
+    total_value <=> other.total_value
+  end
 end

data/lib/head_music/rudiment/scale.rb

@@ -2,13 +2,12 @@
 module HeadMusic::Rudiment; end
 
 # A scale contains ordered pitches starting at a tonal center.
-class HeadMusic::Rudiment::Scale
+class HeadMusic::Rudiment::Scale < HeadMusic::Rudiment::Base
   SCALE_REGEX = /^[A-G][#b]?\s+\w+$/
 
   def self.get(root_pitch, scale_type = nil)
-    root_pitch, scale_type = root_pitch.split(/\s+/) if root_pitch.is_a?(String) && scale_type =~ SCALE_REGEX
     root_pitch = HeadMusic::Rudiment::Pitch.get(root_pitch)
-    scale_type = HeadMusic::Rudiment::ScaleType.get(scale_type || :major)
+    scale_type = HeadMusic::Rudiment::ScaleType.get(scale_type || HeadMusic::Rudiment::ScaleType::DEFAULT)
     @scales ||= {}
     hash_key = HeadMusic::Utilities::HashKey.for(
       [root_pitch, scale_type].join(" ").gsub(/#|♯/, "sharp").gsub(/(\w)[b♭]/, '\\1flat')
@@ -36,7 +35,7 @@ class HeadMusic::Rudiment::Scale
   end
 
   def spellings(direction: :ascending, octaves: 1)
-    pitches(direction: direction, octaves: octaves).map(&:spelling).map(&:to_s)
+    pitches(direction: direction, octaves: octaves).map(&:spelling)
   end
 
   def pitch_names(direction: :ascending, octaves: 1)
@@ -83,7 +82,7 @@ class HeadMusic::Rudiment::Scale
   end
 
   def parent_scale_pitches
-    HeadMusic::Rudiment::Scale.get(root_pitch, scale_type.parent_name).pitches if scale_type.parent
+    HeadMusic::Rudiment::Scale.get(root_pitch, scale_type.parent_name).pitches
   end
 
   def parent_scale_pitch_for(semitones_from_root)

data/lib/head_music/rudiment/scale_degree.rb

@@ -3,7 +3,7 @@ module HeadMusic::Rudiment; end
 
 # A scale degree is a number indicating the ordinality of the spelling in the key.
 # TODO: Rewrite to accept a tonal_center and a scale type.
-class HeadMusic::Rudiment::ScaleDegree
+class HeadMusic::Rudiment::ScaleDegree < HeadMusic::Rudiment::Base
   include Comparable
 
   NAME_FOR_DIATONIC_DEGREE = [nil, "tonic", "supertonic", "mediant", "subdominant", "dominant", "submediant"].freeze
@@ -38,11 +38,16 @@ class HeadMusic::Rudiment::ScaleDegree
   end
 
   def <=>(other)
-    if other.is_a?(HeadMusic::Rudiment::ScaleDegree)
+    case other
+    when HeadMusic::Rudiment::ScaleDegree
       [degree, alteration_semitones] <=> [other.degree, other.alteration_semitones]
-    else
-      # TODO: Improve this
+    when Numeric
+      degree <=> other
+    when String
       to_s <=> other.to_s
+    else
+      # If we can't meaningfully compare, return nil (Ruby standard)
+      nil
     end
   end
 

data/lib/head_music/rudiment/scale_type.rb

@@ -2,9 +2,13 @@
 module HeadMusic::Rudiment; end
 
 # A ScaleType represents a particular scale pattern, such as major, lydian, or minor pentatonic.
-class HeadMusic::Rudiment::ScaleType
-  H = 1 # whole step
-  W = 2 # half step
+class HeadMusic::Rudiment::ScaleType < HeadMusic::Rudiment::Base
+  # TODO: load scale types from yaml configuration file
+  # Include a system of aliasing, e.g. :natural_minor, :aeolian
+  # Include ascending and descending intervals for scales that differ
+
+  H = 1 # half step
+  W = 2 # whole step
 
   # Modal
   I = [W, W, H, W, W, W, H].freeze
@@ -33,6 +37,8 @@ class HeadMusic::Rudiment::ScaleType
 
   MINOR_PENTATONIC = [3, 2, 2, 3, 2].freeze
 
+  DEFAULT = :major
+
   def self._modes
     {}.tap do |modes|
       MODE_NAMES.each do |roman_numeral, aliases|

data/lib/head_music/rudiment/solmization.rb

@@ -2,7 +2,7 @@
 module HeadMusic::Rudiment; end
 
 # A solmization is the rendering of scale degrees as syllables.
-class HeadMusic::Rudiment::Solmization
+class HeadMusic::Rudiment::Solmization < HeadMusic::Rudiment::Base
   include HeadMusic::Named
 
   DEFAULT_SOLMIZATION = "solfège"

data/lib/head_music/rudiment/spelling.rb

@@ -4,8 +4,11 @@ module HeadMusic::Rudiment; end
 # Represents the spelling of a pitch, such as C# or Db.
 # Composite of a LetterName and an optional Alteration.
 # Does not include the octave. See Pitch for that.
-class HeadMusic::Rudiment::Spelling
-  MATCHER = /^\s*([A-G])(#{HeadMusic::Rudiment::Alteration.matcher}?)(-?\d+)?\s*$/i
+class HeadMusic::Rudiment::Spelling < HeadMusic::Rudiment::Base
+  LetterName = HeadMusic::Rudiment::LetterName
+  Alteration = HeadMusic::Rudiment::Alteration
+
+  MATCHER = /^\s*(#{LetterName::PATTERN})(#{Alteration::PATTERN})?(-?\d+)?\s*$/i
 
   attr_reader :pitch_class, :letter_name, :alteration
 
@@ -86,8 +89,6 @@ class HeadMusic::Rudiment::Spelling
     !alteration || alteration.natural?
   end
 
-  private_class_method :new
-
   private
 
   def enharmonic_equivalence