head_music 8.0.2 → 8.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59fd761fa9c441ada6674ebabb1e83c81991f21b20d2b29812160cf7d1bfd1f6
-  data.tar.gz: 6d7edeb8c3c8fbcd2abf3069860c7a31bc2c40cc95e38ef718d94ce2821a655d
+  metadata.gz: 1d1ca0a4ee8274a955259afdd1c915e09fba454522157a1ef687f8760ec064ed
+  data.tar.gz: 902a3b6f27f50b2a8f354adb22cbcc460798f1916f760f475e9f6c1d6583cc93
 SHA512:
-  metadata.gz: 605e82fb95ba7e5c91ca2f861bafbf9dd54e94ab02404382a2ae3293a943a85455dd26c40a46d6725fd26c0caeb89c898220d9b572c5a0b22c0bac0a172e31ce
-  data.tar.gz: 9a920c87fad466335f8b02cff76cd1a202c3a20d9d6e0bc53e91a93648406587e652f0dc47296063d40a26c2fa385a7250f3b6e955c9e99820c513ce97788540
+  metadata.gz: e80f4d2337cabdf0cedd69bc0cb9ad54e73bd0f1a9774ccbfc2bcbe70b28d90899ff55debe9917dc5f62776e90ee7d09fd28530ea10fa28892ffc46e0d430c56
+  data.tar.gz: 3d278d05d015f73e25633e3de2ea47fc90c8d8c8377bd4dff6ba13772039e8cce6824288a98e05e2cf31080dfac4f3b8010d84895dc62f24080699574958f8df

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/locales/de.yml

@@ -291,6 +291,7 @@ de:
       scale: Tonleiter
       scale_degree: Tonleiterstufe
       scale_type: Tonleiterart
+      solfege: Solfège
       solmization: Solmisation
       sonority: Klangfarbe
       spelling: Schreibweise

data/lib/head_music/locales/es.yml

@@ -286,6 +286,7 @@ es:
       scale: escala
       scale_degree: grado de la escala
       scale_type: tipo de escala
+      solfege: solfeo
       solmization: solmización
       sonority: sonoridad
       spelling: notación

data/lib/head_music/locales/fr.yml

@@ -292,6 +292,7 @@ fr:
       scale: gamme
       scale_degree: degré de la gamme
       scale_type: type de gamme
+      solfege: solfège
       solmization: solmisation
       sonority: sonorité
       spelling: notation

data/lib/head_music/locales/it.yml

@@ -284,6 +284,7 @@ it:
       scale: scala
       scale_degree: grado della scala
       scale_type: tipo di scala
+      solfege: solfeggio
       solmization: solmizzazione
       sonority: sonorità
       spelling: notazione

data/lib/head_music/locales/ru.yml

@@ -232,6 +232,7 @@ ru:
       scale: гамма
       scale_degree: ступень гаммы
       scale_type: тип гаммы
+      solfege: сольфеджио
       solmization: сольмизация
       sonority: звучность
       spelling: обозначение

data/lib/head_music/rudiment/solmization.rb

@@ -1,8 +1,7 @@
 # A module for music rudiments
 module HeadMusic::Rudiment; end
 
-# A scale degree is a number indicating the ordinality of the spelling in the key signature.
-# TODO: Rewrite to accept a tonal_center and a scale type.
+# A solmization is the rendering of scale degrees as syllables.
 class HeadMusic::Rudiment::Solmization
   include HeadMusic::Named
 
@@ -34,20 +33,27 @@ class HeadMusic::Rudiment::Solmization
   def record_for_name(name)
     key = HeadMusic::Utilities::HashKey.for(name)
     RECORDS.detect do |record|
-      name_strings = record[:localized_names].map { |localized_name| localized_name[:name] }
+      name_strings = [record[:name]] + (record[:aliases] || []) + translation_aliases
       name_keys = name_strings.map { |name_string| HeadMusic::Utilities::HashKey.for(name_string) }
       name_keys.include?(key)
     end
   end
 
   def initialize_data_from_record(record)
+    self.name = record[:name]
     @syllables = record[:syllables]
-    initialize_localized_names(record[:localized_names])
   end
 
-  def initialize_localized_names(list)
-    @localized_names = (list || []).map do |name_attributes|
-      HeadMusic::Named::LocalizedName.new(**name_attributes.slice(:name, :locale_code, :abbreviation))
+  def translation_aliases
+    @translation_aliases ||= load_translation_aliases
+  end
+
+  def load_translation_aliases
+    aliases = []
+    I18n.config.available_locales.each do |locale|
+      translation = I18n.translate("head_music.rudiments.solfege", locale: locale, default: nil)
+      aliases << translation if translation && translation != 'solfege'
     end
+    aliases.compact.uniq
   end
 end

data/lib/head_music/rudiment/solmizations.yml

@@ -1,5 +1,6 @@
 ---
-- :syllables:
+- :name: solfège
+  :syllables:
   - do
   - re
   - mi
@@ -7,14 +8,7 @@
   - sol
   - la
   - ti
-  :localized_names:
-  - :name: solfège
-  - :name: solfège
-    :locale_code: en
-  - :name: solfège
-    :locale_code: fr
-  - :name: solfeggio
-    :locale_code: it
-  - :name: sol-fa
-  - :name: solfa
-  - :name: solfeo
+  :aliases:
+  - solfege
+  - sol-fa
+  - solfa

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.1"
 end

data/test_translations.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+# Test the translation loading functionality
+
+# First test - German translation of solfege
+result = system('bundle exec ruby -e "require \'head_music\'; puts HeadMusic::Rudiment::Solmization.get(\'Solfège\')&.name || \'nil\'"')
+puts "German 'Solfège' test: #{result}"
+
+# Second test - Italian translation
+result = system('bundle exec ruby -e "require \'head_music\'; puts HeadMusic::Rudiment::Solmization.get(\'solfeggio\')&.name || \'nil\'"')
+puts "Italian 'solfeggio' test: #{result}"
+
+# Third test - Russian translation
+result = system('bundle exec ruby -e "require \'head_music\'; puts HeadMusic::Rudiment::Solmization.get(\'сольфеджио\')&.name || \'nil\'"')
+puts "Russian 'сольфеджио' test: #{result}"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: head_music
 version: !ruby/object:Gem::Version
-  version: 8.0.2
+  version: 8.1.1
 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
@@ -225,6 +225,7 @@ files:
 - lib/head_music/style/mark.rb
 - lib/head_music/utilities/hash_key.rb
 - lib/head_music/version.rb
+- test_translations.rb
 homepage: https://github.com/roberthead/head_music
 licenses:
 - MIT