head_music 17.2.0 → 17.4.0

data/lib/head_music/instruments/score_order.rb

@@ -30,30 +30,9 @@ class HeadMusic::Instruments::ScoreOrder
 
   # Accepts a list of instruments and orders them according to this ensemble type's conventions
   def order(instruments)
-    valid_inputs = instruments.compact.reject { |i| i.respond_to?(:empty?) && i.empty? }
-    instrument_objects = valid_inputs.map { |i| normalize_to_instrument(i) }.compact
-
-    # Build ordering index
     ordering_index = build_ordering_index
-
-    # Separate known and unknown instruments
-    known_instruments = []
-    unknown_instruments = []
-
-    instrument_objects.each do |instrument|
-      position_info = find_position_with_transposition(instrument, ordering_index)
-      if position_info
-        known_instruments << [instrument, position_info]
-      else
-        unknown_instruments << instrument
-      end
-    end
-
-    # Sort known instruments by position (primary) and transposition (secondary)
-    sorted_known = known_instruments.sort_by { |_, pos_info|
-      [pos_info[:position], -pos_info[:transposition]]
-    }.map(&:first)
-    sorted_known + unknown_instruments.sort_by(&:to_s)
+    known, unknown = partition_by_known_position(normalize_inputs(instruments), ordering_index)
+    sort_known(known) + unknown.sort_by(&:to_s)
   end
 
   private_class_method :new
@@ -68,6 +47,32 @@ class HeadMusic::Instruments::ScoreOrder
     self.name = data["name"] || ensemble_type_key.to_s.tr("_", " ").capitalize
   end
 
+  # Discards blank inputs and converts the rest to Instrument objects
+  def normalize_inputs(instruments)
+    valid_inputs = instruments.compact.reject { |i| i.respond_to?(:empty?) && i.empty? }
+    valid_inputs.map { |i| normalize_to_instrument(i) }.compact
+  end
+
+  # Splits instruments into those with a known score position and those without
+  def partition_by_known_position(instrument_objects, ordering_index)
+    known = []
+    unknown = []
+    instrument_objects.each do |instrument|
+      position_info = find_position_with_transposition(instrument, ordering_index)
+      if position_info
+        known << [instrument, position_info]
+      else
+        unknown << instrument
+      end
+    end
+    [known, unknown]
+  end
+
+  # Sorts known instruments by position (primary) and transposition (secondary)
+  def sort_known(known)
+    known.sort_by { |_, pos_info| [pos_info[:position], -pos_info[:transposition]] }.map(&:first)
+  end
+
   def normalize_to_instrument(input)
     # Return if already an Instrument instance
     return input if input.is_a?(HeadMusic::Instruments::Instrument)
@@ -96,31 +101,36 @@ class HeadMusic::Instruments::ScoreOrder
     index
   end
 
-  # Finds the position of an instrument in the ordering
+  # Finds the position of an instrument in the ordering.
+  # Positions are non-negative integers, so a nil lookup safely means "absent".
   def find_position(instrument, ordering_index)
-    # Try exact match with name_key
-    return ordering_index[instrument.name_key.to_s] if instrument.name_key && ordering_index.key?(instrument.name_key.to_s)
+    position_by_name_key(instrument, ordering_index) ||
+      position_by_family(instrument, ordering_index) ||
+      position_by_normalized_name(instrument, ordering_index)
+  end
 
-    # Try matching by family + range category (e.g., alto_saxophone -> saxophone family)
-    if instrument.family_key
-      family_base = instrument.family_key.to_s
-      instrument_key = instrument.name_key.to_s
+  # Exact match on the instrument's name_key
+  def position_by_name_key(instrument, ordering_index)
+    return nil unless instrument.name_key
 
-      # Check if this is a variant of a family (e.g., alto_saxophone)
-      if instrument_key.include?(family_base)
-        # Look for the specific variant first
-        return ordering_index[instrument_key] if ordering_index.key?(instrument_key)
+    ordering_index[instrument.name_key.to_s]
+  end
 
-        # Fall back to generic family instrument if listed
-        return ordering_index[family_base] if ordering_index.key?(family_base)
-      end
-    end
+  # Match a family variant (e.g., alto_saxophone -> saxophone family)
+  def position_by_family(instrument, ordering_index)
+    return nil unless instrument.family_key
+
+    family_base = instrument.family_key.to_s
+    instrument_key = instrument.name_key.to_s
+    return nil unless instrument_key.include?(family_base)
 
-    # Try normalized name (lowercase, underscored)
-    normalized = HeadMusic::Utilities::Case.to_snake_case(instrument.name)
-    return ordering_index[normalized] if ordering_index.key?(normalized)
+    # Prefer the specific variant, then fall back to the generic family instrument
+    ordering_index[instrument_key] || ordering_index[family_base]
+  end
 
-    nil
+  # Match the normalized (lowercase, underscored) display name
+  def position_by_normalized_name(instrument, ordering_index)
+    ordering_index[HeadMusic::Utilities::Case.to_snake_case(instrument.name)]
   end
 
   # Finds the position and transposition information for an instrument

data/lib/head_music/instruments/staff_profile.rb

@@ -0,0 +1,71 @@
+# A module for musical instruments and their properties
+module HeadMusic::Instruments; end
+
+# The properties an instrument derives from its default notation staves:
+# how many staves it uses, their clefs, whether it transposes, and whether it
+# is pitched. These are a projection of the notation layer (a StaffScheme built
+# from the default NotationStyle), separated from the instrument's identity so
+# Instrument can delegate to one place rather than carry the staff logic itself.
+class HeadMusic::Instruments::StaffProfile
+  attr_reader :instrument
+
+  def initialize(instrument)
+    @instrument = instrument
+  end
+
+  def staff_schemes
+    [default_staff_scheme]
+  end
+
+  def default_staff_scheme
+    @default_staff_scheme ||= HeadMusic::Instruments::StaffScheme.new(
+      key: "default",
+      instrument: instrument,
+      list: default_notation_staves_data
+    )
+  end
+
+  def default_staves
+    default_staff_scheme.staves
+  end
+
+  def default_clefs
+    default_staves&.map(&:clef) || []
+  end
+
+  def sounding_transposition
+    default_staves&.first&.sounding_transposition || 0
+  end
+
+  def transposing?
+    sounding_transposition != 0
+  end
+
+  def transposing_at_the_octave?
+    transposing? && sounding_transposition % 12 == 0
+  end
+
+  def single_staff?
+    default_staves.length == 1
+  end
+
+  def multiple_staves?
+    default_staves.length > 1
+  end
+
+  def pitched?
+    return false if default_clefs.compact.uniq == [HeadMusic::Rudiment::Clef.get("neutral_clef")]
+
+    default_clefs.any?
+  end
+
+  private
+
+  # The raw staff-attribute list for this instrument's default notation,
+  # resolved from the default NotationStyle. Referenced only inside a method
+  # body, because the Notation module loads after Instruments.
+  def default_notation_staves_data
+    notation = HeadMusic::Notation::NotationStyle.default.notation_for(instrument)
+    (notation&.staves || []).map(&:attributes)
+  end
+end

data/lib/head_music/instruments/stringing.rb

@@ -10,10 +10,14 @@ module HeadMusic::Instruments; end
 #   stringing = HeadMusic::Instruments::Stringing.for_instrument(guitar)
 #   stringing.courses.map(&:standard_pitch)  # => [E2, A2, D3, G3, B3, E4]
 class HeadMusic::Instruments::Stringing
+  include HeadMusic::ValueEquality
+
   STRINGINGS = YAML.load_file(File.expand_path("stringings.yml", __dir__)).freeze
 
   attr_reader :instrument_key, :courses
 
+  value_equality :instrument_key, :courses
+
   class << self
     # Find the stringing for an instrument
     # @param instrument [HeadMusic::Instruments::Instrument, String, Symbol] The instrument
@@ -92,12 +96,6 @@ class HeadMusic::Instruments::Stringing
     end
   end
 
-  def ==(other)
-    return false unless other.is_a?(self.class)
-
-    instrument_key == other.instrument_key && courses == other.courses
-  end
-
   def to_s
     "#{course_count}-course stringing for #{instrument_key}"
   end

data/lib/head_music/instruments/stringing_course.rb

@@ -11,8 +11,12 @@ module HeadMusic::Instruments; end
 #   - 12-string guitar: 6 courses, each with 2 strings (octave or unison)
 #   - Mandolin: 4 courses, each with 2 strings in unison
 class HeadMusic::Instruments::StringingCourse
+  include HeadMusic::ValueEquality
+
   attr_reader :standard_pitch, :course_semitones
 
+  value_equality :standard_pitch, :course_semitones
+
   # @param standard_pitch [HeadMusic::Rudiment::Pitch, String] The pitch of the primary string
   # @param course_semitones [Array<Integer>] Semitone offsets for additional strings in the course
   def initialize(standard_pitch:, course_semitones: [])
@@ -38,12 +42,6 @@ class HeadMusic::Instruments::StringingCourse
     course_semitones.any?
   end
 
-  def ==(other)
-    return false unless other.is_a?(self.class)
-
-    standard_pitch == other.standard_pitch && course_semitones == other.course_semitones
-  end
-
   def to_s
     standard_pitch.to_s
   end

data/lib/head_music/instruments/variant.rb

@@ -1,8 +1,12 @@
 module HeadMusic::Instruments; end
 
 class HeadMusic::Instruments::Variant
+  include HeadMusic::ValueEquality
+
   attr_reader :key, :attributes
 
+  value_equality :key, :attributes
+
   def initialize(key, attributes = {})
     @key = key.to_s.to_sym
     @attributes = attributes
@@ -34,10 +38,4 @@ class HeadMusic::Instruments::Variant
     @default_staff_scheme ||=
       staff_schemes.find(&:default?) || staff_schemes.first
   end
-
-  def ==(other)
-    return false unless other.is_a?(self.class)
-
-    key == other.key && attributes == other.attributes
-  end
 end

data/lib/head_music/named/locale.rb

@@ -0,0 +1,32 @@
+module HeadMusic::Named
+  # Locale encapsulates a language and optional region or country.
+  class Locale
+    DEFAULT_CODE = :en_US
+
+    attr_reader :language, :region
+
+    def self.default_locale
+      get(DEFAULT_CODE)
+    end
+
+    def self.get(code)
+      @locales ||= {}
+      parts = code.to_s.split(/[_-]/)
+      language = parts[0].downcase
+      region = parts[1]&.upcase
+      key = [language, region].compact.join("_").to_sym
+      @locales[key] ||= new(language: language, region: region)
+    end
+
+    def initialize(language:, region: nil)
+      @language = language
+      @region = region
+    end
+
+    def code
+      @code ||= [@language, @region].compact.join("_")
+    end
+
+    private_class_method :new
+  end
+end

data/lib/head_music/named/localized_name.rb

@@ -0,0 +1,15 @@
+module HeadMusic::Named
+  # A LocalizedName is the name of a rudiment in a locale.
+  class LocalizedName
+    attr_reader :locale, :name, :abbreviation
+
+    delegate :code, to: :locale, prefix: true
+    delegate :language, :region, to: :locale
+
+    def initialize(name:, locale_code: Locale::DEFAULT_CODE, abbreviation: nil)
+      @name = name
+      @locale = Locale.get(locale_code)
+      @abbreviation = abbreviation
+    end
+  end
+end

data/lib/head_music/named.rb

@@ -1,52 +1,8 @@
 # NameRudiment is a module to be included in classes whose instances may be identified by name.
+# Locale and LocalizedName, the value objects it builds names from, live in their own files.
 module HeadMusic::Named
   delegate :to_s, to: :name
 
-  # Locale encapsulates a language and optional region or country.
-  class Locale
-    DEFAULT_CODE = :en_US
-
-    attr_reader :language, :region
-
-    def self.default_locale
-      get(DEFAULT_CODE)
-    end
-
-    def self.get(code)
-      @locales ||= {}
-      parts = code.to_s.split(/[_-]/)
-      language = parts[0].downcase
-      region = parts[1]&.upcase
-      key = [language, region].compact.join("_").to_sym
-      @locales[key] ||= new(language: language, region: region)
-    end
-
-    def initialize(language:, region: nil)
-      @language = language
-      @region = region
-    end
-
-    def code
-      @code ||= [@language, @region].compact.join("_")
-    end
-
-    private_class_method :new
-  end
-
-  # A LocalizedName is the name of a rudiment in a locale.
-  class LocalizedName
-    attr_reader :locale, :name, :abbreviation
-
-    delegate :code, to: :locale, prefix: true
-    delegate :language, :region, to: :locale
-
-    def initialize(name:, locale_code: Locale::DEFAULT_CODE, abbreviation: nil)
-      @name = name
-      @locale = Locale.get(locale_code)
-      @abbreviation = abbreviation
-    end
-  end
-
   # Adds .get_by_name to the including class.
   module ClassMethods
     def get_by_name(name)

data/lib/head_music/notation/abc/body_lexer.rb

@@ -38,10 +38,20 @@ class HeadMusic::Notation::ABC::BodyLexer
 
   NOTE_PATTERN = %r{(\^\^|\^|__|_|=)?([A-Ga-g])([',]*)([\d/]*)}
   CHORD_START_PATTERN = /\[(\^\^|\^|__|_|=)?[A-Ga-g]/
+  # An inline field ("[K:...]"), tried closed before its unterminated fallback.
+  INLINE_FIELD_PATTERNS = [/\[[A-Za-z]:[^\]]*\]/, /\[[A-Za-z]:[^\]]*/].freeze
   CHORD_NOTE_PATTERN = %r{(\^\^|\^|__|_|=)?([A-Ga-g])([',]*)([\d/]*)}
   REST_PATTERN = %r{z([\d/]*)}
   VOLTA_DIGITS_PATTERN = /\d[\d,-]*/
 
+  # Recognizable ABC we deliberately don't handle: grace notes ({..}),
+  # decorations (!..!), tuplets, slurs, and special rests (Z, x). Ordered
+  # so a closed form is tried before its unterminated fallback.
+  UNSUPPORTED_PATTERNS = [
+    /\{[^}]*\}/, /\{[^}]*/, /![^!]*!/, /![^!]*/,
+    /\(\d/, /[()~.]/, /Z\d*/, %r{x[\d/]*}
+  ].freeze
+
   SNIPPET_LENGTH = 20
 
   def initialize(body_text, start_line: 1)
@@ -70,15 +80,17 @@ class HeadMusic::Notation::ABC::BodyLexer
     @body.lines.map(&:chomp).each_with_index do |line_text, index|
       break if line_text.strip.empty?
 
-      line_number = @start_line + index
-      if !continued && line_start_token(line_text, line_number, tokens)
-        next
-      end
-      continued = scan_line(line_text, line_number, tokens)
+      continued = lex_line(line_text, @start_line + index, tokens, continued)
     end
     tokens
   end
 
+  def lex_line(line_text, line_number, tokens, continued)
+    return false if !continued && line_start_token(line_text, line_number, tokens)
+
+    scan_line(line_text, line_number, tokens)
+  end
+
   # Handles lines that are fields rather than music: V: switches voices;
   # any other letter-colon line is a field we don't interpret in the body.
   def line_start_token(line_text, line_number, tokens)
@@ -107,19 +119,35 @@ class HeadMusic::Notation::ABC::BodyLexer
     Token.new(type: :voice_change, line: line_number, column: 1, voice_id: voice_id)
   end
 
+  # Music tokens whose whitespace successor breaks a beam group; other
+  # tokens (bar lines, ties, etc.) already interrupt beaming on their own.
+  BEAMABLE_TOKEN_TYPES = [:note, :rest, :chord].freeze
+
   # Returns true when the line ends with a continuation backslash.
   def scan_line(line_text, line_number, tokens)
     scanner = StringScanner.new(line_text)
     until scanner.eos?
-      next if scanner.skip(/[ \t]+/)
+      spaced = scanner.skip(/[ \t]+/)
       break if scanner.skip(/%/)
       return true if scanner.skip(/\\[ \t]*\z/)
+      break if scanner.eos?
 
+      tokens << beam_break_token(scanner, line_number) if spaced && beamable_predecessor?(tokens.last)
       scan_token(scanner, line_number, tokens)
     end
     false
   end
 
+  # A beam break only matters after a music token; whitespace elsewhere
+  # (leading, after a bar line) carries no beaming signal.
+  def beamable_predecessor?(token)
+    !token.nil? && BEAMABLE_TOKEN_TYPES.include?(token.type)
+  end
+
+  def beam_break_token(scanner, line_number)
+    Token.new(type: :beam_break, line: line_number, column: scanner.pos + 1)
+  end
+
   def scan_token(scanner, line_number, tokens)
     column = scanner.pos + 1
 
@@ -174,7 +202,7 @@ class HeadMusic::Notation::ABC::BodyLexer
       return true
     end
 
-    inline_field = scanner.scan(/\[[A-Za-z]:[^\]]*\]/) || scanner.scan(/\[[A-Za-z]:[^\]]*/)
+    inline_field = scan_first(scanner, INLINE_FIELD_PATTERNS)
     if inline_field
       tokens << unsupported_token(inline_field, line_number, column)
       return true
@@ -188,19 +216,27 @@ class HeadMusic::Notation::ABC::BodyLexer
   def scan_chord(scanner, line_number, column, tokens)
     start_pos = scanner.pos
     scanner.skip(/\[/)
+    notes = collect_chord_notes(scanner)
+    return chord_fallback(scanner, start_pos, line_number, column, tokens) unless notes
+
+    length = scanner.scan(%r{[\d/]*})
+    tokens << Token.new(type: :chord, line: line_number, column: column, notes: notes, length: length)
+    true
+  end
+
+  # Collects the notes between the brackets, or nil when a non-note is hit
+  # (leaving the scanner where it stopped so the fallback can react).
+  def collect_chord_notes(scanner)
     notes = []
     until scanner.skip(/\]/)
-      unless scanner.scan(CHORD_NOTE_PATTERN)
-        return chord_fallback(scanner, start_pos, line_number, column, tokens)
-      end
+      return nil unless scanner.scan(CHORD_NOTE_PATTERN)
+
       notes << ChordNote.new(
         accidental: scanner[1], letter: scanner[2],
         octave_marks: scanner[3], length: scanner[4]
       )
     end
-    length = scanner.scan(%r{[\d/]*})
-    tokens << Token.new(type: :chord, line: line_number, column: column, notes: notes, length: length)
-    true
+    notes
   end
 
   # Non-note content inside the brackets (ties, rests, spaces,
@@ -235,10 +271,12 @@ class HeadMusic::Notation::ABC::BodyLexer
   end
 
   def volta_passes(digits)
-    digits.split(",").flat_map do |part|
-      first, last = part.split("-", 2)
-      last ? (first.to_i..last.to_i).to_a : [first.to_i]
-    end.select(&:positive?)
+    digits.split(",").flat_map { |part| expand_volta_range(part) }.select(&:positive?)
+  end
+
+  def expand_volta_range(part)
+    first, last = part.split("-", 2)
+    last ? (first.to_i..last.to_i).to_a : [first.to_i]
   end
 
   def scan_note(scanner, line_number, column, tokens)
@@ -289,20 +327,23 @@ class HeadMusic::Notation::ABC::BodyLexer
     true
   end
 
-  # Recognizable ABC we deliberately don't handle: grace notes,
-  # decorations, tuplets, slurs, and special rests.
   def scan_unsupported(scanner, line_number, column, tokens)
-    lexeme =
-      scanner.scan(/\{[^}]*\}/) || scanner.scan(/\{[^}]*/) ||
-      scanner.scan(/![^!]*!/) || scanner.scan(/![^!]*/) ||
-      scanner.scan(/\(\d/) || scanner.scan(/[()~.]/) ||
-      scanner.scan(/Z\d*/) || scanner.scan(%r{x[\d/]*})
+    lexeme = scan_first(scanner, UNSUPPORTED_PATTERNS)
     return false unless lexeme
 
     tokens << unsupported_token(lexeme, line_number, column)
     true
   end
 
+  # Returns the first pattern's match, trying each in order.
+  def scan_first(scanner, patterns)
+    patterns.each do |pattern|
+      lexeme = scanner.scan(pattern)
+      return lexeme if lexeme
+    end
+    nil
+  end
+
   def unsupported_token(lexeme, line_number, column)
     Token.new(type: :unsupported, line: line_number, column: column, lexeme: lexeme)
   end

data/lib/head_music/notation/abc/duration_resolver.rb

@@ -48,6 +48,10 @@ module HeadMusic::Notation::ABC
       return Rational(numerator) unless slashes
       return Rational(numerator, 2**slashes.length) unless denominator
 
+      explicit_ratio(numerator, slashes, denominator, source)
+    end
+
+    def explicit_ratio(numerator, slashes, denominator, source)
       # An explicit denominator pairs with exactly one slash ("3/2", not "3//2").
       raise_error("malformed note length multiplier", source) if slashes.length > 1
       raise_error("note length denominator cannot be zero", source) if denominator.to_i.zero?
@@ -85,9 +89,15 @@ module HeadMusic::Notation::ABC
     def greedy_head(fraction)
       numerator = fraction.numerator
       bits = numerator.bit_length
+      run = leading_set_bits(numerator, bits)
+      Rational(((1 << run) - 1) << (bits - run), fraction.denominator)
+    end
+
+    # Length of the leading run of set bits, capped at four (triple-dotted).
+    def leading_set_bits(numerator, bits)
       run = 0
       run += 1 while run < 4 && run < bits && numerator[bits - 1 - run] == 1
-      Rational(((1 << run) - 1) << (bits - run), fraction.denominator)
+      run
     end
 
     def unit_for(unit_fraction, source)

data/lib/head_music/notation/abc/duration_writer.rb

@@ -22,19 +22,12 @@ module HeadMusic::Notation::ABC
     # from integer parts so the multiplier arithmetic stays exact. A tied
     # chain collapses to one multiplier, round-tripping tokens like "A5".
     def total_fraction(rhythmic_value)
-      fraction = single_fraction(rhythmic_value)
+      fraction = HeadMusic::Notation::DottedDuration.dotted_unit_fraction(rhythmic_value)
       tied_value = rhythmic_value.tied_value
       fraction += total_fraction(tied_value) if tied_value
       fraction
     end
 
-    def single_fraction(rhythmic_value)
-      unit = rhythmic_value.unit
-      dots = rhythmic_value.dots
-      # A value with d dots spans (2^(d+1) - 1) / 2^d of its unit.
-      Rational(unit.numerator, unit.denominator) * Rational((2**(dots + 1)) - 1, 2**dots)
-    end
-
     def validate_fraction!(fraction, rhythmic_value)
       max_fraction = DurationResolver::MAX_FRACTION
       if fraction > max_fraction

data/lib/head_music/notation/abc/header.rb

@@ -44,6 +44,14 @@ class HeadMusic::Notation::ABC::Header
 
   # Returns true when the field is K:, which terminates the header.
   def assign_field(stripped_line, line_number)
+    letter, value = parse_field(stripped_line, line_number)
+    return assign_key(value, line_number) if letter == "K"
+
+    store_field(letter, value, line_number, stripped_line)
+    false
+  end
+
+  def parse_field(stripped_line, line_number)
     match = FIELD_PATTERN.match(stripped_line)
     unless match
       raise HeadMusic::Notation::ABC::ParseError.new(
@@ -51,8 +59,15 @@ class HeadMusic::Notation::ABC::Header
         line_number: line_number, snippet: stripped_line
       )
     end
-    letter = match[1]
-    value = match[2].strip
+    [match[1], match[2].strip]
+  end
+
+  def assign_key(value, line_number)
+    @key_signature = HeadMusic::Notation::ABC::KeyMapper.new(value, line_number: line_number).key_signature
+    true
+  end
+
+  def store_field(letter, value, line_number, stripped_line)
     case letter
     when "X" then @reference_number = value
     when "T" then @title = value
@@ -62,15 +77,11 @@ class HeadMusic::Notation::ABC::Header
     when "M" then @meter = resolve_meter(value, line_number)
     when "L" then @unit_note_length = resolve_unit_note_length(value, line_number)
     when "V" then @voice_ids << value.split.first
-    when "K"
-      @key_signature = HeadMusic::Notation::ABC::KeyMapper.new(value, line_number: line_number).key_signature
-      return true
     else
       raise HeadMusic::Notation::ABC::UnsupportedFeatureError.new(
         "Unsupported header field #{letter.inspect}", line_number: line_number, snippet: stripped_line
       )
     end
-    false
   end
 
   def capture_body(lines, key_line_index)
@@ -84,23 +95,23 @@ class HeadMusic::Notation::ABC::Header
     return HeadMusic::Rudiment::Meter.common_time if value == "C"
     return HeadMusic::Rudiment::Meter.cut_time if value == "C|"
 
-    unless FRACTION_PATTERN.match?(value)
-      raise HeadMusic::Notation::ABC::ParseError.new(
-        "Invalid meter #{value.inspect}", line_number: line_number, snippet: value
-      )
-    end
+    ensure_fraction!(value, "meter", line_number)
     HeadMusic::Rudiment::Meter.get(value)
   end
 
   def resolve_unit_note_length(value, line_number)
-    unless FRACTION_PATTERN.match?(value)
-      raise HeadMusic::Notation::ABC::ParseError.new(
-        "Invalid unit note length #{value.inspect}", line_number: line_number, snippet: value
-      )
-    end
+    ensure_fraction!(value, "unit note length", line_number)
     Rational(value)
   end
 
+  def ensure_fraction!(value, description, line_number)
+    return if FRACTION_PATTERN.match?(value)
+
+    raise HeadMusic::Notation::ABC::ParseError.new(
+      "Invalid #{description} #{value.inspect}", line_number: line_number, snippet: value
+    )
+  end
+
   def apply_defaults
     @meter ||= HeadMusic::Rudiment::Meter.common_time
   end