head_music 17.2.0 → 17.4.0

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

@@ -34,85 +34,18 @@ module HeadMusic::Notation::ABC
 
     attr_reader :header, :duration_resolver
 
-    # A note or chord whose placement is deferred until we know whether
-    # a broken-rhythm mark follows it. The pitches are computed eagerly
-    # so bar-line accidental resets cannot corrupt them. `tied_prefix`,
-    # when present, is the already-built rhythmic value of everything
-    # tied ahead of this note; its own value is appended at flush time.
-    PendingNote = Data.define(:pitches, :length, :scale, :tied_prefix) do
-      def initialize(pitches:, length:, scale:, tied_prefix: nil)
-        super
-      end
-    end
-
-    # Per-voice interpretation state. Accidentals, the deferred note,
-    # and volta tracking are all independent between voices.
-    class VoiceState
-      attr_reader :voice, :pitch_builder
-      attr_accessor :pending_note, :awaiting_scale, :broken_line,
-        :active_passes, :volta_start_bar, :tie_open, :tie_line
-
-      def initialize(voice, pitch_builder)
-        @voice = voice
-        @pitch_builder = pitch_builder
-      end
-
-      def completed_bar_number
-        voice.last_placement&.position&.bar_number
-      end
-
-      def entered_bar_number
-        voice.next_position.bar_number
-      end
-    end
+    # Per-voice interpretation state and note-assembly live in VoiceState.
 
     def build_composition
-      ensure_input_present
+      Preflight.ensure_input_present(@abc_string)
       @header = Header.new(@abc_string, start_line: @start_line)
-      reject_content_after_tune
+      Preflight.reject_content_after_tune(header)
       tokens = BodyLexer.new(header.body, start_line: header.body_start_line).tokens
-      reject_unsupported_tokens(tokens)
+      Preflight.reject_unsupported_tokens(tokens)
       @duration_resolver = DurationResolver.new(header.unit_note_length)
       interpret(tokens)
     end
 
-    def ensure_input_present
-      return unless @abc_string.to_s.strip.empty?
-
-      raise ParseError, "ABC input is blank"
-    end
-
-    # The lexer treats a blank line as the end of the tune, so anything
-    # after it would be silently dropped — most likely another tune.
-    def reject_content_after_tune
-      lines = header.body.lines
-      blank_index = lines.find_index { |line| line.strip.empty? }
-      return unless blank_index
-
-      extra_lines = lines[(blank_index + 1)..]
-      extra_index = extra_lines.find_index do |line|
-        stripped = line.strip
-        !stripped.empty? && !stripped.start_with?("%")
-      end
-      return unless extra_index
-
-      raise ParseError.new(
-        "Content after the tune body; parse a book of tunes with ABC.parse_book",
-        line_number: header.body_start_line + blank_index + 1 + extra_index,
-        snippet: extra_lines[extra_index].strip[0, BodyLexer::SNIPPET_LENGTH]
-      )
-    end
-
-    def reject_unsupported_tokens(tokens)
-      token = tokens.find { |candidate| candidate.type == :unsupported }
-      return unless token
-
-      raise UnsupportedFeatureError.new(
-        "Unsupported ABC feature #{token.lexeme.inspect}",
-        line_number: token.line, snippet: token.lexeme
-      )
-    end
-
     def interpret(tokens)
       @building = HeadMusic::Content::Composition.new(
         name: header.title,
@@ -140,7 +73,8 @@ module HeadMusic::Notation::ABC
     def voice_state(role)
       @voice_states[role] ||= VoiceState.new(
         @building.add_voice(role: role),
-        PitchBuilder.new(header.key_signature)
+        PitchBuilder.new(header.key_signature),
+        duration_resolver
       )
     end
 
@@ -159,13 +93,14 @@ module HeadMusic::Notation::ABC
       when :bar_line then handle_bar_line(token)
       when :volta then handle_volta(token)
       when :voice_change then handle_voice_change(token)
+      when :beam_break then handle_beam_break(token)
       end
     end
 
     def handle_note(token)
       state = current_state
       pitch = state.pitch_builder.pitch(token.letter, token.octave_marks, token.accidental)
-      defer_placement(state, [pitch], token.length)
+      state.defer_placement([pitch], token.length)
     end
 
     # Chord pitches resolve in bracket order, so an explicit accidental
@@ -177,7 +112,7 @@ module HeadMusic::Notation::ABC
       end
       ensure_unique_chord_pitches(pitches, token)
       inner_length = uniform_chord_length(token)
-      defer_placement(state, pitches, token.length, inner_length)
+      state.defer_placement(pitches, token.length, inner_length)
     end
 
     def ensure_unique_chord_pitches(pitches, token)
@@ -211,13 +146,10 @@ module HeadMusic::Notation::ABC
       "[#{inner}]"
     end
 
-    def defer_placement(state, pitches, length, inner_scale = Rational(1))
-      scale = (state.awaiting_scale || Rational(1)) * inner_scale
-      state.awaiting_scale = nil
-      return tie_onto_pending(state, pitches, length, scale) if state.tie_open
-
-      flush_pending_note(state)
-      state.pending_note = PendingNote.new(pitches: pitches, length: length, scale: scale)
+    # The lexer only emits :beam_break after a music token, so a voice
+    # state already exists; the flag is consumed by the next deferred note.
+    def handle_beam_break(_token)
+      current_state.mark_beam_break
     end
 
     # A tie (`-`) after a note or chord fuses it to the next note of the
@@ -225,90 +157,73 @@ module HeadMusic::Notation::ABC
     # its right note arrives.
     def handle_tie(token)
       state = current_state
+      line = token.line
       if state.awaiting_scale || state.pending_note.nil?
-        raise ParseError.new(
-          "A tie must follow a note", line_number: token.line, snippet: "-"
-        )
+        raise ParseError.new("A tie must follow a note", line_number: line, snippet: "-")
       end
-      state.tie_open = true
-      state.tie_line = token.line
-    end
-
-    # Closes an open tie: the pending note becomes the new note's tied
-    # prefix, so the pair (and any longer chain) resolves to a single
-    # placement whose rhythmic value carries the author's chosen split.
-    def tie_onto_pending(state, pitches, length, scale)
-      pending = state.pending_note
-      ensure_tie_pitches_match(state, pending, pitches)
-      prefix = pending_rhythmic_value(pending)
-      state.tie_open = false
-      state.tie_line = nil
-      state.pending_note = PendingNote.new(
-        pitches: pitches, length: length, scale: scale, tied_prefix: prefix
-      )
-    end
-
-    def ensure_tie_pitches_match(state, pending, pitches)
-      return if pending.pitches.sort == pitches.sort
-
-      raise ParseError.new(
-        "A tie must connect two notes of the same pitch",
-        line_number: state.tie_line, snippet: "-"
-      )
+      state.open_tie(line)
     end
 
     def handle_rest(token)
       ensure_not_awaiting_note(token)
       state = current_state
       reject_open_tie(state, token.line, "A tie must be followed by a note")
-      flush_pending_note(state)
-      place(state, token.length, nil)
+      state.flush_pending_note
+      state.reset_beam_adjacency
+      state.place(token.length, nil)
     end
 
     # A tie left open by a non-note terminator can never close, so each
     # terminator rejects it. A bar line gets its own message: an author
     # tie across a barline is a real, but not-yet-supported, request.
     def reject_open_tie(state, line, message)
-      return unless state&.tie_open
+      return unless state&.tie_open?
 
       raise ParseError.new(message, line_number: line || state.tie_line, snippet: "-")
     end
 
     def handle_broken_rhythm(token)
       state = current_state
-      reject_open_tie(state, token.line, "A tie must be followed by a note")
-      if state.awaiting_scale || state.pending_note.nil?
+      line = token.line
+      direction = token.direction
+      reject_open_tie(state, line, "A tie must be followed by a note")
+      pending = state.pending_note
+      if state.awaiting_scale || pending.nil?
         raise ParseError.new(
           "Broken rhythm must appear between two notes",
-          line_number: token.line, snippet: token.direction.to_s
+          line_number: line, snippet: direction.to_s
         )
       end
-      left_scale, right_scale = BROKEN_RHYTHM_SCALES.fetch(token.direction)
-      state.pending_note = state.pending_note.with(scale: state.pending_note.scale * left_scale)
+      left_scale, right_scale = BROKEN_RHYTHM_SCALES.fetch(direction)
+      state.pending_note = pending.with(scale: pending.scale * left_scale)
       state.awaiting_scale = right_scale
-      state.broken_line = token.line
+      state.broken_line = line
     end
 
     def handle_bar_line(token)
       ensure_not_awaiting_note(token)
       state = current_state
+      style = token.style
       reject_open_tie(state, token.line, "Ties across barlines are not yet supported")
-      flush_pending_note(state)
+      state.flush_pending_note
+      state.reset_beam_adjacency
       tag_completed_bar(state)
-      apply_repeat_flags(state, token.style)
-      clear_passes_if_over(state, token.style)
+      apply_repeat_flags(state, style)
+      clear_passes_if_over(state, style)
       state.pitch_builder.start_new_bar
     end
 
     def handle_volta(token)
       ensure_not_awaiting_note(token)
-      if token.passes.empty?
-        raise ParseError.new("Volta has no passes", line_number: token.line)
-      end
+      passes = token.passes
+      line = token.line
+      raise ParseError.new("Volta has no passes", line_number: line) if passes.empty?
+
       state = current_state
-      reject_open_tie(state, token.line, "A tie must be followed by a note")
-      flush_pending_note(state)
-      state.active_passes = token.passes
+      reject_open_tie(state, line, "A tie must be followed by a note")
+      state.flush_pending_note
+      state.reset_beam_adjacency
+      state.active_passes = passes
       state.volta_start_bar = state.entered_bar_number
     end
 
@@ -317,7 +232,8 @@ module HeadMusic::Notation::ABC
       if @current_state
         ensure_not_awaiting_note(token, state: @current_state)
         reject_open_tie(@current_state, token.line, "A tie must be followed by a note")
-        flush_pending_note(@current_state)
+        @current_state.flush_pending_note
+        @current_state.reset_beam_adjacency
       end
       @current_state = voice_state(token.voice_id)
     end
@@ -326,7 +242,7 @@ module HeadMusic::Notation::ABC
       @voice_states.each_value do |state|
         ensure_not_awaiting_note(nil, state: state)
         reject_open_tie(state, nil, "A tie must be followed by a note")
-        flush_pending_note(state)
+        state.flush_pending_note
         tag_completed_bar(state)
       end
     end
@@ -340,34 +256,6 @@ module HeadMusic::Notation::ABC
       )
     end
 
-    def flush_pending_note(state)
-      pending = state.pending_note
-      return unless pending
-
-      state.pending_note = nil
-      state.voice.place(state.voice.next_position, pending_rhythmic_value(pending), pending.pitches)
-    end
-
-    # A pending note's own value, with any tied prefix appended ahead of
-    # it so the whole tie chain renders as one sounding note.
-    def pending_rhythmic_value(pending)
-      own = duration_resolver.rhythmic_value(pending.length, scale: pending.scale)
-      pending.tied_prefix ? append_tied(pending.tied_prefix, own) : own
-    end
-
-    # Attaches `tail` at the deep end of `head`'s tied chain, rebuilding
-    # each link (RhythmicValue exposes no setter) so a chain like
-    # "half tied to eighth" gains a further "tied to quarter".
-    def append_tied(head, tail)
-      inner = head.tied_value ? append_tied(head.tied_value, tail) : tail
-      HeadMusic::Rudiment::RhythmicValue.new(head.unit, dots: head.dots, tied_value: inner)
-    end
-
-    def place(state, length, pitches, scale: Rational(1))
-      rhythmic_value = duration_resolver.rhythmic_value(length, scale: scale)
-      state.voice.place(state.voice.next_position, rhythmic_value, pitches)
-    end
-
     def apply_repeat_flags(state, style)
       if REPEAT_ENDING_STYLES.include?(style)
         completed = state.completed_bar_number
@@ -381,12 +269,13 @@ module HeadMusic::Notation::ABC
     # A volta covers every bar from its opening bracket through the bar
     # line that ends it, so each completed bar in that span gets tagged.
     def tag_completed_bar(state)
-      return unless state.active_passes
+      passes = state.active_passes
+      return unless passes
 
       completed = state.completed_bar_number
       return unless completed && completed >= state.volta_start_bar
 
-      bar(completed).plays_on_passes = state.active_passes
+      bar(completed).plays_on_passes = passes
     end
 
     def clear_passes_if_over(state, style)

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

@@ -0,0 +1,48 @@
+# A namespace for ABC-notation parsing helpers
+module HeadMusic::Notation::ABC
+  # Boundary checks the Parser runs before it interprets a tune, so a caller
+  # never receives a reference to a partially built composition. Each check
+  # raises on the first problem it finds and is otherwise a no-op. They run at
+  # distinct points of construction — blank input before the header is read,
+  # trailing content once the header exists, unsupported tokens after lexing —
+  # so each takes exactly the input it inspects rather than sharing state.
+  class Preflight
+    def self.ensure_input_present(abc_string)
+      return unless abc_string.to_s.strip.empty?
+
+      raise ParseError, "ABC input is blank"
+    end
+
+    # The lexer treats a blank line as the end of the tune, so anything
+    # after it would be silently dropped — most likely another tune.
+    def self.reject_content_after_tune(header)
+      lines = header.body.lines
+      blank_index = lines.find_index { |line| line.strip.empty? }
+      return unless blank_index
+
+      extra_lines = lines[(blank_index + 1)..]
+      extra_index = extra_lines.find_index do |line|
+        stripped = line.strip
+        !stripped.empty? && !stripped.start_with?("%")
+      end
+      return unless extra_index
+
+      raise ParseError.new(
+        "Content after the tune body; parse a book of tunes with ABC.parse_book",
+        line_number: header.body_start_line + blank_index + 1 + extra_index,
+        snippet: extra_lines[extra_index].strip[0, BodyLexer::SNIPPET_LENGTH]
+      )
+    end
+
+    def self.reject_unsupported_tokens(tokens)
+      token = tokens.find { |candidate| candidate.type == :unsupported }
+      return unless token
+
+      lexeme = token.lexeme
+      raise UnsupportedFeatureError.new(
+        "Unsupported ABC feature #{lexeme.inspect}",
+        line_number: token.line, snippet: lexeme
+      )
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+# A namespace for ABC-notation parsing helpers
+module HeadMusic::Notation::ABC
+  # Per-voice interpretation state and the note-assembly it drives. Accidentals,
+  # the deferred note, ties, and volta tracking are all independent between
+  # voices, so each voice owns one of these. Beam adjacency and tie bookkeeping
+  # are exposed as transitions rather than raw setters, and the parser hands
+  # notes and chords here to be buffered, tied, and flushed onto the voice — the
+  # behavior that reads and mutates this state lives with the state itself.
+  class VoiceState
+    # The identity length scale, used wherever no stretching applies.
+    ONE = Rational(1)
+
+    # A note or chord whose placement is deferred until we know whether a
+    # broken-rhythm mark follows it. The pitches are computed eagerly so
+    # bar-line accidental resets cannot corrupt them. `tied_prefix`, when
+    # present, is the already-built rhythmic value of everything tied ahead of
+    # this note; its own value is appended at flush time.
+    PendingNote = Data.define(:pitches, :length, :scale, :tied_prefix, :beam_break) do
+      def initialize(pitches:, length:, scale:, tied_prefix: nil, beam_break: nil)
+        super
+      end
+    end
+
+    attr_reader :voice, :pitch_builder, :tie_line
+    attr_accessor :pending_note, :awaiting_scale, :broken_line,
+      :active_passes, :volta_start_bar
+
+    def initialize(voice, pitch_builder, duration_resolver = nil)
+      @voice = voice
+      @pitch_builder = pitch_builder
+      @duration_resolver = duration_resolver
+      @beam_break_pending = false
+      @beam_last_was_note = false
+      @tie_open = false
+    end
+
+    def completed_bar_number
+      voice.last_placement&.position&.bar_number
+    end
+
+    def entered_bar_number
+      voice.next_position.bar_number
+    end
+
+    # Records an explicit beam break; the next note consumes it.
+    def mark_beam_break
+      @beam_break_pending = true
+    end
+
+    # The beam-break flag for the note now beginning: true if a break was
+    # marked, false if the previous token was also a note (so they beam
+    # together), or nil when there is no prior note to beam against.
+    # Consumes the pending break and records that a note is now current.
+    def next_beam_break
+      flag = if @beam_break_pending
+        true
+      elsif @beam_last_was_note
+        false
+      end
+      @beam_break_pending = false
+      @beam_last_was_note = true
+      flag
+    end
+
+    # After a rest, bar line, volta, or voice change, the next note must
+    # not beam to whatever preceded the boundary.
+    def reset_beam_adjacency
+      @beam_last_was_note = false
+      @beam_break_pending = false
+    end
+
+    def tie_open?
+      @tie_open
+    end
+
+    def open_tie(line)
+      @tie_open = true
+      @tie_line = line
+    end
+
+    def close_tie
+      @tie_open = false
+      @tie_line = nil
+    end
+
+    # Buffers a note or chord as the pending note, flushing whatever was
+    # pending first. A broken-rhythm scale awaiting its right note, and any
+    # per-chord inner scale, fold into the buffered length. When a tie is
+    # open the arriving note instead extends the pending tie chain.
+    def defer_placement(pitches, length, inner_scale = ONE)
+      scale = (awaiting_scale || ONE) * inner_scale
+      self.awaiting_scale = nil
+      return tie_onto_pending(pitches, length, scale) if tie_open?
+
+      flush_pending_note
+      self.pending_note = PendingNote.new(
+        pitches: pitches, length: length, scale: scale, beam_break: next_beam_break
+      )
+    end
+
+    # Places the pending note onto the voice, if any, carrying its authored
+    # beam break onto the placement.
+    def flush_pending_note
+      pending = pending_note
+      return unless pending
+
+      self.pending_note = nil
+      placement = voice.place(voice.next_position, pending_rhythmic_value(pending), pending.pitches)
+      placement.beam_break_before = pending.beam_break
+    end
+
+    # Places a note, chord, or rest (nil pitches) directly onto the voice,
+    # bypassing the pending-note buffer.
+    def place(length, pitches, scale: ONE)
+      rhythmic_value = @duration_resolver.rhythmic_value(length, scale: scale)
+      voice.place(voice.next_position, rhythmic_value, pitches)
+    end
+
+    private
+
+    # Closes an open tie: the pending note becomes the new note's tied prefix,
+    # so the pair (and any longer chain) resolves to a single placement whose
+    # rhythmic value carries the author's chosen split.
+    def tie_onto_pending(pitches, length, scale)
+      pending = pending_note
+      ensure_tie_pitches_match(pending, pitches)
+      prefix = pending_rhythmic_value(pending)
+      close_tie
+      self.pending_note = PendingNote.new(
+        pitches: pitches, length: length, scale: scale, tied_prefix: prefix,
+        beam_break: pending.beam_break
+      )
+    end
+
+    def ensure_tie_pitches_match(pending, pitches)
+      return if pending.pitches.sort == pitches.sort
+
+      raise ParseError.new(
+        "A tie must connect two notes of the same pitch",
+        line_number: tie_line, snippet: "-"
+      )
+    end
+
+    # A pending note's own value, with any tied prefix appended ahead of
+    # it so the whole tie chain renders as one sounding note.
+    def pending_rhythmic_value(pending)
+      own = @duration_resolver.rhythmic_value(pending.length, scale: pending.scale)
+      prefix = pending.tied_prefix
+      prefix ? append_tied(prefix, own) : own
+    end
+
+    # Attaches `tail` at the deep end of `head`'s tied chain, rebuilding
+    # each link (RhythmicValue exposes no setter) so a chain like
+    # "half tied to eighth" gains a further "tied to quarter".
+    def append_tied(head, tail)
+      tied = head.tied_value
+      inner = tied ? append_tied(tied, tail) : tail
+      HeadMusic::Rudiment::RhythmicValue.new(head.unit, dots: head.dots, tied_value: inner)
+    end
+  end
+end

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

@@ -15,6 +15,8 @@ module HeadMusic::Notation::ABC
     UNIT_NOTE_LENGTH = Rational(1, 8)
     BARS_PER_LINE = 4
 
+    include HeadMusic::Notation::PlacementValidation
+
     attr_reader :composition, :reference_number
 
     def initialize(composition, reference_number: 1)
@@ -83,15 +85,27 @@ module HeadMusic::Notation::ABC
       [
         "X:#{reference_number}",
         "T:#{composition.name}",
-        composition.composer && "C:#{composition.composer}",
-        composition.origin && "O:#{composition.origin}",
+        optional_field("C", composition.composer),
+        optional_field("O", composition.origin),
         "M:#{composition.meter}",
-        "L:#{UNIT_NOTE_LENGTH.numerator}/#{UNIT_NOTE_LENGTH.denominator}",
-        # The parser requires K: to terminate the header.
-        "K:#{KeyMapper.abc_value(composition.key_signature)}"
+        unit_note_length_field,
+        key_field
       ].compact
     end
 
+    def optional_field(letter, value)
+      "#{letter}:#{value}" if value
+    end
+
+    def unit_note_length_field
+      "L:#{UNIT_NOTE_LENGTH.numerator}/#{UNIT_NOTE_LENGTH.denominator}"
+    end
+
+    def key_field
+      # The parser requires K: to terminate the header.
+      "K:#{KeyMapper.abc_value(composition.key_signature)}"
+    end
+
     def body_lines
       return [] if bar_strings.empty?
 
@@ -109,13 +123,34 @@ module HeadMusic::Notation::ABC
     def build_bar_strings
       pitch_writer = PitchWriter.new(composition.key_signature)
       duration_writer = DurationWriter.new(UNIT_NOTE_LENGTH)
-      bar_groups = placements.chunk_while do |previous, current|
-        previous.position.bar_number == current.position.bar_number
-      end
-      bar_groups.each_with_index.map do |bar_placements, index|
+      placements_by_bar.each_with_index.map do |bar_placements, index|
         # Accidental state must mirror what a re-parse accumulates bar by bar.
         pitch_writer.start_new_bar if index.positive?
-        bar_placements.map { |placement| token(placement, pitch_writer, duration_writer) }.join(" ")
+        render_bar(bar_placements, pitch_writer, duration_writer)
+      end
+    end
+
+    def placements_by_bar
+      placements.chunk_while do |previous, current|
+        previous.position.bar_number == current.position.bar_number
+      end
+    end
+
+    def render_bar(bar_placements, pitch_writer, duration_writer)
+      tokens = bar_placements.map { |placement| token(placement, pitch_writer, duration_writer) }
+      join_bar_tokens(bar_placements, tokens)
+    end
+
+    # Suppresses the inter-token space only where the following placement was
+    # authored as beamed to its predecessor (beam_break_before == false).
+    # A true or nil flag keeps the space, so programmatic (nil-flag)
+    # compositions render with today's every-token spacing. Every bar token
+    # (note, rest, or [..] chord) re-lexes unambiguously with no separator, so
+    # dropping the space is safe.
+    def join_bar_tokens(placements, tokens)
+      tokens.each_with_index.reduce(+"") do |line, (token, index)|
+        separator = (index.zero? || placements[index].beam_break_before == false) ? "" : " "
+        line << separator << token
       end
     end
 
@@ -137,12 +172,8 @@ module HeadMusic::Notation::ABC
       "[#{pitch_tokens.join}]#{multiplier}"
     end
 
-    def ensure_pitched_sounds(placement)
-      unpitched = placement.sounds.find { |sound| !sound.pitched? }
-      return unless unpitched
-
-      raise RenderError, "cannot render unpitched sound \"#{unpitched}\" at #{placement.position}: " \
-        "percussion rendering is not yet supported"
+    def render_error_class
+      RenderError
     end
   end
 end

data/lib/head_music/notation/dotted_duration.rb

@@ -0,0 +1,19 @@
+module HeadMusic
+  module Notation
+    # The exact fractional length of a (possibly dotted) rhythmic value in
+    # terms of its own unit. RhythmicValue's own value methods return Floats,
+    # so the fraction is rebuilt here from the unit's integer numerator and
+    # denominator to keep downstream arithmetic (ABC multipliers, MusicXML
+    # divisions) exact.
+    module DottedDuration
+      module_function
+
+      def dotted_unit_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 own unit.
+        Rational(unit.numerator, unit.denominator) * Rational((2**(dots + 1)) - 1, 2**dots)
+      end
+    end
+  end
+end

data/lib/head_music/notation/instrument_notation.rb

@@ -7,8 +7,13 @@ module HeadMusic::Notation; end
 # catalog entry with its own factory. Alternatives are recorded data only —
 # no selection behavior is implemented here (deferred to the Content layer).
 class HeadMusic::Notation::InstrumentNotation
+  include HeadMusic::ValueEquality
+
   attr_reader :instrument, :staves, :alternatives
 
+  value_equality :instrument, :staves_attributes
+  alias_method :eql?, :==
+
   def initialize(instrument:, data:)
     @instrument = instrument
     @staves = build_staves(data["staves"])
@@ -32,13 +37,6 @@ class HeadMusic::Notation::InstrumentNotation
     staves.length > 1
   end
 
-  def ==(other)
-    return false unless other.is_a?(self.class)
-
-    instrument == other.instrument && staves_attributes == other.staves_attributes
-  end
-  alias_method :eql?, :==
-
   def hash
     [instrument.name_key, staves_attributes].hash
   end