head_music 6.0.0 → 7.0.0

data/lib/head_music/diatonic_interval/category.rb

@@ -0,0 +1,24 @@
+# Accepts the letter name count between two notes and categorizes the interval
+class HeadMusic::DiatonicInterval::Category
+  attr_reader :number
+
+  def initialize(number)
+    @number = number
+  end
+
+  def step?
+    number == 2
+  end
+
+  def skip?
+    number == 3
+  end
+
+  def leap?
+    number >= 3
+  end
+
+  def large_leap?
+    number > 3
+  end
+end

data/lib/head_music/diatonic_interval/naming.rb

@@ -0,0 +1,73 @@
+# Accepts a number and number of semitones and privides the naming methods.
+class HeadMusic::DiatonicInterval::Naming
+  QUALITY_SEMITONES = HeadMusic::DiatonicInterval::QUALITY_SEMITONES
+  NUMBER_NAMES = HeadMusic::DiatonicInterval::NUMBER_NAMES
+  NAME_SUFFIXES = HeadMusic::DiatonicInterval::NAME_SUFFIXES
+
+  attr_reader :number, :semitones
+
+  def initialize(number:, semitones:)
+    @number = number
+    @semitones = semitones
+  end
+
+  def simple_number
+    @simple_number ||= octave_equivalent? ? 8 : (number - 1) % 7 + 1
+  end
+
+  def simple_name
+    [quality_name, simple_number_name].join(" ")
+  end
+
+  def quality_name
+    starting_quality = QUALITY_SEMITONES[simple_number_name.to_sym].keys.first
+    delta = simple_semitones - (QUALITY_SEMITONES[simple_number_name.to_sym][starting_quality] % 12)
+    delta -= 12 while delta >= 6
+    HeadMusic::Quality.from(starting_quality, delta)
+  end
+
+  def simple_number_name
+    NUMBER_NAMES[simple_number - 1]
+  end
+
+  def number_name
+    NUMBER_NAMES[number - 1] || (number.to_s + NAME_SUFFIXES[number % 10])
+  end
+
+  def name
+    if named_number?
+      [quality_name, number_name].join(" ")
+    elsif simple_name == "perfect octave"
+      "#{octaves.humanize} octaves"
+    else
+      "#{octaves.humanize} octaves and #{quality.article} #{simple_name}"
+    end
+  end
+
+  def shorthand
+    step_shorthand = (number == 1) ? "U" : number
+    [quality.shorthand, step_shorthand].join
+  end
+
+  private
+
+  def simple_semitones
+    @simple_semitones ||= semitones % 12
+  end
+
+  def named_number?
+    number < NUMBER_NAMES.length
+  end
+
+  def quality
+    @quality ||= HeadMusic::Quality.get(quality_name)
+  end
+
+  def octaves
+    @octaves ||= semitones / 12
+  end
+
+  def octave_equivalent?
+    number > 1 && ((number - 1) % 7).zero?
+  end
+end

data/lib/head_music/diatonic_interval/parser.rb

@@ -0,0 +1,47 @@
+class HeadMusic::DiatonicInterval::Parser
+  NUMBER_NAMES = HeadMusic::DiatonicInterval::NUMBER_NAMES
+
+  attr_reader :identifier
+
+  def initialize(identifier)
+    @identifier = expand(identifier)
+  end
+
+  def words
+    identifier.to_s.split(/[_ ]+/)
+  end
+
+  def quality_name
+    words[0..-2].join(" ").to_sym
+  end
+
+  def degree_name
+    words.last
+  end
+
+  def steps
+    NUMBER_NAMES.index(degree_name)
+  end
+
+  def higher_letter
+    HeadMusic::Pitch.middle_c.letter_name.steps_up(steps)
+  end
+
+  def expand(identifier)
+    if /[A-Z]\d{1,2}/i.match?(identifier)
+      number = NUMBER_NAMES[identifier.gsub(/[A-Z]/i, "").to_i - 1]
+      return [quality_for(identifier[0]), number].join("_").to_sym
+    end
+    identifier
+  end
+
+  def quality_abbreviations
+    HeadMusic::DiatonicInterval::QUALITY_ABBREVIATIONS
+  end
+
+  def quality_for(abbreviation)
+    quality_abbreviations[abbreviation.to_sym] ||
+      quality_abbreviations[abbreviation.upcase.to_sym] ||
+      quality_abbreviations[abbreviation.downcase.to_sym]
+  end
+end

data/lib/head_music/diatonic_interval/semitones.rb

@@ -0,0 +1,36 @@
+# Accepts a name and a quality and returns the number of semitones
+class HeadMusic::DiatonicInterval::Semitones
+  QUALITY_SEMITONES = HeadMusic::DiatonicInterval::QUALITY_SEMITONES
+
+  attr_reader :count
+
+  def initialize(name, quality_name)
+    @count = self.class.degree_quality_semitones.dig(name, quality_name)
+  end
+
+  def self.degree_quality_semitones
+    @degree_quality_semitones ||= {}.tap do |degree_quality_semitones|
+      QUALITY_SEMITONES.each do |degree_name, qualities|
+        default_quality = qualities.keys.first
+        default_semitones = qualities[default_quality]
+        degree_quality_semitones[degree_name] = _semitones_for_degree(default_quality, default_semitones)
+      end
+    end
+  end
+
+  def self._semitones_for_degree(quality, default_semitones)
+    {}.tap do |semitones|
+      _degree_quality_modifications(quality).each do |current_quality, delta|
+        semitones[current_quality] = default_semitones + delta
+      end
+    end
+  end
+
+  def self._degree_quality_modifications(quality)
+    if quality == :perfect
+      HeadMusic::Quality::PERFECT_INTERVAL_MODIFICATION.invert
+    else
+      HeadMusic::Quality::MAJOR_INTERVAL_MODIFICATION.invert
+    end
+  end
+end

data/lib/head_music/diatonic_interval/size.rb

@@ -0,0 +1,50 @@
+# Encapsulate the distance methods of the interval
+class HeadMusic::DiatonicInterval::Size
+  attr_reader :low_pitch, :high_pitch
+
+  def initialize(pitch1, pitch2)
+    @low_pitch, @high_pitch = *[pitch1, pitch2].sort
+  end
+
+  def number
+    @number ||= @low_pitch.steps_to(@high_pitch) + 1
+  end
+
+  def simple_number
+    @simple_number ||= octave_equivalent? ? 8 : (number - 1) % 7 + 1
+  end
+
+  def octaves
+    @octaves ||= number / 8
+  end
+
+  def simple?
+    number <= 8
+  end
+
+  def compound?
+    !simple?
+  end
+
+  def simple_semitones
+    @simple_semitones ||= semitones % 12
+  end
+
+  def semitones
+    (high_pitch - low_pitch).to_i
+  end
+
+  def steps
+    number - 1
+  end
+
+  def simple_steps
+    steps % 7
+  end
+
+  private
+
+  def octave_equivalent?
+    number > 1 && ((number - 1) % 7).zero?
+  end
+end

data/lib/head_music/diatonic_interval.rb

@@ -43,237 +43,13 @@ class HeadMusic::DiatonicInterval
   delegate :to_s, to: :name
   delegate :perfect?, :major?, :minor?, :diminished?, :augmented?, :doubly_diminished?, :doubly_augmented?, to: :quality
 
-  # Interprets a string or symbol
-  class Parser
-    attr_reader :identifier
-
-    def initialize(identifier)
-      @identifier = expand(identifier)
-    end
-
-    def words
-      identifier.to_s.split(/[_ ]+/)
-    end
-
-    def quality_name
-      words[0..-2].join(" ").to_sym
-    end
-
-    def degree_name
-      words.last
-    end
-
-    def steps
-      NUMBER_NAMES.index(degree_name)
-    end
-
-    def higher_letter
-      HeadMusic::Pitch.middle_c.letter_name.steps_up(steps)
-    end
-
-    def expand(identifier)
-      if /[A-Z]\d{1,2}/i.match?(identifier)
-        number = NUMBER_NAMES[identifier.gsub(/[A-Z]/i, "").to_i - 1]
-        return [quality_for(identifier[0]), number].join("_").to_sym
-      end
-      identifier
-    end
-
-    def quality_for(abbreviation)
-      QUALITY_ABBREVIATIONS[abbreviation.to_sym] ||
-        QUALITY_ABBREVIATIONS[abbreviation.upcase.to_sym] ||
-        QUALITY_ABBREVIATIONS[abbreviation.downcase.to_sym]
-    end
-  end
-
-  # Accepts a name and a quality and returns the number of semitones
-  class Semitones
-    attr_reader :count
-
-    def initialize(name, quality_name)
-      @count = Semitones.degree_quality_semitones.dig(name, quality_name)
-    end
-
-    def self.degree_quality_semitones
-      @degree_quality_semitones ||= {}.tap do |degree_quality_semitones|
-        QUALITY_SEMITONES.each do |degree_name, qualities|
-          default_quality = qualities.keys.first
-          default_semitones = qualities[default_quality]
-          degree_quality_semitones[degree_name] = _semitones_for_degree(default_quality, default_semitones)
-        end
-      end
-    end
-
-    def self._semitones_for_degree(quality, default_semitones)
-      {}.tap do |semitones|
-        _degree_quality_modifications(quality).each do |current_quality, delta|
-          semitones[current_quality] = default_semitones + delta
-        end
-      end
-    end
-
-    def self._degree_quality_modifications(quality)
-      if quality == :perfect
-        HeadMusic::Quality::PERFECT_INTERVAL_MODIFICATION.invert
-      else
-        HeadMusic::Quality::MAJOR_INTERVAL_MODIFICATION.invert
-      end
-    end
-  end
-
-  # Accepts the letter name count between two notes and categorizes the interval
-  class Category
-    attr_reader :number
-
-    def initialize(number)
-      @number = number
-    end
-
-    def step?
-      number == 2
-    end
-
-    def skip?
-      number == 3
-    end
-
-    def leap?
-      number >= 3
-    end
-
-    def large_leap?
-      number > 3
-    end
-  end
-
-  # Encapsulate the distance methods of the interval
-  class Size
-    attr_reader :low_pitch, :high_pitch
-
-    def initialize(pitch1, pitch2)
-      @low_pitch, @high_pitch = *[pitch1, pitch2].sort
-    end
-
-    def number
-      @number ||= @low_pitch.steps_to(@high_pitch) + 1
-    end
-
-    def simple_number
-      @simple_number ||= octave_equivalent? ? 8 : (number - 1) % 7 + 1
-    end
-
-    def octaves
-      @octaves ||= number / 8
-    end
-
-    def simple?
-      number <= 8
-    end
-
-    def compound?
-      !simple?
-    end
-
-    def simple_semitones
-      @simple_semitones ||= semitones % 12
-    end
-
-    def semitones
-      (high_pitch - low_pitch).to_i
-    end
-
-    def steps
-      number - 1
-    end
-
-    def simple_steps
-      steps % 7
-    end
-
-    private
-
-    def octave_equivalent?
-      number > 1 && ((number - 1) % 7).zero?
-    end
-  end
-
-  # Accepts a number and number of semitones and privides the naming methods.
-  class Naming
-    attr_reader :number, :semitones
-
-    def initialize(number:, semitones:)
-      @number = number
-      @semitones = semitones
-    end
-
-    def simple_semitones
-      @simple_semitones ||= semitones % 12
-    end
-
-    def simple_number
-      @simple_number ||= octave_equivalent? ? 8 : (number - 1) % 7 + 1
-    end
-
-    def simple_name
-      [quality_name, simple_number_name].join(" ")
-    end
-
-    def quality_name
-      starting_quality = QUALITY_SEMITONES[simple_number_name.to_sym].keys.first
-      delta = simple_semitones - (QUALITY_SEMITONES[simple_number_name.to_sym][starting_quality] % 12)
-      delta -= 12 while delta >= 6
-      HeadMusic::Quality.from(starting_quality, delta)
-    end
-
-    def simple_number_name
-      NUMBER_NAMES[simple_number - 1]
-    end
-
-    def number_name
-      NUMBER_NAMES[number - 1] || (number.to_s + NAME_SUFFIXES[number % 10])
-    end
-
-    def name
-      if named_number?
-        [quality_name, number_name].join(" ")
-      elsif simple_name == "perfect octave"
-        "#{octaves.humanize} octaves"
-      else
-        "#{octaves.humanize} octaves and #{quality.article} #{simple_name}"
-      end
-    end
-
-    def shorthand
-      step_shorthand = (number == 1) ? "U" : number
-      [quality.shorthand, step_shorthand].join
-    end
-
-    private
-
-    def named_number?
-      number < NUMBER_NAMES.length
-    end
-
-    def quality
-      @quality ||= HeadMusic::Quality.get(quality_name)
-    end
-
-    def octaves
-      @octaves ||= semitones / 12
-    end
-
-    def octave_equivalent?
-      number > 1 && ((number - 1) % 7).zero?
-    end
-  end
-
   delegate :step?, :skip?, :leap?, :large_leap?, to: :category
   delegate(
     :simple_number, :octaves, :number, :simple?, :compound?, :semitones, :simple_semitones, :steps, :simple_steps,
     to: :size
   )
   delegate(
-    :simple_semitones, :simple_name, :quality_name, :simple_number_name, :number_name, :name, :shorthand,
+    :simple_name, :quality_name, :simple_number_name, :number_name, :name, :shorthand,
     to: :naming
   )
 
@@ -378,10 +154,6 @@ class HeadMusic::DiatonicInterval
     @naming ||= Naming.new(number: number, semitones: semitones)
   end
 
-  def named_number?
-    number < NUMBER_NAMES.length
-  end
-
   def consonance_for_perfect(style = :standard_practice)
     HeadMusic::Consonance.get(dissonant_fourth?(style) ? :dissonant : :perfect) if perfect?
   end

data/lib/head_music/instrument/staff.rb

@@ -21,7 +21,7 @@ class HeadMusic::Instrument::Staff
   end
 
   def name_key
-    attributes["name_key"]
+    attributes["name_key"] || ""
   end
 
   def name

data/lib/head_music/instrument/staff_scheme.rb

@@ -1,8 +1,8 @@
 class HeadMusic::Instrument::StaffScheme
-  attr_reader :pitch_variant, :key, :list
+  attr_reader :variant, :key, :list
 
-  def initialize(pitch_variant:, key:, list:)
-    @pitch_variant = pitch_variant
+  def initialize(variant:, key:, list:)
+    @variant = variant
     @key = key || "default"
     @list = list
   end

data/lib/head_music/instrument/{pitch_variant.rb → variant.rb}

@@ -1,4 +1,4 @@
-class HeadMusic::Instrument::PitchVariant
+class HeadMusic::Instrument::Variant
   attr_reader :key, :attributes
 
   def initialize(key, attributes = {})
@@ -6,11 +6,11 @@ class HeadMusic::Instrument::PitchVariant
     @attributes = attributes
   end
 
-  def fundamental_pitch_spelling
-    return unless attributes["fundamental_pitch_spelling"].to_s != ""
+  def pitch_designation
+    return unless attributes["pitch_designation"].to_s != ""
 
-    @fundamental_pitch_spelling ||=
-      HeadMusic::Spelling.get(attributes["fundamental_pitch_spelling"])
+    @pitch_designation ||=
+      HeadMusic::Spelling.get(attributes["pitch_designation"])
   end
 
   def staff_schemes
@@ -18,7 +18,7 @@ class HeadMusic::Instrument::PitchVariant
       (attributes["staff_schemes"] || {}).map do |key, list|
         HeadMusic::Instrument::StaffScheme.new(
           key: key,
-          pitch_variant: self,
+          variant: self,
           list: list
         )
       end

data/lib/head_music/instrument.rb

@@ -9,8 +9,8 @@
 #   default_clefs: the default clef or system of clefs for the instrument
 #     - [treble] for instruments that use the treble clef
 #     - [treble, bass] for instruments that use the grand staff
-#   pitch_variants:
-#     a hash of default and alternative fundamental pitches.
+#   variants:
+#     a hash of default and alternative pitch designations
 # Associations:
 #   family: the family of the instrument (e.g. "saxophone")
 #   orchestra_section: the section of the orchestra (e.g. "strings")
@@ -32,7 +32,7 @@ class HeadMusic::Instrument
   attr_reader(
     :name_key, :alias_name_keys,
     :family_key, :orchestra_section_key,
-    :pitch_variants, :classification_keys
+    :variants, :classification_keys
   )
 
   def ==(other)
@@ -75,12 +75,12 @@ class HeadMusic::Instrument
     default_clefs.any?
   end
 
-  def default_pitch_variant
-    pitch_variants.find(&:default?) || pitch_variants.first
+  def default_variant
+    variants.find(&:default?) || variants.first
   end
 
   def default_staff_scheme
-    default_pitch_variant&.default_staff_scheme
+    default_variant&.default_staff_scheme
   end
 
   def default_staves
@@ -158,9 +158,9 @@ class HeadMusic::Instrument
   def initialize_attributes(record)
     @orchestra_section_key ||= record["orchestra_section_key"]
     @classification_keys = [@classification_keys, record["classification_keys"]].flatten.compact.uniq
-    @pitch_variants =
-      (record["pitch_variants"] || {}).map do |key, attributes|
-        HeadMusic::Instrument::PitchVariant.new(key, attributes)
+    @variants =
+      (record["variants"] || {}).map do |key, attributes|
+        HeadMusic::Instrument::Variant.new(key, attributes)
       end
   end
 

data/lib/head_music/key_signature/enharmonic_equivalence.rb

@@ -0,0 +1,26 @@
+# Key signatures are enharmonic when all pitch classes in one are respellings of the pitch classes in the other.
+class HeadMusic::KeySignature::EnharmonicEquivalence
+  attr_reader :key_signature
+
+  def self.get(key_signature)
+    key_signature = HeadMusic::KeySignature.get(key_signature)
+    @enharmonic_equivalences ||= {}
+    @enharmonic_equivalences[key_signature.to_s] ||= new(key_signature)
+  end
+
+  def initialize(key_signature)
+    @key_signature = HeadMusic::KeySignature.get(key_signature)
+  end
+
+  def enharmonic_equivalent?(other)
+    other = HeadMusic::KeySignature.get(other)
+
+    key_signature.pitch_classes.map(&:to_i).sort == other.pitch_classes.map(&:to_i).sort &&
+      key_signature.alterations.map(&:to_s).sort != other.alterations.map(&:to_s).sort
+  end
+
+  alias_method :enharmonic?, :enharmonic_equivalent?
+  alias_method :equivalent?, :enharmonic_equivalent?
+
+  private_class_method :new
+end

data/lib/head_music/key_signature.rb

@@ -1,5 +1,4 @@
 # Represents a key signature.
-# In French, sharps and flats in the key signature are called "altérations".
 class HeadMusic::KeySignature
   attr_reader :tonic_spelling, :scale_type, :scale
 
@@ -21,7 +20,7 @@ class HeadMusic::KeySignature
 
   delegate :pitch_class, to: :tonic_spelling, prefix: :tonic
   delegate :to_s, to: :name
-  delegate :pitches, to: :scale
+  delegate :pitches, :pitch_classes, to: :scale
 
   def initialize(tonic_spelling, scale_type = nil)
     @tonic_spelling = HeadMusic::Spelling.get(tonic_spelling)
@@ -67,19 +66,23 @@ class HeadMusic::KeySignature
     flats.length + double_flats.length * 2
   end
 
-  def signs
-    flats.any? ? flats : sharps
+  def num_alterations
+    num_sharps + num_flats
   end
 
-  alias_method :sharps_and_flats, :signs
-  alias_method :accidentals, :signs
+  def alterations
+    flats.any? ? (double_flats + flats) : (double_sharps + sharps)
+  end
+
+  alias_method :sharps_and_flats, :alterations
+  alias_method :accidentals, :alterations
 
   def name
     [tonic_spelling, scale_type].join(" ")
   end
 
   def ==(other)
-    signs == self.class.get(other).signs
+    alterations == self.class.get(other).alterations
   end
 
   def to_s
@@ -93,38 +96,12 @@ class HeadMusic::KeySignature
   end
 
   def enharmonic_equivalent?(other)
-    other = KeySignature.get(other)
-    enharmonic_equivalence.equivalent?(other)
+    enharmonic_equivalence.enharmonic_equivalent?(other)
   end
 
   private
 
   def enharmonic_equivalence
-    @enharmonic_equivalence ||= EnharmonicEquivalence.get(self)
-  end
-
-  # Key signatures are enharmonic when all pitch classes in one are respellings of the pitch classes in the other.
-  class EnharmonicEquivalence
-    def self.get(key_signature)
-      key_signature = HeadMusic::KeySignature.get(key_signature)
-      @enharmonic_equivalences ||= {}
-      @enharmonic_equivalences[key_signature.to_s] ||= new(key_signature)
-    end
-
-    attr_reader :key_signature
-
-    def initialize(key_signature)
-      @key_signature = HeadMusic::KeySignature.get(key_signature)
-    end
-
-    def enharmonic_equivalent?(other)
-      other = HeadMusic::KeySignature.get(other)
-      (key_signature.signs | other.signs).map(&:to_s).uniq.length == 12
-    end
-
-    alias_method :enharmonic?, :enharmonic_equivalent?
-    alias_method :equivalent?, :enharmonic_equivalent?
-
-    private_class_method :new
+    @enharmonic_equivalence ||= HeadMusic::KeySignature::EnharmonicEquivalence.get(self)
   end
 end