head_music 11.8.0 → 12.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2683c0fce1a231c327156e69951df7590f9ba507a08643d9838bb7c67371dc4d
-  data.tar.gz: 120a035414104720af26cf0cdada21785da646f8827f4354f37c12e45c263f89
+  metadata.gz: c2be29f6b7e43ea3463fa98fba14bbdeea632fe94472df74b5c286b0952b322e
+  data.tar.gz: 5ec5d730b43357a8aa2283e3ea73d23596b21a983d5b9bc93e80bfd910eb8a92
 SHA512:
-  metadata.gz: 78fd1c9698ae12bf14e9db26131f4d642b241251a9f50ce29aabcf7c631888c2a558572977ed9240e26719b5f7feea28dd1274c2e3985eec0f1c7a922af2c5b7
-  data.tar.gz: 236fd7f24ee4a4ad073cca5dae89da522b62ba8d34601d75d40523ad274b9c427d210f34e933e145c055f8485ff2c7a03d780fa967892340c2c4ec67c7c016f6
+  metadata.gz: 17d1a2575d8b32a6c5ce22c4e522ca7c84bbcc6ffc66d22c3cd76d7af49d2c82628b096eeeee40e4d38def2eaeed5123a4281131c35b5eb432da680a08631eab
+  data.tar.gz: ccc33122bdadc8deccfd4258abebf7723fd12ec15dddeacc164529c4477dd69c0d5a575fe9c0a7251199c588e374896c1288a6991e883eb60893aa18443598f6

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    head_music (11.8.0)
+    head_music (12.0.0)
       activesupport (>= 7.0, < 10)
       humanize (~> 2.0)
       i18n (~> 1.8)

data/lib/head_music/analysis/dyad.rb

@@ -68,95 +68,59 @@ class HeadMusic::Analysis::Dyad
 
   private
 
-  def generate_possible_trichords
-    trichords = []
-    pitch_classes = [lower_pitch.pitch_class, upper_pitch.pitch_class]
-
-    HeadMusic::Rudiment::Spelling::CHROMATIC_SPELLINGS.each do |root_spelling|
-      root_pitch = HeadMusic::Rudiment::Pitch.get("#{root_spelling}4")
-
-      # Try all common trichord types from this root
-      trichord_intervals = [
-        %w[M3 P5],   # major triad
-        %w[m3 P5],   # minor triad
-        %w[m3 d5],   # diminished triad
-        %w[M3 A5],   # augmented triad
-        %w[P4 P5],   # sus4 (not a triad)
-        %w[M2 P5]    # sus2 (not a triad)
-      ]
-
-      trichord_intervals.each do |intervals|
-        trichord_pitches = [root_pitch]
-
-        # Each interval is FROM THE ROOT, not consecutive
-        intervals.each do |interval_name|
-          interval = HeadMusic::Analysis::DiatonicInterval.get(interval_name)
-          next_pitch = interval.above(root_pitch)
-          trichord_pitches << next_pitch
-        end
-
-        pitch_collection = HeadMusic::Analysis::PitchCollection.new(trichord_pitches)
-        trichord_pitch_classes = pitch_collection.pitch_classes
+  TRICHORD_INTERVALS = [
+    %w[M3 P5],   # major triad
+    %w[m3 P5],   # minor triad
+    %w[m3 d5],   # diminished triad
+    %w[M3 A5],   # augmented triad
+    %w[P4 P5],   # sus4 (not a triad)
+    %w[M2 P5]    # sus2 (not a triad)
+  ].freeze
+
+  SEVENTH_CHORD_INTERVALS = [
+    %w[M3 P5 M7],   # major seventh
+    %w[M3 P5 m7],   # dominant seventh (major-minor)
+    %w[m3 P5 m7],   # minor seventh
+    %w[m3 P5 M7],   # minor-major seventh
+    %w[m3 d5 m7],   # half-diminished seventh
+    %w[m3 d5 d7],   # diminished seventh
+    %w[M2 M3 P5 m7], # dominant ninth
+    %w[m2 M3 P5 m7], # dominant minor ninth
+    %w[M2 m3 P5 m7], # minor ninth
+    %w[M2 M3 P5 M7]  # major ninth
+  ].freeze
 
-        # Check if this trichord contains both pitches from our dyad
-        if pitch_classes.all? { |pc| trichord_pitch_classes.include?(pc) }
-          trichords << pitch_collection
-        end
-      end
-    end
-
-    trichords.uniq { |t| t.pitch_classes.sort.map(&:to_i) }
+  def generate_possible_trichords
+    generate_possible_chords(TRICHORD_INTERVALS)
   end
 
   def generate_possible_seventh_chords
-    seventh_chords = []
-    pitch_classes = [lower_pitch.pitch_class, upper_pitch.pitch_class]
+    generate_possible_chords(SEVENTH_CHORD_INTERVALS)
+  end
+
+  def generate_possible_chords(interval_sets)
+    dyad_pitch_classes = [lower_pitch.pitch_class, upper_pitch.pitch_class]
+    chords = []
 
     HeadMusic::Rudiment::Spelling::CHROMATIC_SPELLINGS.each do |root_spelling|
       root_pitch = HeadMusic::Rudiment::Pitch.get("#{root_spelling}4")
 
-      # Try all common seventh chord types from this root
-      seventh_chord_intervals = [
-        %w[M3 P5 M7],   # major seventh
-        %w[M3 P5 m7],   # dominant seventh (major-minor)
-        %w[m3 P5 m7],   # minor seventh
-        %w[m3 P5 M7],   # minor-major seventh
-        %w[m3 d5 m7],   # half-diminished seventh
-        %w[m3 d5 d7],   # diminished seventh
-        %w[M2 M3 P5 m7], # dominant ninth
-        %w[m2 M3 P5 m7], # dominant minor ninth
-        %w[M2 m3 P5 m7], # minor ninth
-        %w[M2 M3 P5 M7]  # major ninth
-      ]
-
-      seventh_chord_intervals.each do |intervals|
-        chord_pitches = [root_pitch]
-
-        # Each interval is FROM THE ROOT, not consecutive
-        intervals.each do |interval_name|
-          interval = HeadMusic::Analysis::DiatonicInterval.get(interval_name)
-          next_pitch = interval.above(root_pitch)
-          chord_pitches << next_pitch
-        end
-
+      interval_sets.each do |intervals|
+        chord_pitches = [root_pitch] + intervals.map { |name| HeadMusic::Analysis::DiatonicInterval.get(name).above(root_pitch) }
         pitch_collection = HeadMusic::Analysis::PitchCollection.new(chord_pitches)
-        chord_pitch_classes = pitch_collection.pitch_classes
 
-        # Check if this chord contains both pitches from our dyad
-        if pitch_classes.all? { |pc| chord_pitch_classes.include?(pc) }
-          seventh_chords << pitch_collection
+        if dyad_pitch_classes.all? { |pc| pitch_collection.pitch_classes.include?(pc) }
+          chords << pitch_collection
         end
       end
     end
 
-    seventh_chords.uniq { |c| c.pitch_classes.sort.map(&:to_i) }
+    chords.uniq { |chord| chord.pitch_classes.sort.map(&:to_i) }
   end
 
   def filter_by_key(pitch_collections)
     return pitch_collections unless key
 
-    diatonic_spellings = key.scale.spellings
-
     pitch_collections.select do |pitch_collection|
       pitch_collection.pitches.all? { |pitch| diatonic_spellings.include?(pitch.spelling) }
     end
@@ -165,65 +129,50 @@ class HeadMusic::Analysis::Dyad
   def sort_by_diatonic_agreement(pitch_collections)
     return pitch_collections unless key
 
-    diatonic_spellings = key.scale.spellings
-
     pitch_collections.sort_by do |pitch_collection|
-      # Count how many pitches match diatonic spellings (lower is better for sort)
-      diatonic_count = pitch_collection.pitches.count { |pitch| diatonic_spellings.include?(pitch.spelling) }
-      -diatonic_count # Negative so higher counts come first
+      -pitch_collection.pitches.count { |pitch| diatonic_spellings.include?(pitch.spelling) }
     end
   end
 
+  def diatonic_spellings
+    @diatonic_spellings ||= key.scale.spellings
+  end
+
   def generate_enharmonic_respellings
     respellings = []
 
     # Get enharmonic equivalents for each pitch
-    pitch1_equivalents = get_enharmonic_equivalents(pitch1)
-    pitch2_equivalents = get_enharmonic_equivalents(pitch2)
+    pitch1_equivalents = enharmonic_equivalents_for(pitch1)
+    pitch2_equivalents = enharmonic_equivalents_for(pitch2)
 
     # Generate all combinations
-    pitch1_equivalents.each do |p1|
-      pitch2_equivalents.each do |p2|
-        # Skip the original combination
-        next if p1.spelling == pitch1.spelling && p2.spelling == pitch2.spelling
+    pitch1_equivalents.each do |lower|
+      pitch2_equivalents.each do |upper|
+        next if lower.spelling == pitch1.spelling && upper.spelling == pitch2.spelling
 
-        # Create new dyad with same key context
-        respellings << self.class.new(p1, p2, key: key)
+        respellings << self.class.new(lower, upper, key: key)
       end
     end
 
     respellings
   end
 
-  def get_enharmonic_equivalents(pitch)
-    equivalents = [pitch]
+  ALTERATION_SIGNS = {-2 => "bb", -1 => "b", 0 => "", 1 => "#", 2 => "##"}.freeze
 
-    # Get common enharmonic spellings
-    pitch_class = pitch.pitch_class
-    letter_names = HeadMusic::Rudiment::LetterName.all
+  def enharmonic_equivalents_for(pitch)
+    target_pitch_class = pitch.pitch_class
+    equivalents = [pitch]
 
-    letter_names.each do |letter_name|
-      [-2, -1, 0, 1, 2].each do |alteration_semitones|
-        spelling = HeadMusic::Rudiment::Spelling.get("#{letter_name}#{alteration_sign(alteration_semitones)}")
-        next unless spelling
+    HeadMusic::Rudiment::LetterName.all.each do |letter_name|
+      ALTERATION_SIGNS.each_value do |sign|
+        spelling = HeadMusic::Rudiment::Spelling.get("#{letter_name}#{sign}")
+        next unless spelling && spelling.pitch_class == target_pitch_class
+        next if equivalents.any? { |equiv| equiv.spelling == spelling }
 
-        if spelling.pitch_class == pitch_class
-          equivalent_pitch = HeadMusic::Rudiment::Pitch.fetch_or_create(spelling, pitch.register)
-          equivalents << equivalent_pitch unless equivalents.any? { |p| p.spelling == spelling }
-        end
+        equivalents << HeadMusic::Rudiment::Pitch.fetch_or_create(spelling, pitch.register)
       end
     end
 
     equivalents
   end
-
-  def alteration_sign(semitones)
-    case semitones
-    when -2 then "bb"
-    when -1 then "b"
-    when 0 then ""
-    when 1 then "#"
-    when 2 then "##"
-    end
-  end
 end

data/lib/head_music/analysis/pitch_collection.rb

@@ -110,20 +110,27 @@ class HeadMusic::Analysis::PitchCollection
     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?
-    [%w[M3 m3], %w[m3 P4], %w[P4 M3]].include? reduction_diatonic_intervals.map(&:shorthand)
+    triad_type?(:major)
   end
 
   def minor_triad?
-    [%w[m3 M3], %w[M3 P4], %w[P4 m3]].include? reduction_diatonic_intervals.map(&:shorthand)
+    triad_type?(:minor)
   end
 
   def diminished_triad?
-    [%w[m3 m3], %w[m3 A4], %w[A4 m3]].include? reduction_diatonic_intervals.map(&:shorthand)
+    triad_type?(:diminished)
   end
 
   def augmented_triad?
-    [%w[M3 M3], %w[M3 d4], %w[d4 M3]].include? reduction_diatonic_intervals.map(&:shorthand)
+    triad_type?(:augmented)
   end
 
   def root_position_triad?
@@ -195,6 +202,10 @@ class HeadMusic::Analysis::PitchCollection
 
   private
 
+  def triad_type?(type)
+    TRIAD_PATTERNS[type].include?(reduction_diatonic_intervals.map(&:shorthand))
+  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

data/lib/head_music/content/voice.rb

@@ -60,8 +60,8 @@ class HeadMusic::Content::Voice
   end
 
   def melodic_note_pairs
-    @melodic_note_pairs ||= notes.each_cons(2).map do |note1, note2|
-      HeadMusic::Content::Voice::MelodicNotePair.new(note1, note2)
+    @melodic_note_pairs ||= notes.each_cons(2).map do |first_note, second_note|
+      HeadMusic::Content::Voice::MelodicNotePair.new(first_note, second_note)
     end
   end
 
@@ -135,6 +135,7 @@ class HeadMusic::Content::Voice
     pitches.first(10).map(&:to_s).join(" ")
   end
 
+  # A pair of consecutive notes in a melodic line, used to analyze intervals and leaps.
   class MelodicNotePair
     attr_reader :first_note, :second_note
 

data/lib/head_music/instruments/instrument.rb

@@ -1,3 +1,4 @@
+# A module for musical instruments and their properties
 module HeadMusic::Instruments; end
 
 # A musical instrument with parent-based inheritance.
@@ -36,15 +37,12 @@ class HeadMusic::Instruments::Instrument
     def get(name, variant_key = nil)
       return name if name.is_a?(self)
 
-      # Handle two-argument form for backward compatibility
+      name_str = name.to_s
       if variant_key
-        combined_name = "#{name}_#{variant_key}"
-        result = find_valid_instrument(combined_name) || find_valid_instrument(name.to_s)
+        find_valid_instrument("#{name_str}_#{variant_key}") || find_valid_instrument(name_str)
       else
-        result = find_valid_instrument(name.to_s) || find_valid_instrument(normalize_variant_name(name))
+        find_valid_instrument(name_str) || find_valid_instrument(normalize_variant_name(name_str))
       end
-
-      result
     end
 
     def find_valid_instrument(name)
@@ -63,24 +61,14 @@ class HeadMusic::Instruments::Instrument
     # Convert shorthand variant names to full form
     # e.g., "trumpet_in_eb" -> "trumpet_in_e_flat"
     # e.g., "clarinet_in_bb" -> "clarinet_in_b_flat"
-    def normalize_variant_name(name)
-      name_str = name.to_s
+    VARIANT_PATTERN = /^(.+)_in_([a-g])([b#])$/i
 
-      # Match patterns like "_in_eb" or "_in_bb" at the end (flat)
-      flat_pattern = /^(.+)_in_([a-g])b$/i
-      sharp_pattern = %r{^(.+)_in_([a-g])\#$}i
-
-      if name_str =~ flat_pattern
-        instrument = Regexp.last_match(1)
-        note = Regexp.last_match(2).downcase
-        "#{instrument}_in_#{note}_flat"
-      elsif name_str =~ sharp_pattern
-        instrument = Regexp.last_match(1)
-        note = Regexp.last_match(2).downcase
-        "#{instrument}_in_#{note}_sharp"
-      else
-        name_str
-      end
+    def normalize_variant_name(name_str)
+      match = VARIANT_PATTERN.match(name_str.to_s)
+      return name_str.to_s unless match
+
+      suffix = (match[3] == "b") ? "flat" : "sharp"
+      "#{match[1]}_in_#{match[2].downcase}_#{suffix}"
     end
   end
 
@@ -306,13 +294,14 @@ class HeadMusic::Instruments::Instrument
   def pitch_key_to_designation
     return nil unless pitch_key
 
-    key = pitch_key.to_s
-    if key.end_with?("_flat")
-      "#{key[0].upcase}b"
-    elsif key.end_with?("_sharp")
-      "#{key[0].upcase}#"
+    pitch_key_str = pitch_key.to_s
+    first_letter = pitch_key_str[0].upcase
+    if pitch_key_str.end_with?("_flat")
+      "#{first_letter}b"
+    elsif pitch_key_str.end_with?("_sharp")
+      "#{first_letter}#"
     else
-      key.upcase
+      pitch_key_str.upcase
     end
   end
 

data/lib/head_music/rudiment/pitch.rb

@@ -56,9 +56,10 @@ class HeadMusic::Rudiment::Pitch < HeadMusic::Rudiment::Base
   end
 
   def self.from_number(number)
-    return nil unless number == number.to_i
+    number_int = number.to_i
+    return nil unless number == number_int
 
-    fetch_or_create(HeadMusic::Rudiment::Spelling.from_number(number), (number.to_i / 12) - 1)
+    fetch_or_create(HeadMusic::Rudiment::Spelling.from_number(number), (number_int / 12) - 1)
   end
 
   def self.from_number_and_letter(number, letter_name)
@@ -71,9 +72,10 @@ class HeadMusic::Rudiment::Pitch < HeadMusic::Rudiment::Base
   end
 
   def self.natural_letter_pitch(number, letter_name)
+    number_int = number.to_i
     natural_letter_pitch = get(HeadMusic::Rudiment::LetterName.get(letter_name).pitch_class)
-    natural_letter_pitch += 12 while (number.to_i - natural_letter_pitch.to_i) >= 6
-    natural_letter_pitch -= 12 while (number.to_i - natural_letter_pitch.to_i) <= -6
+    natural_letter_pitch += 12 while (number_int - natural_letter_pitch.to_i) >= 6
+    natural_letter_pitch -= 12 while (number_int - natural_letter_pitch.to_i) <= -6
     get(natural_letter_pitch)
   end
 
@@ -218,9 +220,10 @@ class HeadMusic::Rudiment::Pitch < HeadMusic::Rudiment::Base
   end
 
   def helmholtz_letter_name
-    return spelling.to_s.downcase if HeadMusic::Rudiment::Register.get(register).helmholtz_case == :lower
+    spelling_str = spelling.to_s
+    return spelling_str.downcase if HeadMusic::Rudiment::Register.get(register).helmholtz_case == :lower
 
-    spelling.to_s
+    spelling_str
   end
 
   def helmholtz_marks

data/lib/head_music/rudiment/tuning/just_intonation.rb

@@ -21,26 +21,7 @@ class HeadMusic::Rudiment::Tuning::JustIntonation < HeadMusic::Rudiment::Tuning
     octave: Rational(2, 1)
   }.freeze
 
-  attr_reader :tonal_center
-
   def initialize(reference_pitch: :a440, tonal_center: nil)
-    super
-    @tonal_center = HeadMusic::Rudiment::Pitch.get(tonal_center || "C4")
-  end
-
-  def frequency_for(pitch)
-    pitch = HeadMusic::Rudiment::Pitch.get(pitch)
-
-    # Calculate the frequency of the tonal center using equal temperament from reference pitch
-    tonal_center_frequency = calculate_tonal_center_frequency
-
-    # Calculate the interval from the tonal center to the requested pitch
-    interval_from_tonal_center = (pitch - tonal_center).semitones
-
-    # Get the just intonation ratio for this interval
-    ratio = ratio_for_interval(interval_from_tonal_center)
-
-    # Calculate the frequency
-    tonal_center_frequency * ratio
+    super(reference_pitch: reference_pitch, tonal_center: tonal_center || "C4")
   end
 end

data/lib/head_music/rudiment/tuning/meantone.rb

@@ -23,26 +23,7 @@ class HeadMusic::Rudiment::Tuning::Meantone < HeadMusic::Rudiment::Tuning
     octave: Rational(2, 1)                              # Octave (2.0)
   }.freeze
 
-  attr_reader :tonal_center
-
   def initialize(reference_pitch: :a440, tonal_center: nil)
-    super
-    @tonal_center = HeadMusic::Rudiment::Pitch.get(tonal_center || "C4")
-  end
-
-  def frequency_for(pitch)
-    pitch = HeadMusic::Rudiment::Pitch.get(pitch)
-
-    # Calculate the frequency of the tonal center using equal temperament from reference pitch
-    tonal_center_frequency = calculate_tonal_center_frequency
-
-    # Calculate the interval from the tonal center to the requested pitch
-    interval_from_tonal_center = (pitch - tonal_center).semitones
-
-    # Get the meantone ratio for this interval
-    ratio = ratio_for_interval(interval_from_tonal_center)
-
-    # Calculate the frequency
-    tonal_center_frequency * ratio
+    super(reference_pitch: reference_pitch, tonal_center: tonal_center || "C4")
   end
 end

data/lib/head_music/rudiment/tuning/pythagorean.rb

@@ -27,26 +27,7 @@ class HeadMusic::Rudiment::Tuning::Pythagorean < HeadMusic::Rudiment::Tuning
     diminished_second: Rational(256, 243)     # Same as minor second in Pythagorean
   }.freeze
 
-  attr_reader :tonal_center
-
   def initialize(reference_pitch: :a440, tonal_center: nil)
-    super
-    @tonal_center = HeadMusic::Rudiment::Pitch.get(tonal_center || "C4")
-  end
-
-  def frequency_for(pitch)
-    pitch = HeadMusic::Rudiment::Pitch.get(pitch)
-
-    # Calculate the frequency of the tonal center using equal temperament from reference pitch
-    tonal_center_frequency = calculate_tonal_center_frequency
-
-    # Calculate the interval from the tonal center to the requested pitch
-    interval_from_tonal_center = (pitch - tonal_center).semitones
-
-    # Get the Pythagorean ratio for this interval
-    ratio = ratio_for_interval(interval_from_tonal_center)
-
-    # Calculate the frequency
-    tonal_center_frequency * ratio
+    super(reference_pitch: reference_pitch, tonal_center: tonal_center || "C4")
   end
 end

data/lib/head_music/rudiment/tuning.rb

@@ -23,18 +23,29 @@ class HeadMusic::Rudiment::Tuning < HeadMusic::Rudiment::Base
     end
   end
 
+  attr_reader :tonal_center
+
   def initialize(reference_pitch: :a440, tonal_center: nil)
     @reference_pitch = HeadMusic::Rudiment::ReferencePitch.get(reference_pitch)
-    @tonal_center = tonal_center
+    @tonal_center = tonal_center ? HeadMusic::Rudiment::Pitch.get(tonal_center) : nil
   end
 
   def frequency_for(pitch)
     pitch = HeadMusic::Rudiment::Pitch.get(pitch)
-    reference_pitch_frequency * (2**(1.0 / 12))**(pitch - reference_pitch.pitch).semitones
+    return equal_temperament_frequency(pitch) unless tonal_center
+
+    tonal_center_frequency = calculate_tonal_center_frequency
+    interval_from_tonal_center = (pitch - tonal_center).semitones
+    ratio = ratio_for_interval(interval_from_tonal_center)
+    tonal_center_frequency * ratio
   end
 
   private
 
+  def equal_temperament_frequency(pitch)
+    reference_pitch_frequency * (2**(1.0 / 12))**(pitch - reference_pitch.pitch).semitones
+  end
+
   def calculate_tonal_center_frequency
     # Use equal temperament to get the tonal center frequency from the reference pitch
     interval_to_tonal_center = (tonal_center - reference_pitch.pitch).semitones

data/lib/head_music/style/guidelines/directional_step_to_final_note.rb

@@ -0,0 +1,28 @@
+# Module for style guidelines.
+module HeadMusic::Style::Guidelines; end
+
+# Base class for guidelines requiring a step in a specific direction to the final note.
+class HeadMusic::Style::Guidelines::DirectionalStepToFinalNote < HeadMusic::Style::Annotation
+  def marks
+    return if last_melodic_interval.nil?
+
+    fitness = 1
+    fitness *= HeadMusic::PENALTY_FACTOR unless step?
+    fitness *= HeadMusic::PENALTY_FACTOR unless expected_direction?
+    HeadMusic::Style::Mark.for_all(notes[-2..], fitness: fitness) if fitness < 1
+  end
+
+  private
+
+  def expected_direction?
+    raise NotImplementedError
+  end
+
+  def step?
+    last_melodic_interval&.step?
+  end
+
+  def last_melodic_interval
+    @last_melodic_interval ||= melodic_intervals.last
+  end
+end

data/lib/head_music/style/guidelines/four_to_one.rb

@@ -2,26 +2,10 @@
 module HeadMusic::Style::Guidelines; end
 
 # A counterpoint guideline
-class HeadMusic::Style::Guidelines::FourToOne < HeadMusic::Style::Annotation
+class HeadMusic::Style::Guidelines::FourToOne < HeadMusic::Style::Guidelines::NoteCountPerBar
   MESSAGE = "Use four quarter notes against each whole note in the cantus firmus."
 
   QUARTER = HeadMusic::Rudiment::RhythmicValue.get(:quarter)
-  WHOLE = HeadMusic::Rudiment::RhythmicValue.get(:whole)
-
-  def marks
-    return [] unless cantus_firmus&.notes&.any?
-
-    cantus_firmus.notes.each_with_index.filter_map do |cf_note, index|
-      bar_number = cf_note.position.bar_number
-      if index == cantus_firmus.notes.length - 1
-        check_final_bar(bar_number)
-      elsif index == 0
-        check_first_bar(bar_number)
-      else
-        check_middle_bar(bar_number)
-      end
-    end
-  end
 
   private
 
@@ -42,49 +26,20 @@ class HeadMusic::Style::Guidelines::FourToOne < HeadMusic::Style::Annotation
     mark_bar(bar_number)
   end
 
-  def check_final_bar(bar_number)
-    bar_notes = notes_in_bar(bar_number)
-    return if one_whole_note?(bar_notes)
-
-    mark_bar(bar_number)
-  end
-
   def four_quarter_notes?(bar_notes)
-    bar_notes.length == 4 && bar_notes.all? { |n| n.rhythmic_value == QUARTER }
-  end
-
-  def one_whole_note?(bar_notes)
-    bar_notes.length == 1 && bar_notes.first.rhythmic_value == WHOLE
+    bar_notes.length == 4 && bar_notes.all? { |note| note.rhythmic_value == QUARTER }
   end
 
   def rest_then_three_quarter_notes?(bar_notes, bar_rests)
     bar_notes.length == 3 &&
-      bar_notes.all? { |n| n.rhythmic_value == QUARTER } &&
+      bar_notes.all? { |note| note.rhythmic_value == QUARTER } &&
       bar_rests.length == 1 &&
       bar_rests.first.rhythmic_value == QUARTER
   end
 
   def three_quarter_notes_after_downbeat?(bar_notes)
     bar_notes.length == 3 &&
-      bar_notes.all? { |n| n.rhythmic_value == QUARTER } &&
+      bar_notes.all? { |note| note.rhythmic_value == QUARTER } &&
       bar_notes.first.position.count > 1
   end
-
-  def notes_in_bar(bar_number)
-    notes.select { |n| n.position.bar_number == bar_number }
-  end
-
-  def rests_in_bar(bar_number)
-    rests.select { |r| r.position.bar_number == bar_number }
-  end
-
-  def mark_bar(bar_number)
-    bar_placements = notes_in_bar(bar_number)
-    if bar_placements.any?
-      HeadMusic::Style::Mark.for_all(bar_placements)
-    else
-      cf_note = cantus_firmus.notes.detect { |n| n.position.bar_number == bar_number }
-      HeadMusic::Style::Mark.for(cf_note) if cf_note
-    end
-  end
 end