head_music 8.3.0 → 9.0.1

data/lib/head_music/rudiment/rhythmic_value/parser.rb

@@ -0,0 +1,77 @@
+class HeadMusic::Rudiment::RhythmicValue::Parser
+  attr_reader :identifier, :rhythmic_value
+
+  RhythmicUnit = HeadMusic::Rudiment::RhythmicUnit
+  RhythmicValue = HeadMusic::Rudiment::RhythmicValue
+
+  PATTERN = /((double|triple)\W?)?(dotted)?.?(#{HeadMusic::Rudiment::RhythmicUnit::PATTERN})/
+
+  # For stuff like the "q." in "q. = 108"
+  SHORTHAND_PATTERN = /\A(#{HeadMusic::Rudiment::RhythmicUnit::Parser::TEMPO_SHORTHAND_PATTERN})(\.*)?\z/i
+
+  # Parse a rhythmic value identifier and return a RhythmicValue object
+  # Returns nil if the identifier cannot be parsed
+  def self.parse(identifier)
+    return nil if identifier.nil?
+    new(identifier).rhythmic_value
+  end
+
+  def initialize(identifier)
+    @identifier = identifier.to_s.strip
+    parse_components
+  end
+
+  private
+
+  def parse_components
+    # First check for shorthand patterns like "q." to avoid infinite recursion
+    match = identifier.match(SHORTHAND_PATTERN)
+    if match && match[1]
+      unit_name = RhythmicUnit::Parser.parse(match[1].to_s.strip)
+      dots = match[2] ? match[2].strip.length : 0
+      @rhythmic_value = RhythmicValue.new(unit_name, dots: dots) if unit_name
+      return
+    end
+
+    # Try RhythmicUnit::Parser directly first (handles fractions, decimals, British names, etc.)
+    parser = RhythmicUnit::Parser.new(identifier)
+    if parser.american_name
+      @rhythmic_value = RhythmicValue.new(parser.american_name, dots: 0)
+      return
+    end
+
+    # Then try to parse with dots extracted for formats like "1/4."
+    # Count and strip dots (e.g., "1/4." -> "1/4" with 1 dot)
+    # But skip this if identifier looks like a decimal number
+    unless identifier.match?(/^\d+\.\d+$/)
+      dots = identifier.scan(".").count
+      base_identifier = identifier.gsub(".", "").strip
+
+      # Try RhythmicUnit::Parser on the base identifier
+      parser = RhythmicUnit::Parser.new(base_identifier)
+      if parser.american_name
+        @rhythmic_value = RhythmicValue.new(parser.american_name, dots: dots)
+        return
+      end
+    end
+
+    # Finally check the word pattern for things like "dotted quarter"
+    match = identifier.match(PATTERN)
+    if match
+      matched_string = match[0].to_s.strip
+      # Extract unit and dots from the matched string
+      unit_part = matched_string.gsub(/^\W*(double|triple)?\W*(dotted)?\W*/, "")
+      unit = RhythmicUnit.get(unit_part)
+      if unit
+        dots = if matched_string.include?("triple")
+          3
+        elsif matched_string.include?("double")
+          2
+        else
+          matched_string.include?("dotted") ? 1 : 0
+        end
+        @rhythmic_value = RhythmicValue.new(unit, dots: dots)
+      end
+    end
+  end
+end

data/lib/head_music/{content → rudiment}/rhythmic_value.rb

@@ -1,8 +1,12 @@
 # A module for musical content
-module HeadMusic::Content; end
+module HeadMusic::Rudiment; end
 
 # A rhythmic value is a duration composed of a rhythmic unit, any number of dots, and a tied value.
-class HeadMusic::Content::RhythmicValue
+class HeadMusic::Rudiment::RhythmicValue
+  include Comparable
+
+  RhythmicUnit = HeadMusic::Rudiment::RhythmicUnit
+
   attr_reader :unit, :dots, :tied_value
 
   delegate :name, to: :unit, prefix: true
@@ -10,13 +14,23 @@ class HeadMusic::Content::RhythmicValue
 
   def self.get(identifier)
     case identifier
-    when HeadMusic::Content::RhythmicValue
+    when HeadMusic::Rudiment::RhythmicValue
       identifier
     when HeadMusic::Rudiment::RhythmicUnit
       new(identifier)
     when Symbol, String
-      identifier = identifier.to_s.downcase.strip.gsub(/\W+/, "_")
-      from_words(identifier)
+      original_identifier = identifier.to_s.strip
+      # First try the new parser which handles all formats
+      parsed = Parser.parse(original_identifier)
+      return parsed if parsed
+
+      # Then try the word-based approach as fallback
+      identifier = original_identifier.downcase.gsub(/\W+/, "_")
+      begin
+        from_words(identifier)
+      rescue
+        nil
+      end
     end
   end
 
@@ -102,4 +116,8 @@ class HeadMusic::Content::RhythmicValue
   def to_s
     name.tr("_", "-")
   end
+
+  def <=>(other)
+    total_value <=> other.total_value
+  end
 end

data/lib/head_music/rudiment/scale.rb

@@ -2,13 +2,12 @@
 module HeadMusic::Rudiment; end
 
 # A scale contains ordered pitches starting at a tonal center.
-class HeadMusic::Rudiment::Scale
+class HeadMusic::Rudiment::Scale < HeadMusic::Rudiment::Base
   SCALE_REGEX = /^[A-G][#b]?\s+\w+$/
 
   def self.get(root_pitch, scale_type = nil)
-    root_pitch, scale_type = root_pitch.split(/\s+/) if root_pitch.is_a?(String) && scale_type =~ SCALE_REGEX
     root_pitch = HeadMusic::Rudiment::Pitch.get(root_pitch)
-    scale_type = HeadMusic::Rudiment::ScaleType.get(scale_type || :major)
+    scale_type = HeadMusic::Rudiment::ScaleType.get(scale_type || HeadMusic::Rudiment::ScaleType::DEFAULT)
     @scales ||= {}
     hash_key = HeadMusic::Utilities::HashKey.for(
       [root_pitch, scale_type].join(" ").gsub(/#|♯/, "sharp").gsub(/(\w)[b♭]/, '\\1flat')
@@ -36,7 +35,7 @@ class HeadMusic::Rudiment::Scale
   end
 
   def spellings(direction: :ascending, octaves: 1)
-    pitches(direction: direction, octaves: octaves).map(&:spelling).map(&:to_s)
+    pitches(direction: direction, octaves: octaves).map(&:spelling)
   end
 
   def pitch_names(direction: :ascending, octaves: 1)
@@ -83,7 +82,7 @@ class HeadMusic::Rudiment::Scale
   end
 
   def parent_scale_pitches
-    HeadMusic::Rudiment::Scale.get(root_pitch, scale_type.parent_name).pitches if scale_type.parent
+    HeadMusic::Rudiment::Scale.get(root_pitch, scale_type.parent_name).pitches
   end
 
   def parent_scale_pitch_for(semitones_from_root)

data/lib/head_music/rudiment/scale_degree.rb

@@ -3,7 +3,7 @@ module HeadMusic::Rudiment; end
 
 # A scale degree is a number indicating the ordinality of the spelling in the key.
 # TODO: Rewrite to accept a tonal_center and a scale type.
-class HeadMusic::Rudiment::ScaleDegree
+class HeadMusic::Rudiment::ScaleDegree < HeadMusic::Rudiment::Base
   include Comparable
 
   NAME_FOR_DIATONIC_DEGREE = [nil, "tonic", "supertonic", "mediant", "subdominant", "dominant", "submediant"].freeze

data/lib/head_music/rudiment/scale_type.rb

@@ -2,9 +2,13 @@
 module HeadMusic::Rudiment; end
 
 # A ScaleType represents a particular scale pattern, such as major, lydian, or minor pentatonic.
-class HeadMusic::Rudiment::ScaleType
-  H = 1 # whole step
-  W = 2 # half step
+class HeadMusic::Rudiment::ScaleType < HeadMusic::Rudiment::Base
+  # TODO: load scale types from yaml configuration file
+  # Include a system of aliasing, e.g. :natural_minor, :aeolian
+  # Include ascending and descending intervals for scales that differ
+
+  H = 1 # half step
+  W = 2 # whole step
 
   # Modal
   I = [W, W, H, W, W, W, H].freeze
@@ -33,6 +37,8 @@ class HeadMusic::Rudiment::ScaleType
 
   MINOR_PENTATONIC = [3, 2, 2, 3, 2].freeze
 
+  DEFAULT = :major
+
   def self._modes
     {}.tap do |modes|
       MODE_NAMES.each do |roman_numeral, aliases|

data/lib/head_music/rudiment/solmization.rb

@@ -2,7 +2,7 @@
 module HeadMusic::Rudiment; end
 
 # A solmization is the rendering of scale degrees as syllables.
-class HeadMusic::Rudiment::Solmization
+class HeadMusic::Rudiment::Solmization < HeadMusic::Rudiment::Base
   include HeadMusic::Named
 
   DEFAULT_SOLMIZATION = "solfège"

data/lib/head_music/rudiment/spelling.rb

@@ -4,8 +4,11 @@ module HeadMusic::Rudiment; end
 # Represents the spelling of a pitch, such as C# or Db.
 # Composite of a LetterName and an optional Alteration.
 # Does not include the octave. See Pitch for that.
-class HeadMusic::Rudiment::Spelling
-  MATCHER = /^\s*([A-G])(#{HeadMusic::Rudiment::Alteration.matcher}?)(-?\d+)?\s*$/i
+class HeadMusic::Rudiment::Spelling < HeadMusic::Rudiment::Base
+  LetterName = HeadMusic::Rudiment::LetterName
+  Alteration = HeadMusic::Rudiment::Alteration
+
+  MATCHER = /^\s*(#{LetterName::PATTERN})(#{Alteration::PATTERN})?(-?\d+)?\s*$/i
 
   attr_reader :pitch_class, :letter_name, :alteration
 
@@ -86,8 +89,6 @@ class HeadMusic::Rudiment::Spelling
     !alteration || alteration.natural?
   end
 
-  private_class_method :new
-
   private
 
   def enharmonic_equivalence

data/lib/head_music/rudiment/tempo.rb

@@ -0,0 +1,85 @@
+module HeadMusic::Rudiment; end
+
+# Represents a musical tempo with a beat value and beats per minute
+class HeadMusic::Rudiment::Tempo
+  SECONDS_PER_MINUTE = 60
+  NANOSECONDS_PER_SECOND = 1_000_000_000
+  NANOSECONDS_PER_MINUTE = (NANOSECONDS_PER_SECOND * SECONDS_PER_MINUTE).freeze
+
+  attr_reader :beat_value, :beats_per_minute
+
+  delegate :ticks, to: :beat_value, prefix: true
+  alias_method :ticks_per_beat, :beat_value_ticks
+
+  NAMED_TEMPO_DEFAULTS = {
+    larghissimo: ["quarter", 24],       # 24–40 bpm
+    adagissimo: ["quarter", 32],        # 24–40 bpm
+    grave: ["quarter", 32],             # 24–40 bpm
+    largo: ["quarter", 54],             # 40–66 bpm
+    larghetto: ["quarter", 54],         # 44–66 bpm
+    adagio: ["quarter", 60],            # 44–66 bpm
+    adagietto: ["quarter", 68],         # 46–80 bpm
+    lento: ["quarter", 72],             # 52–108 bpm
+    marcia_moderato: ["quarter", 72],   # 66–80 bpm
+    andante: ["quarter", 78],           # 56–108 bpm
+    andante_moderato: ["quarter", 88],  # 80–108 bpm
+    andantino: ["quarter", 92],         # 80–108 bpm
+    moderato: ["quarter", 108],         # 108–120 bpm
+    allegretto: ["quarter", 112],       # 112–120 bpm
+    allegro_moderato: ["quarter", 116], # 116–120 bpm
+    allegro: ["quarter", 120],          # 120–156 bpm
+    molto_allegro: ["quarter", 132],    # 124–156 bpm
+    allegro_vivace: ["quarter", 132],   # 124–156 bpm
+    vivace: ["quarter", 156],           # 156–176 bpm
+    vivacissimo: ["quarter", 172],      # 172–176 bpm
+    allegrissimo: ["quarter", 172],     # 172–176 bpm
+    presto: ["quarter", 180],           # 168–200 bpm
+    prestissimo: ["quarter", 200]      # 200 bpm and over
+  }
+
+  def self.get(identifier)
+    @tempos ||= {}
+    key = HeadMusic::Utilities::HashKey.for(identifier)
+    if NAMED_TEMPO_DEFAULTS.key?(identifier.to_s.to_sym)
+      beat_value, beats_per_minute = NAMED_TEMPO_DEFAULTS[identifier.to_s.to_sym]
+      @tempos[key] ||= new(beat_value, beats_per_minute)
+    elsif identifier.to_s.match?(/=|at/)
+      parts = identifier.to_s.split(/\s*(=|at)\s*/)
+      unit = parts[0]
+      bpm = parts[2] || parts[1]  # Handle both "q = 120" and "q at 120bpm"
+      bpm_value = bpm.to_s.gsub(/[^0-9]/, "").to_i
+      @tempos[key] ||= new(standardized_unit(unit), bpm_value)
+    else
+      @tempos[key] ||= new("quarter", 120)
+    end
+    @tempos[key]
+  end
+
+  def initialize(beat_value, beats_per_minute)
+    @beat_value = HeadMusic::Rudiment::RhythmicValue.get(beat_value)
+    @beats_per_minute = beats_per_minute.to_f
+  end
+
+  def beat_duration_in_seconds
+    @beat_duration_in_seconds ||=
+      SECONDS_PER_MINUTE / beats_per_minute
+  end
+
+  def beat_duration_in_nanoseconds
+    @beat_duration_in_nanoseconds ||=
+      NANOSECONDS_PER_MINUTE / beats_per_minute
+  end
+
+  def tick_duration_in_nanoseconds
+    @tick_duration_in_nanoseconds ||=
+      beat_duration_in_nanoseconds / ticks_per_beat
+  end
+
+  def self.standardized_unit(unit)
+    return "quarter" if unit.nil?
+
+    # Use RhythmicValue parser to handle all formats (shorthand, fractions, British names, dots, etc.)
+    rhythmic_value = HeadMusic::Rudiment::RhythmicValue.get(unit)
+    rhythmic_value&.unit ? rhythmic_value.to_s : "quarter"
+  end
+end

data/lib/head_music/rudiment/tonal_context.rb

@@ -0,0 +1,35 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
+# Abstract base class representing a tonal context (system of pitches with a tonal center)
+class HeadMusic::Rudiment::TonalContext < HeadMusic::Rudiment::Base
+  attr_reader :tonic_spelling
+
+  def initialize(tonic_spelling)
+    @tonic_spelling = HeadMusic::Rudiment::Spelling.get(tonic_spelling)
+  end
+
+  def tonic_pitch(octave = 4)
+    HeadMusic::Rudiment::Pitch.get("#{tonic_spelling}#{octave}")
+  end
+
+  def scale
+    raise NotImplementedError, "Subclasses must implement #scale"
+  end
+
+  def pitches(octave = nil)
+    scale.pitches(direction: :ascending, octaves: 1)
+  end
+
+  def pitch_classes
+    scale.pitch_classes
+  end
+
+  def spellings
+    scale.spellings
+  end
+
+  def key_signature
+    raise NotImplementedError, "Subclasses must implement #key_signature"
+  end
+end

data/lib/head_music/rudiment/tuning.rb

@@ -3,7 +3,7 @@ module HeadMusic::Rudiment; end
 
 # A tuning has a reference pitch and frequency and provides frequencies for all pitches
 # The base class assumes equal temperament tuning. By default, A4 = 440.0 Hz
-class HeadMusic::Rudiment::Tuning
+class HeadMusic::Rudiment::Tuning < HeadMusic::Rudiment::Base
   attr_accessor :reference_pitch
 
   delegate :pitch, :frequency, to: :reference_pitch, prefix: true

data/lib/head_music/rudiment/unpitched_note.rb

@@ -0,0 +1,62 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
+# An UnpitchedNote represents a percussion note with rhythm but no specific pitch.
+# It inherits from RhythmicElement and can optionally have an instrument name.
+class HeadMusic::Rudiment::UnpitchedNote < HeadMusic::Rudiment::RhythmicElement
+  include HeadMusic::Named
+
+  attr_reader :instrument_name
+
+  # Make new public for this concrete class
+  public_class_method :new
+
+  def self.get(rhythmic_value, instrument: nil)
+    return rhythmic_value if rhythmic_value.is_a?(HeadMusic::Rudiment::UnpitchedNote)
+
+    rhythmic_value = HeadMusic::Rudiment::RhythmicValue.get(rhythmic_value)
+    return nil unless rhythmic_value
+
+    fetch_or_create(rhythmic_value, instrument)
+  end
+
+  def self.fetch_or_create(rhythmic_value, instrument_name)
+    @unpitched_notes ||= {}
+    hash_key = [rhythmic_value.to_s, instrument_name].compact.join("_")
+    @unpitched_notes[hash_key] ||= new(rhythmic_value, instrument_name)
+  end
+
+  def initialize(rhythmic_value, instrument_name = nil)
+    super(rhythmic_value)
+    @instrument_name = instrument_name
+  end
+
+  def name
+    if instrument_name
+      "#{rhythmic_value} #{instrument_name}"
+    else
+      "#{rhythmic_value} unpitched note"
+    end
+  end
+
+  # Override with_rhythmic_value to preserve instrument
+  def with_rhythmic_value(new_rhythmic_value)
+    self.class.get(new_rhythmic_value, instrument: instrument_name)
+  end
+
+  # Create a new unpitched note with a different instrument
+  def with_instrument(new_instrument_name)
+    self.class.get(rhythmic_value, instrument: new_instrument_name)
+  end
+
+  def ==(other)
+    return false unless other.is_a?(self.class)
+    rhythmic_value == other.rhythmic_value && instrument_name == other.instrument_name
+  end
+
+  def sounded?
+    true
+  end
+
+  private_class_method :fetch_or_create
+end

data/lib/head_music/style/medieval_tradition.rb

@@ -0,0 +1,26 @@
+# Medieval tradition for interval consonance classification
+class HeadMusic::Style::MedievalTradition < HeadMusic::Style::Tradition
+  def consonance_classification(interval)
+    interval_mod = interval.simple_semitones
+
+    # Check for augmented or diminished intervals
+    if interval.augmented? || interval.diminished?
+      return HeadMusic::Rudiment::Consonance::DISSONANCE
+    end
+
+    case interval_mod
+    when 0, 12  # Unison, Octave
+      HeadMusic::Rudiment::Consonance::PERFECT_CONSONANCE
+    when 7      # Perfect Fifth
+      HeadMusic::Rudiment::Consonance::PERFECT_CONSONANCE
+    when 5      # Perfect Fourth - consonant in medieval music
+      HeadMusic::Rudiment::Consonance::PERFECT_CONSONANCE
+    when 3, 4   # Minor Third, Major Third
+      HeadMusic::Rudiment::Consonance::IMPERFECT_CONSONANCE
+    when 8, 9   # Minor Sixth, Major Sixth
+      HeadMusic::Rudiment::Consonance::IMPERFECT_CONSONANCE
+    else
+      HeadMusic::Rudiment::Consonance::DISSONANCE
+    end
+  end
+end

data/lib/head_music/style/modern_tradition.rb

@@ -0,0 +1,34 @@
+# Modern/standard practice tradition for interval consonance classification
+class HeadMusic::Style::ModernTradition < HeadMusic::Style::Tradition
+  def consonance_classification(interval)
+    interval_mod = interval.simple_semitones
+
+    # Check for augmented or diminished intervals (except diminished fifth/augmented fourth)
+    if (interval.augmented? || interval.diminished?) && interval_mod != 6
+      return HeadMusic::Rudiment::Consonance::DISSONANCE
+    end
+
+    case interval_mod
+    when 0, 12  # Unison, Octave
+      HeadMusic::Rudiment::Consonance::PERFECT_CONSONANCE
+    when 7      # Perfect Fifth
+      HeadMusic::Rudiment::Consonance::PERFECT_CONSONANCE
+    when 3, 4   # Minor Third, Major Third
+      HeadMusic::Rudiment::Consonance::IMPERFECT_CONSONANCE
+    when 8, 9   # Minor Sixth, Major Sixth
+      HeadMusic::Rudiment::Consonance::IMPERFECT_CONSONANCE
+    when 5      # Perfect Fourth
+      # In standard practice, perfect fourth is considered consonant
+      # but contextual would be more accurate
+      HeadMusic::Rudiment::Consonance::PERFECT_CONSONANCE
+    when 2, 10  # Major Second, Minor Seventh
+      HeadMusic::Rudiment::Consonance::MILD_DISSONANCE
+    when 1, 11  # Minor Second, Major Seventh
+      HeadMusic::Rudiment::Consonance::HARSH_DISSONANCE
+    when 6      # Tritone (Aug 4th/Dim 5th)
+      HeadMusic::Rudiment::Consonance::DISSONANCE
+    else
+      HeadMusic::Rudiment::Consonance::DISSONANCE
+    end
+  end
+end

data/lib/head_music/style/renaissance_tradition.rb

@@ -0,0 +1,26 @@
+# Renaissance counterpoint tradition for interval consonance classification
+class HeadMusic::Style::RenaissanceTradition < HeadMusic::Style::Tradition
+  def consonance_classification(interval)
+    interval_mod = interval.simple_semitones
+
+    # Check for augmented or diminished intervals
+    if interval.augmented? || interval.diminished?
+      return HeadMusic::Rudiment::Consonance::DISSONANCE
+    end
+
+    case interval_mod
+    when 0, 12  # Unison, Octave
+      HeadMusic::Rudiment::Consonance::PERFECT_CONSONANCE
+    when 7      # Perfect Fifth
+      HeadMusic::Rudiment::Consonance::PERFECT_CONSONANCE
+    when 3, 4   # Minor Third, Major Third
+      HeadMusic::Rudiment::Consonance::IMPERFECT_CONSONANCE
+    when 8, 9   # Minor Sixth, Major Sixth
+      HeadMusic::Rudiment::Consonance::IMPERFECT_CONSONANCE
+    when 5      # Perfect Fourth - dissonant in Renaissance counterpoint
+      HeadMusic::Rudiment::Consonance::DISSONANCE
+    else
+      HeadMusic::Rudiment::Consonance::DISSONANCE
+    end
+  end
+end

data/lib/head_music/style/tradition.rb

@@ -0,0 +1,21 @@
+# A style tradition represents a historical or theoretical approach to music
+module HeadMusic::Style
+  class Tradition
+    def self.get(name)
+      case name&.to_sym
+      when :modern, :standard_practice then ModernTradition.new
+      when :renaissance_counterpoint, :two_part_harmony then RenaissanceTradition.new
+      when :medieval then MedievalTradition.new
+      else ModernTradition.new
+      end
+    end
+
+    def consonance_classification(interval)
+      raise NotImplementedError, "#{self.class} must implement consonance_classification"
+    end
+
+    def name
+      self.class.name.split("::").last.sub(/Tradition$/, "").downcase.gsub(" ", "_").to_sym
+    end
+  end
+end

data/lib/head_music/utilities/hash_key.rb

@@ -2,8 +2,40 @@
 module HeadMusic::Utilities; end
 
 # Util for converting an object to a consistent hash key
-module HeadMusic::Utilities::HashKey
+class HeadMusic::Utilities::HashKey
   def self.for(identifier)
-    I18n.transliterate(identifier.to_s).downcase.gsub(/\W+/, "_").to_sym
+    @hash_keys ||= {}
+    @hash_keys[identifier] ||= new(identifier).to_sym
+  end
+
+  attr_reader :original
+
+  def initialize(identifier)
+    @original = identifier
+  end
+
+  def to_sym
+    normalized_string.to_sym
+  end
+
+  private
+
+  def normalized_string
+    @normalized_string ||=
+      transliterated_string.downcase.gsub(/\W+/, "_")
+  end
+
+  def transliterated_string
+    I18n.transliterate(desymbolized_string)
+  end
+
+  def desymbolized_string
+    original.to_s
+      .gsub("𝄫", "_double_flat")
+      .gsub("♭", "_flat")
+      .gsub("♮", "_natural")
+      .gsub("♯", "_sharp")
+      .gsub("#", "_sharp")
+      .gsub("𝄪", "_double_sharp")
   end
 end

data/lib/head_music/version.rb

@@ -1,3 +1,3 @@
 module HeadMusic
-  VERSION = "8.3.0"
+  VERSION = "9.0.1"
 end