head_music 8.0.2 → 8.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59fd761fa9c441ada6674ebabb1e83c81991f21b20d2b29812160cf7d1bfd1f6
-  data.tar.gz: 6d7edeb8c3c8fbcd2abf3069860c7a31bc2c40cc95e38ef718d94ce2821a655d
+  metadata.gz: bf272cf25921ce289e80bbbfbb8566178b541ce8cdc4711feb269cb7863f0dd7
+  data.tar.gz: 35d4beef32b86a25376136dbaae5f2749ca13b22e2d359a6e83297fadfb6fca0
 SHA512:
-  metadata.gz: 605e82fb95ba7e5c91ca2f861bafbf9dd54e94ab02404382a2ae3293a943a85455dd26c40a46d6725fd26c0caeb89c898220d9b572c5a0b22c0bac0a172e31ce
-  data.tar.gz: 9a920c87fad466335f8b02cff76cd1a202c3a20d9d6e0bc53e91a93648406587e652f0dc47296063d40a26c2fa385a7250f3b6e955c9e99820c513ce97788540
+  metadata.gz: 169bdae2dc9223bee17d1dc5cb67baa2b3ea9c80a6a83df055e0ed1707b57ab14834b6193c8c2a03cb317532f243ea2f805a1be981987c5885ca88e08c725c73
+  data.tar.gz: 5bea0f2ff5883d4fd8b6d37bdcf1ea49d19469eb23b5da3f733e57524dbbb6299027f9a287b5e2d291f7813429088ba409d0fd045c80da66f482ab49d94ef472

data/lib/head_music/analysis/diatonic_interval.rb

@@ -66,10 +66,14 @@ class HeadMusic::Analysis::DiatonicInterval
     new(HeadMusic::Rudiment::Pitch.middle_c, higher_pitch)
   end
 
-  def initialize(pitch1, pitch2)
-    pitch1 = HeadMusic::Rudiment::Pitch.get(pitch1)
-    pitch2 = HeadMusic::Rudiment::Pitch.get(pitch2)
-    @lower_pitch, @higher_pitch = [pitch1, pitch2].sort
+  def initialize(first_pitch, second_pitch)
+    first_pitch = HeadMusic::Rudiment::Pitch.get(first_pitch)
+    second_pitch = HeadMusic::Rudiment::Pitch.get(second_pitch)
+    @lower_pitch, @higher_pitch = [first_pitch, second_pitch].sort
+  end
+
+  def spans?(pitch)
+    pitch >= lower_pitch && pitch <= higher_pitch
   end
 
   def quality

data/lib/head_music/analysis/melodic_interval.rb

@@ -1,43 +1,22 @@
 # A module for musical analysis
 module HeadMusic::Analysis; end
 
-# A melodic interval is the distance between one note and the next.
+# A melodic interval is the distance between two sequential pitches.
 class HeadMusic::Analysis::MelodicInterval
-  attr_reader :first_note, :second_note
+  attr_reader :first_pitch, :second_pitch
 
-  def initialize(note1, note2)
-    @first_note = note1
-    @second_note = note2
+  def initialize(first, second)
+    @first_pitch, @second_pitch = extract_pitches(first, second)
   end
 
   def diatonic_interval
     @diatonic_interval ||= HeadMusic::Analysis::DiatonicInterval.new(first_pitch, second_pitch)
   end
 
-  def position_start
-    first_note.position
-  end
-
-  def position_end
-    second_note.next_position
-  end
-
-  def notes
-    [first_note, second_note]
-  end
-
   def pitches
     [first_pitch, second_pitch]
   end
 
-  def first_pitch
-    @first_pitch ||= first_note.pitch
-  end
-
-  def second_pitch
-    @second_pitch ||= second_note.pitch
-  end
-
   def to_s
     [direction, diatonic_interval].join(" ")
   end
@@ -58,10 +37,6 @@ class HeadMusic::Analysis::MelodicInterval
     !moving?
   end
 
-  def spans?(pitch)
-    pitch.between?(low_pitch, high_pitch)
-  end
-
   def high_pitch
     pitches.max
   end
@@ -91,10 +66,18 @@ class HeadMusic::Analysis::MelodicInterval
   end
 
   def method_missing(method_name, *args, &block)
-    respond_to_missing?(method_name) ? diatonic_interval.send(method_name, *args, &block) : super
+    diatonic_interval.respond_to?(method_name) ? diatonic_interval.send(method_name, *args, &block) : super
   end
 
-  def respond_to_missing?(method_name, *_args)
-    diatonic_interval.respond_to?(method_name)
+  def respond_to_missing?(method_name, include_private = false)
+    diatonic_interval.respond_to?(method_name, include_private) || super
+  end
+
+  private
+
+  def extract_pitches(first, second)
+    first_pitch = first.respond_to?(:pitch) ? first.pitch : first
+    second_pitch = second.respond_to?(:pitch) ? second.pitch : second
+    [first_pitch, second_pitch]
   end
 end

data/lib/head_music/content/voice.rb

@@ -23,7 +23,7 @@ class HeadMusic::Content::Voice
   end
 
   def notes
-    @placements.select(&:note?)
+    @placements.select(&:note?).sort_by(&:position)
   end
 
   def notes_not_in_key
@@ -59,17 +59,23 @@ class HeadMusic::Content::Voice
     HeadMusic::Analysis::DiatonicInterval.new(lowest_pitch, highest_pitch)
   end
 
+  def melodic_note_pairs
+    @melodic_note_pairs ||= notes.each_cons(2).map do |note1, note2|
+      HeadMusic::Content::Voice::MelodicNotePair.new(note1, note2)
+    end
+  end
+
   def melodic_intervals
     @melodic_intervals ||=
-      notes.each_cons(2).map { |note_pair| HeadMusic::Analysis::MelodicInterval.new(*note_pair) }
+      melodic_note_pairs.map { |note_pair| HeadMusic::Analysis::MelodicInterval.new(*note_pair.notes) }
   end
 
   def leaps
-    melodic_intervals.select(&:leap?)
+    melodic_note_pairs.select(&:leap?)
   end
 
   def large_leaps
-    melodic_intervals.select(&:large_leap?)
+    melodic_note_pairs.select(&:large_leap?)
   end
 
   def cantus_firmus?
@@ -120,4 +126,43 @@ class HeadMusic::Content::Voice
   def pitches_string
     pitches.first(10).map(&:to_s).join(" ")
   end
+
+  class MelodicNotePair
+    attr_reader :first_note, :second_note
+
+    delegate(
+      :octave?, :unison?,
+      :perfect?,
+      :step?, :leap?, :large_leap?,
+      :ascending?, :descending?, :repetition?,
+      :spans?,
+      to: :melodic_interval
+    )
+
+    def initialize(first_note, second_note)
+      @first_note = first_note
+      @second_note = second_note
+    end
+
+    def notes
+      @notes ||= [first_note, second_note]
+    end
+
+    def pitches
+      @pitches ||= notes.map(&:pitch)
+    end
+
+    def melodic_interval
+      @melodic_interval ||= HeadMusic::Analysis::MelodicInterval.new(*notes)
+    end
+
+    def spells_consonant_triad_with?(other_note_pair)
+      return false if step? || other_note_pair.step?
+
+      combined_pitches = (pitches + other_note_pair.pitches).uniq
+      return false if combined_pitches.length < 3
+
+      HeadMusic::Analysis::PitchSet.new(combined_pitches).consonant_triad?
+    end
+  end
 end

data/lib/head_music/style/annotation.rb

@@ -10,6 +10,7 @@ class HeadMusic::Style::Annotation
     :lowest_pitch,
     :highest_notes,
     :lowest_notes,
+    :melodic_note_pairs,
     :melodic_intervals,
     :notes,
     :notes_not_in_key,

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

@@ -6,8 +6,8 @@ class HeadMusic::Style::Guidelines::AlwaysMove < HeadMusic::Style::Annotation
   MESSAGE = "Always move to a different note."
 
   def marks
-    melodic_intervals
-      .select { |interval| interval.perfect? && interval.unison? }
-      .map { |interval| HeadMusic::Style::Mark.for_all(interval.notes) }
+    melodic_note_pairs
+      .select { |pair| pair.perfect? && pair.unison? }
+      .map { |pair| HeadMusic::Style::Mark.for_all(pair.notes) }
   end
 end

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

@@ -6,7 +6,7 @@ class HeadMusic::Style::Guidelines::EndOnTonic < HeadMusic::Style::Annotation
   MESSAGE = "End on the first scale degree."
 
   def marks
-    HeadMusic::Style::Mark.for(notes.last) if notes.any? && !ends_on_tonic?
+    HeadMusic::Style::Mark.for(last_note) if notes.any? && !ends_on_tonic?
   end
 
   private

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

@@ -16,6 +16,6 @@ class HeadMusic::Style::Guidelines::LimitOctaveLeaps < HeadMusic::Style::Annotat
   private
 
   def octave_leaps
-    melodic_intervals.select(&:octave?)
+    melodic_note_pairs.select(&:octave?)
   end
 end

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

@@ -16,14 +16,14 @@ class HeadMusic::Style::Guidelines::MostlyConjunct < HeadMusic::Style::Annotatio
   private
 
   def marks_for_skips_and_leaps
-    melodic_intervals
+    melodic_note_pairs
       .reject(&:step?)
-      .map { |interval| HeadMusic::Style::Mark.for_all(interval.notes, fitness: HeadMusic::SMALL_PENALTY_FACTOR) }
+      .map { |note_pair| HeadMusic::Style::Mark.for_all(note_pair.notes, fitness: HeadMusic::SMALL_PENALTY_FACTOR) }
   end
 
   def conjunct_ratio
-    return 1 if melodic_intervals.empty?
+    return 1 if melodic_note_pairs.empty?
 
-    melodic_intervals.count(&:step?).to_f / melodic_intervals.length
+    melodic_note_pairs.count(&:step?).to_f / melodic_note_pairs.length
   end
 end

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

@@ -6,32 +6,48 @@ class HeadMusic::Style::Guidelines::PrepareOctaveLeaps < HeadMusic::Style::Annot
   MESSAGE = "Enter and exit an octave leap from within."
 
   def marks
-    (external_entries + external_exits + octave_ending).map do |trouble_spot|
+    external_entries_marks + external_exits_marks + octave_ending_marks
+  end
+
+  private
+
+  def external_entries_marks
+    external_entries.map do |trouble_spot|
       HeadMusic::Style::Mark.for_all(trouble_spot)
     end
   end
 
-  private
+  def external_exits_marks
+    external_exits.map do |trouble_spot|
+      HeadMusic::Style::Mark.for_all(trouble_spot)
+    end
+  end
+
+  def octave_ending_marks
+    return [] unless octave_ending?
+
+    [HeadMusic::Style::Mark.for_all(octave_ending)]
+  end
 
   def external_entries
-    melodic_intervals.each_cons(2).map do |pair|
+    melodic_note_pairs.each_cons(2).map do |pair|
       first, second = *pair
-      pair.map(&:notes).uniq if second.octave? && !second.spans?(first.first_note.pitch)
+      pair.map(&:notes).flatten.uniq if second.octave? && !second.spans?(first.pitches.first)
     end.compact
   end
 
   def external_exits
-    melodic_intervals.each_cons(2).map do |pair|
+    melodic_note_pairs.each_cons(2).map do |pair|
       first, second = *pair
-      pair.map(&:notes).uniq if first.octave? && !first.spans?(second.second_note.pitch)
+      pair.map(&:notes).flatten.uniq if first.octave? && !first.spans?(second.pitches.last)
     end.compact
   end
 
   def octave_ending
-    octave_ending? ? [melodic_intervals.last.notes] : []
+    octave_ending? ? melodic_note_pairs.last.notes : []
   end
 
   def octave_ending?
-    melodic_intervals.last&.octave?
+    melodic_note_pairs.last&.octave?
   end
 end

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

@@ -9,35 +9,35 @@ class HeadMusic::Style::Guidelines::RecoverLargeLeaps < HeadMusic::Style::Annota
   MESSAGE = "Recover large leaps by step in the opposite direction."
 
   def marks
-    melodic_intervals.each_cons(3).map do |intervals|
-      if unrecovered_leap?(intervals[0], intervals[1], intervals[2])
-        HeadMusic::Style::Mark.for_all(notes_in_intervals(intervals))
+    melodic_note_pairs.each_cons(3).map do |note_pairs|
+      if unrecovered_leap?(note_pairs[0], note_pairs[1], note_pairs[2])
+        HeadMusic::Style::Mark.for_all(notes_in_note_pairs(note_pairs))
       end
     end.compact
   end
 
   private
 
-  def notes_in_intervals(intervals)
-    (intervals[0].notes + intervals[1].notes).uniq
+  def notes_in_note_pairs(note_pairs)
+    (note_pairs[0].notes + note_pairs[1].notes).uniq
   end
 
-  def unrecovered_leap?(first_interval, second_interval, third_interval)
-    first_interval.large_leap? &&
-      !spelling_consonant_triad?(first_interval, second_interval, third_interval) &&
+  def unrecovered_leap?(first_note_pair, second_note_pair, third_note_pair)
+    first_note_pair.large_leap? &&
+      !spelling_consonant_triad?(first_note_pair, second_note_pair, third_note_pair) &&
       (
-        !direction_changed?(first_interval, second_interval) ||
-        !second_interval.step?
+        !direction_changed?(first_note_pair, second_note_pair) ||
+        !second_note_pair.step?
       )
   end
 
-  def spelling_consonant_triad?(first_interval, second_interval, third_interval)
-    first_interval.spells_consonant_triad_with?(second_interval) ||
-      second_interval.spells_consonant_triad_with?(third_interval)
+  def spelling_consonant_triad?(first_note_pair, second_note_pair, third_note_pair)
+    first_note_pair.spells_consonant_triad_with?(second_note_pair) ||
+      second_note_pair.spells_consonant_triad_with?(third_note_pair)
   end
 
-  def direction_changed?(first_interval, second_interval)
-    first_interval.ascending? && second_interval.descending? ||
-      first_interval.descending? && second_interval.ascending?
+  def direction_changed?(first_note_pair, second_note_pair)
+    first_note_pair.ascending? && second_note_pair.descending? ||
+      first_note_pair.descending? && second_note_pair.ascending?
   end
 end

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

@@ -9,14 +9,15 @@ class HeadMusic::Style::Guidelines::SingableIntervals < HeadMusic::Style::Annota
   MESSAGE = "Use only PU, m2, M2, m3, M3, P4, P5, m6 (ascending), P8 in the melodic line."
 
   def marks
-    melodic_intervals.reject { |interval| permitted?(interval) }.map do |unpermitted_interval|
-      HeadMusic::Style::Mark.for_all([unpermitted_interval.first_note, unpermitted_interval.second_note])
+    melodic_note_pairs.reject { |note_pair| permitted?(note_pair) }.map do |pair_with_unpermitted_interval|
+      HeadMusic::Style::Mark.for_all(pair_with_unpermitted_interval.notes)
     end
   end
 
   private
 
-  def permitted?(melodic_interval)
+  def permitted?(note_pair)
+    melodic_interval = note_pair.melodic_interval
     whitelist_for_interval(melodic_interval).include?(melodic_interval.shorthand)
   end
 

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

@@ -7,12 +7,12 @@ class HeadMusic::Style::Guidelines::SingleLargeLeaps < HeadMusic::Style::Guideli
 
   private
 
-  def unrecovered_leap?(first_interval, second_interval, third_interval)
-    return false unless first_interval.large_leap?
-    return false if spelling_consonant_triad?(first_interval, second_interval, third_interval)
-    return false if second_interval.step?
-    return false if second_interval.repetition?
+  def unrecovered_leap?(first_note_pair, second_note_pair, third_note_pair)
+    return false unless first_note_pair.large_leap?
+    return false if spelling_consonant_triad?(first_note_pair, second_note_pair, third_note_pair)
+    return false if second_note_pair.step?
+    return false if second_note_pair.repetition?
 
-    !direction_changed?(first_interval, second_interval) && second_interval.leap?
+    !direction_changed?(first_note_pair, second_note_pair) && second_note_pair.leap?
   end
 end

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

@@ -6,23 +6,23 @@ class HeadMusic::Style::Guidelines::StepOutOfUnison < HeadMusic::Style::Annotati
   MESSAGE = "Exit a unison by step."
 
   def marks
-    leaps_following_unisons.map do |skip|
-      HeadMusic::Style::Mark.for_all(skip.notes)
+    leaps_following_unisons.map do |note_pair|
+      HeadMusic::Style::Mark.for_all(note_pair.notes)
     end.flatten
   end
 
   private
 
   def leaps_following_unisons
-    melodic_intervals_following_unisons.select(&:leap?)
+    melodic_note_pairs_following_unisons.select(&:leap?)
   end
 
-  def melodic_intervals_following_unisons
-    @melodic_intervals_following_unisons ||=
+  def melodic_note_pairs_following_unisons
+    @melodic_note_pairs_following_unisons ||=
       perfect_unisons.map do |unison|
         note1 = voice.note_at(unison.position)
         note2 = voice.note_following(unison.position)
-        HeadMusic::Analysis::MelodicInterval.new(note1, note2) if note1 && note2
+        HeadMusic::Content::Voice::MelodicNotePair.new(note1, note2) if note1 && note2
       end.compact
   end
 

data/lib/head_music/version.rb

@@ -1,3 +1,3 @@
 module HeadMusic
-  VERSION = "8.0.2"
+  VERSION = "8.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: head_music
 version: !ruby/object:Gem::Version
-  version: 8.0.2
+  version: 8.1.0
 platform: ruby
 authors:
 - Rob Head
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-05-04 00:00:00.000000000 Z
+date: 2025-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport