head_music 17.3.0 → 17.4.0

data/lib/head_music/analysis/pitch_collection.rb

@@ -6,15 +6,6 @@ module HeadMusic::Analysis; end
 # as distinct from a "pitch-class set" which abstracts away register and octave equivalence.
 # See also: PitchClassSet
 class HeadMusic::Analysis::PitchCollection
-  TERTIAN_SONORITIES = {
-    implied_triad: [3],
-    triad: [3, 5],
-    seventh_chord: [3, 5, 7],
-    ninth_chord: [2, 3, 5, 7],
-    eleventh_chord: [2, 3, 4, 5, 7],
-    thirteenth_chord: [2, 3, 4, 5, 6, 7] # a.k.a. diatonic scale
-  }.freeze
-
   attr_reader :pitches
 
   delegate :diatonic_intervals, to: :reduction, prefix: true
@@ -24,6 +15,17 @@ class HeadMusic::Analysis::PitchCollection
   delegate :heptachord?, :octachord?, :nonachord?, :decachord?, :undecachord?, :dodecachord?, to: :pitch_class_set
   delegate :size, to: :pitch_class_set, prefix: true
 
+  # Tertian chord classification (triad/seventh/extended, quality, inversion).
+  delegate(
+    :triad?, :consonant_triad?,
+    :major_triad?, :minor_triad?, :diminished_triad?, :augmented_triad?,
+    :root_position_triad?, :first_inversion_triad?, :second_inversion_triad?,
+    :seventh_chord?, :root_position_seventh_chord?, :first_inversion_seventh_chord?,
+    :second_inversion_seventh_chord?, :third_inversion_seventh_chord?,
+    :ninth_chord?, :eleventh_chord?, :thirteenth_chord?, :tertian?,
+    to: :chord_analysis
+  )
+
   def initialize(pitches)
     @pitches = pitches.map { |pitch| HeadMusic::Rudiment::Pitch.get(pitch) }.sort.uniq
   end
@@ -60,20 +62,17 @@ class HeadMusic::Analysis::PitchCollection
     # questions:
     # - should this be absolute? 0 = C?
     # - should there be both absolute and relative versions?
-    @integer_notation ||= begin
-      return [] if pitches.empty?
-      diatonic_intervals_above_bass_pitch.map { |interval| interval.semitones % 12 }.flatten.sort.unshift(0).uniq
-    end
+    @integer_notation ||= integer_notation_values
   end
 
   def invert
-    inverted_pitch = pitches[0] + HeadMusic::Analysis::DiatonicInterval.get("perfect octave")
+    inverted_pitch = pitches.first + octave
     new_pitches = pitches.drop(1) + [inverted_pitch]
     HeadMusic::Analysis::PitchCollection.new(new_pitches)
   end
 
   def uninvert
-    inverted_pitch = pitches[-1] - HeadMusic::Analysis::DiatonicInterval.get("perfect octave")
+    inverted_pitch = pitches.last - octave
     new_pitches = [inverted_pitch] + pitches[0..-2]
     HeadMusic::Analysis::PitchCollection.new(new_pitches)
   end
@@ -102,92 +101,6 @@ class HeadMusic::Analysis::PitchCollection
     pitches.length
   end
 
-  def triad?
-    trichord? && tertian?
-  end
-
-  def consonant_triad?
-    major_triad? || minor_triad?
-  end
-
-  TRIAD_PATTERNS = {
-    major: [%w[M3 m3], %w[m3 P4], %w[P4 M3]],
-    minor: [%w[m3 M3], %w[M3 P4], %w[P4 m3]],
-    diminished: [%w[m3 m3], %w[m3 A4], %w[A4 m3]],
-    augmented: [%w[M3 M3], %w[M3 d4], %w[d4 M3]]
-  }.freeze
-
-  def major_triad?
-    triad_type?(:major)
-  end
-
-  def minor_triad?
-    triad_type?(:minor)
-  end
-
-  def diminished_triad?
-    triad_type?(:diminished)
-  end
-
-  def augmented_triad?
-    triad_type?(:augmented)
-  end
-
-  def root_position_triad?
-    trichord? && reduction_diatonic_intervals.all?(&:third?)
-  end
-
-  def first_inversion_triad?
-    trichord? && reduction.uninvert.diatonic_intervals.all?(&:third?)
-  end
-
-  def second_inversion_triad?
-    trichord? && reduction.invert.diatonic_intervals.all?(&:third?)
-  end
-
-  def seventh_chord?
-    tetrachord? && tertian?
-  end
-
-  def root_position_seventh_chord?
-    tetrachord? && reduction_diatonic_intervals.all?(&:third?)
-  end
-
-  def first_inversion_seventh_chord?
-    tetrachord? && reduction.uninvert.diatonic_intervals.all?(&:third?)
-  end
-
-  def second_inversion_seventh_chord?
-    tetrachord? && reduction.uninvert.uninvert.diatonic_intervals.all?(&:third?)
-  end
-
-  def third_inversion_seventh_chord?
-    tetrachord? && reduction.invert.diatonic_intervals.all?(&:third?)
-  end
-
-  def ninth_chord?
-    pentachord? && tertian?
-  end
-
-  def eleventh_chord?
-    hexachord? && tertian?
-  end
-
-  def thirteenth_chord?
-    heptachord? && tertian?
-  end
-
-  def tertian?
-    return false unless diatonic_intervals.any?
-
-    inversion = reduction
-    pitches.length.times do
-      return true if TERTIAN_SONORITIES.value?(inversion.scale_degrees_above_bass_pitch)
-      inversion = inversion.invert
-    end
-    false
-  end
-
   def scale_degrees
     @scale_degrees ||= pitches.empty? ? [] : scale_degrees_above_bass_pitch.unshift(1)
   end
@@ -200,16 +113,29 @@ class HeadMusic::Analysis::PitchCollection
     @sonority ||= HeadMusic::Analysis::Sonority.new(self)
   end
 
+  def chord_analysis
+    @chord_analysis ||= HeadMusic::Analysis::ChordAnalysis.new(self)
+  end
+
   private
 
-  def triad_type?(type)
-    TRIAD_PATTERNS[type].include?(reduction_diatonic_intervals.map(&:shorthand))
+  def octave
+    @octave ||= HeadMusic::Analysis::DiatonicInterval.get("perfect octave")
+  end
+
+  def integer_notation_values
+    return [] if pitches.empty?
+
+    diatonic_intervals_above_bass_pitch.map { |interval| interval.semitones % 12 }.sort.unshift(0).uniq
   end
 
   def reduction_pitches
-    pitches.map do |pitch|
-      pitch = HeadMusic::Rudiment::Pitch.fetch_or_create(pitch.spelling, pitch.register - 1) while pitch > bass_pitch + 12
-      pitch
-    end.sort
+    pitches.map { |pitch| folded_into_reduction(pitch) }.sort
+  end
+
+  def folded_into_reduction(pitch)
+    ceiling = bass_pitch + 12
+    pitch = HeadMusic::Rudiment::Pitch.fetch_or_create(pitch.spelling, pitch.register - 1) while pitch > ceiling
+    pitch
   end
 end

data/lib/head_music/analysis/sonority.rb

@@ -73,6 +73,7 @@ class HeadMusic::Analysis::Sonority
   delegate :heptachord?, :octachord?, :nonachord?, :decachord?, :undecachord?, :dodecachord?, to: :pitch_collection
   delegate :pitch_class_set, :pitch_class_set_size, to: :pitch_collection
   delegate :scale_degrees_above_bass_pitch, to: :pitch_collection
+  delegate :triad?, :seventh_chord?, :tertian?, to: :pitch_collection
 
   def initialize(pitch_collection)
     @pitch_collection = pitch_collection
@@ -117,32 +118,13 @@ class HeadMusic::Analysis::Sonority
       root_position.diatonic_intervals_above_bass_pitch.all?(&:consonant?)
   end
 
-  def triad?
-    @triad ||= trichord? && tertian?
-  end
-
-  def seventh_chord?
-    @seventh_chord ||= tetrachord? && tertian?
-  end
-
-  def tertian?
-    @tertian ||= inversions.detect do |inversion|
-      inversion.diatonic_intervals.count(&:third?).to_f / inversion.diatonic_intervals.length > 0.5 ||
-        (scale_degrees_above_bass_pitch && [3, 5, 7]).length == 3
-    end
-  end
-
   def secundal?
-    @secundal ||= inversions.detect do |inversion|
-      inversion.diatonic_intervals.count(&:second?).to_f / inversion.diatonic_intervals.length > 0.5
-    end
+    @secundal ||= inversions.detect { |inversion| interval_ratio(inversion, &:second?) > 0.5 }
   end
 
   def quartal?
     @quartal ||= inversions.detect do |inversion|
-      inversion.diatonic_intervals.count do |interval|
-        interval.fourth? || interval.fifth?
-      end.to_f / inversion.diatonic_intervals.length > 0.5
+      interval_ratio(inversion) { |interval| interval.fourth? || interval.fifth? } > 0.5
     end
   end
   alias_method :quintal?, :quartal?
@@ -159,4 +141,12 @@ class HeadMusic::Analysis::Sonority
     other = self.class.new(other) if other.is_a?(HeadMusic::Analysis::PitchCollection)
     identifier == other.identifier
   end
+
+  private
+
+  # Fraction of an inversion's diatonic intervals that satisfy the given predicate.
+  def interval_ratio(inversion, &predicate)
+    intervals = inversion.diatonic_intervals
+    intervals.count(&predicate).to_f / intervals.length
+  end
 end

data/lib/head_music/content/composition/hash_deserializer.rb

@@ -0,0 +1,110 @@
+class HeadMusic::Content::Composition
+  # Rebuilds a composition from a schema v3 hash by replaying the public
+  # builder API in dependency order: meter and key changes first (position
+  # strings roll counts and ticks over via the meter map), then placements,
+  # then repeat flags (a pickup-bar flag needs its bar allocated), then
+  # comments. Raw values are validated at the boundary by SchemaValues so
+  # corrupted input raises ArgumentError with path context instead of
+  # silently deserializing wrong.
+  class HashDeserializer
+    def initialize(hash)
+      raise ArgumentError, "expected a Hash, got #{hash.class}" unless hash.is_a?(Hash)
+
+      @hash = hash.deep_transform_keys(&:to_s)
+      validate_schema_version
+    end
+
+    def composition
+      @composition ||= build_base_composition.tap do |composition|
+        apply_bar_changes(composition)
+        build_voices(composition)
+        apply_repeat_flags(composition)
+        add_comments(composition)
+      end
+    end
+
+    private
+
+    attr_reader :hash
+
+    def values
+      @values ||= SchemaValues.new
+    end
+
+    def validate_schema_version
+      version = hash["schema_version"]
+      return if version.is_a?(Integer) && version == SCHEMA_VERSION
+
+      message = "unsupported schema_version: #{version.inspect} (supported: #{SCHEMA_VERSION})"
+      if version == 2
+        message += "; migrate v2 \"pitches\" arrays to v3 \"sounds\" arrays " \
+          "(pitch strings unchanged; unpitched sounds are {\"unpitched\" => name_key} objects)"
+      end
+      raise ArgumentError, message
+    end
+
+    def build_base_composition
+      HeadMusic::Content::Composition.new(
+        name: hash["name"],
+        key_signature: values.key_signature(hash["key_signature"], "key_signature"),
+        meter: values.meter(hash["meter"], "meter"),
+        composer: hash["composer"],
+        origin: hash["origin"]
+      )
+    end
+
+    def bar_hashes
+      @bar_hashes ||= Array(hash["bars"])
+    end
+
+    def apply_bar_changes(composition)
+      bar_hashes.each_with_index do |bar_hash, index|
+        number = values.bar_number(bar_hash, index)
+        path = "bars[#{index}]"
+        key_signature = values.key_signature(bar_hash["key_signature"], path)
+        meter = values.meter(bar_hash["meter"], path)
+        composition.change_key_signature(number, key_signature) if key_signature
+        composition.change_meter(number, meter) if meter
+      end
+    end
+
+    def build_voices(composition)
+      Array(hash["voices"]).each_with_index do |voice_hash, voice_index|
+        voice = composition.add_voice(role: voice_hash["role"])
+        Array(voice_hash["placements"]).each_with_index do |placement_hash, placement_index|
+          path = "voices[#{voice_index}].placements[#{placement_index}]"
+          position = values.position(placement_hash["position"], path)
+          rhythmic_value = values.rhythmic_value(placement_hash["rhythmic_value"], path)
+          sounds = values.placement_sounds(placement_hash, path)
+          placement = voice.place(position, rhythmic_value, sounds)
+          placement.beam_break_before = placement_hash["beam_break_before"] if placement_hash.key?("beam_break_before")
+        end
+      end
+    end
+
+    def apply_repeat_flags(composition)
+      bar_hashes.each_with_index do |bar_hash, index|
+        next unless repeat_state?(bar_hash)
+
+        bar = composition.bars(values.bar_number(bar_hash, index)).last
+        bar.starts_repeat = true if bar_hash["starts_repeat"]
+        ends_repeat = bar_hash["ends_repeat_after_num_plays"]
+        bar.ends_repeat_after_num_plays = ends_repeat if ends_repeat
+        plays_on_passes = bar_hash["plays_on_passes"]
+        bar.plays_on_passes = plays_on_passes if plays_on_passes
+      end
+    end
+
+    def add_comments(composition)
+      Array(hash["comments"]).each_with_index do |comment_hash, index|
+        raw_position = comment_hash["position"]
+        position = values.position(raw_position, "comments[#{index}]") if raw_position
+        composition.add_comment(comment_hash["text"], position)
+      end
+    end
+
+    def repeat_state?(bar_hash)
+      bar_hash["starts_repeat"] || bar_hash["ends_repeat_after_num_plays"] || bar_hash["plays_on_passes"]
+    end
+  end
+end

data/lib/head_music/content/composition/schema_values.rb

@@ -0,0 +1,127 @@
+class HeadMusic::Content::Composition
+  # Validates and coerces raw schema values into domain objects for the
+  # HashDeserializer. Every method takes the raw value and the path it came
+  # from, returning a validated object or raising ArgumentError with that path
+  # context. Stateless: it holds no reference to the source hash, so the
+  # deserializer stays responsible for *where* values come from and this class
+  # for *what* a value is allowed to be.
+  class SchemaValues
+    # Position silently coerces garbage strings to "0:1:000", which would
+    # mislocate content with no error, so the shape is validated up front.
+    # Accepts "bar", "bar:count", or "bar:count:tick" with non-negative parts.
+    def position(value, path)
+      return nil if value.nil?
+
+      unless value.is_a?(String) && value.match?(/\A\d+(:\d+){0,2}\z/)
+        raise ArgumentError, "#{path}: unknown position #{value.inspect}"
+      end
+      value
+    end
+
+    # KeySignature.get returns a hollow object (nil tonic_spelling) for
+    # garbage rather than nil, so presence of the tonic is the real check.
+    def key_signature(value, path)
+      return nil if value.nil?
+
+      key_signature = begin
+        HeadMusic::Rudiment::KeySignature.get(value)
+      rescue
+        nil
+      end
+      unless key_signature&.tonic_spelling
+        raise ArgumentError, "#{path}: unknown key signature #{value.inspect}"
+      end
+      key_signature
+    end
+
+    def meter(value, path)
+      return nil if value.nil?
+
+      meter = begin
+        HeadMusic::Rudiment::Meter.get(value)
+      rescue
+        nil
+      end
+      unless meter&.top_number&.positive? && meter.bottom_number.positive?
+        raise ArgumentError, "#{path}: unknown meter #{value.inspect}"
+      end
+      meter
+    end
+
+    def rhythmic_value(value, path)
+      rhythmic_value = HeadMusic::Rudiment::RhythmicValue.get(value)
+      unless valid_rhythmic_value?(rhythmic_value)
+        raise ArgumentError, "#{path}: unknown rhythmic value #{value.inspect}"
+      end
+      rhythmic_value
+    end
+
+    # "sounds" is an array of sound data, empty for a rest. A pitched sound
+    # is a pitch string; an unpitched sound is a one-key
+    # {"unpitched" => name_key} hash. A nil element is never a rest, so it
+    # fails like any other unknown sound.
+    def placement_sounds(placement_hash, path)
+      values = placement_hash["sounds"]
+      unless values.is_a?(Array)
+        raise ArgumentError, "#{path}: sounds must be an Array, got #{values.inspect}"
+      end
+
+      values.each_with_index.map do |value, index|
+        sound(value, "#{path}.sounds[#{index}]")
+      end
+    end
+
+    def bar_number(bar_hash, index)
+      number = bar_hash["number"]
+      unless number.is_a?(Integer) && number >= 0
+        raise ArgumentError, "bars[#{index}]: bar number must be an Integer of at least 0, got #{number.inspect}"
+      end
+      number
+    end
+
+    private
+
+    # RhythmicValue.get returns a hollow object (nil unit) for garbage rather
+    # than nil, and a tied tail can be hollow while the head parses, so the
+    # whole tie chain is checked.
+    def valid_rhythmic_value?(rhythmic_value)
+      return false unless rhythmic_value.is_a?(HeadMusic::Rudiment::RhythmicValue)
+      return false unless rhythmic_value.unit
+
+      tied_value = rhythmic_value.tied_value
+      tied_value.nil? || valid_rhythmic_value?(tied_value)
+    end
+
+    # A value that fails to parse would otherwise silently deserialize as
+    # a rest.
+    def pitch(value, path)
+      pitch = HeadMusic::Rudiment::Pitch.get(value)
+      raise ArgumentError, "#{path}: unknown pitch #{value.inspect}" unless pitch
+
+      pitch
+    end
+
+    def sound(value, path)
+      return pitch(value, path) if value.is_a?(String)
+      return unpitched_sound(value, path) if value.is_a?(Hash)
+
+      raise ArgumentError, "#{path}: unknown sound #{value.inspect}"
+    end
+
+    # A nil name_key is the generic unpitched sound. A pitched instrument is
+    # a valid hit surface (a knock on a violin body is unpitched), so any
+    # catalog name or alias resolves.
+    def unpitched_sound(value, path)
+      unless value.keys == ["unpitched"]
+        raise ArgumentError, "#{path}: unknown sound #{value.inspect}"
+      end
+
+      name = value["unpitched"]
+      valid_name = name.nil? || (name.is_a?(String) && !name.empty?)
+      sound = HeadMusic::Rudiment::UnpitchedSound.get(name) if valid_name
+      raise ArgumentError, "#{path}: unknown instrument #{name.inspect}" unless sound
+
+      sound
+    end
+  end
+end

data/lib/head_music/content/composition.rb

@@ -142,220 +142,4 @@ class HeadMusic::Content::Composition
       {"number" => number}.merge(bar_hash)
     end
   end
-
-  # Rebuilds a composition from a schema v3 hash by replaying the public
-  # builder API in dependency order: meter and key changes first (position
-  # strings roll counts and ticks over via the meter map), then placements,
-  # then repeat flags (a pickup-bar flag needs its bar allocated), then
-  # comments. Validates values at the boundary so corrupted input raises
-  # ArgumentError with path context instead of silently deserializing wrong.
-  class HashDeserializer
-    def initialize(hash)
-      raise ArgumentError, "expected a Hash, got #{hash.class}" unless hash.is_a?(Hash)
-
-      @hash = hash.deep_transform_keys(&:to_s)
-      validate_schema_version
-    end
-
-    def composition
-      @composition ||= build_base_composition.tap do |composition|
-        apply_bar_changes(composition)
-        build_voices(composition)
-        apply_repeat_flags(composition)
-        add_comments(composition)
-      end
-    end
-
-    private
-
-    attr_reader :hash
-
-    def validate_schema_version
-      version = hash["schema_version"]
-      return if version.is_a?(Integer) && version == SCHEMA_VERSION
-
-      message = "unsupported schema_version: #{version.inspect} (supported: #{SCHEMA_VERSION})"
-      if version == 2
-        message += "; migrate v2 \"pitches\" arrays to v3 \"sounds\" arrays " \
-          "(pitch strings unchanged; unpitched sounds are {\"unpitched\" => name_key} objects)"
-      end
-      raise ArgumentError, message
-    end
-
-    def build_base_composition
-      HeadMusic::Content::Composition.new(
-        name: hash["name"],
-        key_signature: parsed_key_signature(hash["key_signature"], "key_signature"),
-        meter: parsed_meter(hash["meter"], "meter"),
-        composer: hash["composer"],
-        origin: hash["origin"]
-      )
-    end
-
-    def bar_hashes
-      @bar_hashes ||= Array(hash["bars"])
-    end
-
-    def apply_bar_changes(composition)
-      bar_hashes.each_with_index do |bar_hash, index|
-        number = validated_bar_number(bar_hash, index)
-        path = "bars[#{index}]"
-        key_signature = parsed_key_signature(bar_hash["key_signature"], path)
-        meter = parsed_meter(bar_hash["meter"], path)
-        composition.change_key_signature(number, key_signature) if key_signature
-        composition.change_meter(number, meter) if meter
-      end
-    end
-
-    def build_voices(composition)
-      Array(hash["voices"]).each_with_index do |voice_hash, voice_index|
-        voice = composition.add_voice(role: voice_hash["role"])
-        Array(voice_hash["placements"]).each_with_index do |placement_hash, placement_index|
-          path = "voices[#{voice_index}].placements[#{placement_index}]"
-          position = parsed_position(placement_hash["position"], path)
-          rhythmic_value = parsed_rhythmic_value(placement_hash["rhythmic_value"], path)
-          sounds = parsed_placement_sounds(placement_hash, path)
-          placement = voice.place(position, rhythmic_value, sounds)
-          placement.beam_break_before = placement_hash["beam_break_before"] if placement_hash.key?("beam_break_before")
-        end
-      end
-    end
-
-    def apply_repeat_flags(composition)
-      bar_hashes.each_with_index do |bar_hash, index|
-        next unless repeat_state?(bar_hash)
-
-        bar = composition.bars(validated_bar_number(bar_hash, index)).last
-        bar.starts_repeat = true if bar_hash["starts_repeat"]
-        bar.ends_repeat_after_num_plays = bar_hash["ends_repeat_after_num_plays"] if bar_hash["ends_repeat_after_num_plays"]
-        bar.plays_on_passes = bar_hash["plays_on_passes"] if bar_hash["plays_on_passes"]
-      end
-    end
-
-    def add_comments(composition)
-      Array(hash["comments"]).each_with_index do |comment_hash, index|
-        position = parsed_position(comment_hash["position"], "comments[#{index}]") if comment_hash["position"]
-        composition.add_comment(comment_hash["text"], position)
-      end
-    end
-
-    def repeat_state?(bar_hash)
-      bar_hash["starts_repeat"] || bar_hash["ends_repeat_after_num_plays"] || bar_hash["plays_on_passes"]
-    end
-
-    def validated_bar_number(bar_hash, index)
-      number = bar_hash["number"]
-      unless number.is_a?(Integer) && number >= 0
-        raise ArgumentError, "bars[#{index}]: bar number must be an Integer of at least 0, got #{number.inspect}"
-      end
-      number
-    end
-
-    # Position silently coerces garbage strings to "0:1:000", which would
-    # mislocate content with no error, so the shape is validated up front.
-    # Accepts "bar", "bar:count", or "bar:count:tick" with non-negative parts.
-    def parsed_position(value, path)
-      return nil if value.nil?
-
-      unless value.is_a?(String) && value.match?(/\A\d+(:\d+){0,2}\z/)
-        raise ArgumentError, "#{path}: unknown position #{value.inspect}"
-      end
-      value
-    end
-
-    # KeySignature.get returns a hollow object (nil tonic_spelling) for
-    # garbage rather than nil, so presence of the tonic is the real check.
-    def parsed_key_signature(value, path)
-      return nil if value.nil?
-
-      key_signature = begin
-        HeadMusic::Rudiment::KeySignature.get(value)
-      rescue
-        nil
-      end
-      unless key_signature&.tonic_spelling
-        raise ArgumentError, "#{path}: unknown key signature #{value.inspect}"
-      end
-      key_signature
-    end
-
-    def parsed_meter(value, path)
-      return nil if value.nil?
-
-      meter = begin
-        HeadMusic::Rudiment::Meter.get(value)
-      rescue
-        nil
-      end
-      unless meter&.top_number&.positive? && meter.bottom_number.positive?
-        raise ArgumentError, "#{path}: unknown meter #{value.inspect}"
-      end
-      meter
-    end
-
-    def parsed_rhythmic_value(value, path)
-      rhythmic_value = HeadMusic::Rudiment::RhythmicValue.get(value)
-      unless valid_rhythmic_value?(rhythmic_value)
-        raise ArgumentError, "#{path}: unknown rhythmic value #{value.inspect}"
-      end
-      rhythmic_value
-    end
-
-    # RhythmicValue.get returns a hollow object (nil unit) for garbage rather
-    # than nil, and a tied tail can be hollow while the head parses, so the
-    # whole tie chain is checked.
-    def valid_rhythmic_value?(rhythmic_value)
-      return false unless rhythmic_value.is_a?(HeadMusic::Rudiment::RhythmicValue)
-      return false unless rhythmic_value.unit
-
-      rhythmic_value.tied_value.nil? || valid_rhythmic_value?(rhythmic_value.tied_value)
-    end
-
-    # A value that fails to parse would otherwise silently deserialize as
-    # a rest.
-    def parsed_pitch(value, path)
-      pitch = HeadMusic::Rudiment::Pitch.get(value)
-      raise ArgumentError, "#{path}: unknown pitch #{value.inspect}" unless pitch
-
-      pitch
-    end
-
-    # "sounds" is an array of sound data, empty for a rest. A pitched sound
-    # is a pitch string; an unpitched sound is a one-key
-    # {"unpitched" => name_key} hash. A nil element is never a rest, so it
-    # fails like any other unknown sound.
-    def parsed_placement_sounds(placement_hash, path)
-      values = placement_hash["sounds"]
-      unless values.is_a?(Array)
-        raise ArgumentError, "#{path}: sounds must be an Array, got #{values.inspect}"
-      end
-
-      values.each_with_index.map do |value, index|
-        parsed_sound(value, "#{path}.sounds[#{index}]")
-      end
-    end
-
-    def parsed_sound(value, path)
-      return parsed_pitch(value, path) if value.is_a?(String)
-      return parsed_unpitched_sound(value, path) if value.is_a?(Hash)
-
-      raise ArgumentError, "#{path}: unknown sound #{value.inspect}"
-    end
-
-    # A nil name_key is the generic unpitched sound. A pitched instrument is
-    # a valid hit surface (a knock on a violin body is unpitched), so any
-    # catalog name or alias resolves.
-    def parsed_unpitched_sound(value, path)
-      unless value.keys == ["unpitched"]
-        raise ArgumentError, "#{path}: unknown sound #{value.inspect}"
-      end
-
-      name = value["unpitched"]
-      valid_name = name.nil? || (name.is_a?(String) && !name.empty?)
-      sound = HeadMusic::Rudiment::UnpitchedSound.get(name) if valid_name
-      raise ArgumentError, "#{path}: unknown instrument #{name.inspect}" unless sound
-
-      sound
-    end
-  end
 end