head_music 7.0.5 → 8.0.1

data/lib/head_music/{key_signature → rudiment/key_signature}/enharmonic_equivalence.rb

@@ -1,19 +1,19 @@
 # Key signatures are enharmonic when all pitch classes in one are respellings of the pitch classes in the other.
-class HeadMusic::KeySignature::EnharmonicEquivalence
+class HeadMusic::Rudiment::KeySignature::EnharmonicEquivalence
   attr_reader :key_signature
 
   def self.get(key_signature)
-    key_signature = HeadMusic::KeySignature.get(key_signature)
+    key_signature = HeadMusic::Rudiment::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)
+    @key_signature = HeadMusic::Rudiment::KeySignature.get(key_signature)
   end
 
   def enharmonic_equivalent?(other)
-    other = HeadMusic::KeySignature.get(other)
+    other = HeadMusic::Rudiment::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

data/lib/head_music/{key_signature.rb → rudiment/key_signature.rb}

@@ -1,5 +1,8 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
 # Represents a key signature.
-class HeadMusic::KeySignature
+class HeadMusic::Rudiment::KeySignature
   attr_reader :tonic_spelling, :scale_type, :scale
 
   ORDERED_LETTER_NAMES_OF_SHARPS = %w[F C G D A E B].freeze
@@ -10,7 +13,7 @@ class HeadMusic::KeySignature
   end
 
   def self.get(identifier)
-    return identifier if identifier.is_a?(HeadMusic::KeySignature)
+    return identifier if identifier.is_a?(HeadMusic::Rudiment::KeySignature)
 
     @key_signatures ||= {}
     tonic_spelling, scale_type_name = identifier.strip.split(/\s/)
@@ -23,11 +26,11 @@ class HeadMusic::KeySignature
   delegate :pitches, :pitch_classes, to: :scale
 
   def initialize(tonic_spelling, scale_type = nil)
-    @tonic_spelling = HeadMusic::Spelling.get(tonic_spelling)
-    @scale_type = HeadMusic::ScaleType.get(scale_type) if scale_type
-    @scale_type ||= HeadMusic::ScaleType.default
+    @tonic_spelling = HeadMusic::Rudiment::Spelling.get(tonic_spelling)
+    @scale_type = HeadMusic::Rudiment::ScaleType.get(scale_type) if scale_type
+    @scale_type ||= HeadMusic::Rudiment::ScaleType.default
     @scale_type = @scale_type.parent || @scale_type
-    @scale = HeadMusic::Scale.get(@tonic_spelling, @scale_type)
+    @scale = HeadMusic::Rudiment::Scale.get(@tonic_spelling, @scale_type)
   end
 
   def spellings
@@ -102,6 +105,6 @@ class HeadMusic::KeySignature
   private
 
   def enharmonic_equivalence
-    @enharmonic_equivalence ||= HeadMusic::KeySignature::EnharmonicEquivalence.get(self)
+    @enharmonic_equivalence ||= HeadMusic::Rudiment::KeySignature::EnharmonicEquivalence.get(self)
   end
 end

data/lib/head_music/{letter_name.rb → rudiment/letter_name.rb}

@@ -1,5 +1,8 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
 # Music has seven lette names that are used to identify pitches and pitch classes.
-class HeadMusic::LetterName
+class HeadMusic::Rudiment::LetterName
   NAMES = %w[C D E F G A B].freeze
 
   NATURAL_PITCH_CLASS_NUMBERS = {
@@ -32,7 +35,7 @@ class HeadMusic::LetterName
 
     pitch_class = pitch_class.to_i % 12
     name = NAMES.detect { |candidate| pitch_class == NATURAL_PITCH_CLASS_NUMBERS[candidate] }
-    name ||= HeadMusic::PitchClass::SHARP_SPELLINGS[pitch_class].first
+    name ||= HeadMusic::Rudiment::PitchClass::SHARP_SPELLINGS[pitch_class].first
     @letter_names[name] ||= new(name) if NAMES.include?(name)
   end
 
@@ -47,7 +50,7 @@ class HeadMusic::LetterName
   end
 
   def pitch_class
-    HeadMusic::PitchClass.get(NATURAL_PITCH_CLASS_NUMBERS[name])
+    HeadMusic::Rudiment::PitchClass.get(NATURAL_PITCH_CLASS_NUMBERS[name])
   end
 
   def ==(other)
@@ -59,15 +62,15 @@ class HeadMusic::LetterName
   end
 
   def steps_up(num)
-    HeadMusic::LetterName.get(series_ascending[num % NAMES.length])
+    HeadMusic::Rudiment::LetterName.get(series_ascending[num % NAMES.length])
   end
 
   def steps_down(num)
-    HeadMusic::LetterName.get(series_descending[num % NAMES.length])
+    HeadMusic::Rudiment::LetterName.get(series_descending[num % NAMES.length])
   end
 
   def steps_to(other, direction = :ascending)
-    other = HeadMusic::LetterName.get(other)
+    other = HeadMusic::Rudiment::LetterName.get(other)
     other_position = other.position
     if direction == :descending
       other_position -= NAMES.length if other_position > position

data/lib/head_music/{meter.rb → rudiment/meter.rb}

@@ -1,5 +1,8 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
 # Meter is the rhythmic size of a measure, such as 4/4 or 6/8
-class HeadMusic::Meter
+class HeadMusic::Rudiment::Meter
   attr_reader :top_number, :bottom_number
 
   NAMED = {
@@ -74,13 +77,13 @@ class HeadMusic::Meter
   end
 
   def count_unit
-    HeadMusic::RhythmicUnit.for_denominator_value(bottom_number)
+    HeadMusic::Rudiment::RhythmicUnit.for_denominator_value(bottom_number)
   end
 
   def beat_unit
     @beat_unit ||=
       if compound?
-        HeadMusic::Content::RhythmicValue.new(HeadMusic::RhythmicUnit.for_denominator_value(bottom_number / 2), dots: 1)
+        HeadMusic::Content::RhythmicValue.new(HeadMusic::Rudiment::RhythmicUnit.for_denominator_value(bottom_number / 2), dots: 1)
       else
         HeadMusic::Content::RhythmicValue.new(count_unit)
       end

data/lib/head_music/{musical_symbol.rb → rudiment/musical_symbol.rb}

@@ -1,5 +1,8 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
 # A symbol is a mark or sign that signifies a particular rudiment of music
-class HeadMusic::MusicalSymbol
+class HeadMusic::Rudiment::MusicalSymbol
   attr_reader :ascii, :unicode, :html_entity
 
   def initialize(ascii: nil, unicode: nil, html_entity: nil)

data/lib/head_music/{pitch → rudiment/pitch}/enharmonic_equivalence.rb

@@ -1,7 +1,7 @@
 # An enharmonic equivalent pitch is the same frequency spelled differently, such as D# and Eb.
-class HeadMusic::Pitch::EnharmonicEquivalence
+class HeadMusic::Rudiment::Pitch::EnharmonicEquivalence
   def self.get(pitch)
-    pitch = HeadMusic::Pitch.get(pitch)
+    pitch = HeadMusic::Rudiment::Pitch.get(pitch)
     @enharmonic_equivalences ||= {}
     @enharmonic_equivalences[pitch.to_s] ||= new(pitch)
   end
@@ -11,11 +11,11 @@ class HeadMusic::Pitch::EnharmonicEquivalence
   delegate :pitch_class, to: :pitch
 
   def initialize(pitch)
-    @pitch = HeadMusic::Pitch.get(pitch)
+    @pitch = HeadMusic::Rudiment::Pitch.get(pitch)
   end
 
   def enharmonic_equivalent?(other)
-    other = HeadMusic::Pitch.get(other)
+    other = HeadMusic::Rudiment::Pitch.get(other)
     pitch.midi_note_number == other.midi_note_number && pitch.spelling != other.spelling
   end
 

data/lib/head_music/{pitch → rudiment/pitch}/octave_equivalence.rb

@@ -1,5 +1,5 @@
 # Octave equivalence is the functional equivalence of pitches with the same spelling separated by one or more octaves.
-class HeadMusic::Pitch::OctaveEquivalence
+class HeadMusic::Rudiment::Pitch::OctaveEquivalence
   def self.get(pitch)
     @octave_equivalences ||= {}
     @octave_equivalences[pitch.to_s] ||= new(pitch)
@@ -12,7 +12,7 @@ class HeadMusic::Pitch::OctaveEquivalence
   end
 
   def octave_equivalent?(other)
-    other = HeadMusic::Pitch.get(other)
+    other = HeadMusic::Rudiment::Pitch.get(other)
     pitch.spelling == other.spelling && pitch.register != other.register
   end
 

data/lib/head_music/{pitch.rb → rudiment/pitch.rb}

@@ -1,5 +1,8 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
 # A pitch is a named frequency represented by a spelling and a register.
-class HeadMusic::Pitch
+class HeadMusic::Rudiment::Pitch
   include Comparable
 
   attr_reader :spelling, :register
@@ -40,7 +43,7 @@ class HeadMusic::Pitch
   end
 
   def self.from_pitch_class(pitch_class)
-    return nil unless pitch_class.is_a?(HeadMusic::PitchClass)
+    return nil unless pitch_class.is_a?(HeadMusic::Rudiment::PitchClass)
 
     fetch_or_create(pitch_class.sharp_spelling)
   end
@@ -48,33 +51,33 @@ class HeadMusic::Pitch
   def self.from_name(name)
     return nil unless name == name.to_s
 
-    fetch_or_create(HeadMusic::Spelling.get(name), HeadMusic::Register.get(name).to_i)
+    fetch_or_create(HeadMusic::Rudiment::Spelling.get(name), HeadMusic::Rudiment::Register.get(name).to_i)
   end
 
   def self.from_number(number)
     return nil unless number == number.to_i
 
-    fetch_or_create(HeadMusic::Spelling.from_number(number), (number.to_i / 12) - 1)
+    fetch_or_create(HeadMusic::Rudiment::Spelling.from_number(number), (number.to_i / 12) - 1)
   end
 
   def self.from_number_and_letter(number, letter_name)
-    letter_name = HeadMusic::LetterName.get(letter_name)
+    letter_name = HeadMusic::Rudiment::LetterName.get(letter_name)
     natural_letter_pitch = natural_letter_pitch(number, letter_name)
-    alteration_interval = natural_letter_pitch.smallest_interval_to(HeadMusic::PitchClass.get(number))
-    alteration = HeadMusic::Alteration.by(:semitones, alteration_interval) if alteration_interval != 0
-    spelling = HeadMusic::Spelling.fetch_or_create(letter_name, alteration)
+    alteration_interval = natural_letter_pitch.smallest_interval_to(HeadMusic::Rudiment::PitchClass.get(number))
+    alteration = HeadMusic::Rudiment::Alteration.by(:semitones, alteration_interval) if alteration_interval != 0
+    spelling = HeadMusic::Rudiment::Spelling.fetch_or_create(letter_name, alteration)
     fetch_or_create(spelling, natural_letter_pitch.register)
   end
 
   def self.natural_letter_pitch(number, letter_name)
-    natural_letter_pitch = get(HeadMusic::LetterName.get(letter_name).pitch_class)
+    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
     get(natural_letter_pitch)
   end
 
   def self.fetch_or_create(spelling, register = nil)
-    register ||= HeadMusic::Register::DEFAULT
+    register ||= HeadMusic::Rudiment::Register::DEFAULT
     return unless spelling && (-1..9).cover?(register)
 
     @pitches ||= {}
@@ -83,7 +86,7 @@ class HeadMusic::Pitch
   end
 
   def initialize(spelling, register)
-    @spelling = HeadMusic::Spelling.get(spelling.to_s)
+    @spelling = HeadMusic::Rudiment::Spelling.get(spelling.to_s)
     @register = register.to_i
   end
 
@@ -111,35 +114,35 @@ class HeadMusic::Pitch
   end
 
   def natural
-    HeadMusic::Pitch.get(to_s.gsub(HeadMusic::Alteration.matcher, ""))
+    HeadMusic::Rudiment::Pitch.get(to_s.gsub(HeadMusic::Rudiment::Alteration.matcher, ""))
   end
 
   def +(other)
-    if other.is_a?(HeadMusic::DiatonicInterval)
+    if other.is_a?(HeadMusic::Analysis::DiatonicInterval)
       # return a pitch
       other.above(self)
     else
       # assume value represents an interval in semitones and return another pitch
-      HeadMusic::Pitch.get(to_i + other.to_i)
+      HeadMusic::Rudiment::Pitch.get(to_i + other.to_i)
     end
   end
 
   def -(other)
     case other
-    when HeadMusic::DiatonicInterval
+    when HeadMusic::Analysis::DiatonicInterval
       # return a pitch
       other.below(self)
-    when HeadMusic::Pitch
+    when HeadMusic::Rudiment::Pitch
       # return an interval
-      HeadMusic::ChromaticInterval.get(to_i - other.to_i)
+      HeadMusic::Rudiment::ChromaticInterval.get(to_i - other.to_i)
     else
       # assume value represents an interval in semitones and return another pitch
-      HeadMusic::Pitch.get(to_i - other.to_i)
+      HeadMusic::Rudiment::Pitch.get(to_i - other.to_i)
     end
   end
 
   def ==(other)
-    other = HeadMusic::Pitch.get(other)
+    other = HeadMusic::Rudiment::Pitch.get(other)
     to_s == other.to_s
   end
 
@@ -148,11 +151,11 @@ class HeadMusic::Pitch
   end
 
   def scale(scale_type_name = nil)
-    HeadMusic::Scale.get(self, scale_type_name)
+    HeadMusic::Rudiment::Scale.get(self, scale_type_name)
   end
 
   def natural_steps(num_steps)
-    HeadMusic::Pitch.get([target_letter_name(num_steps), register + octaves_delta(num_steps)].join)
+    HeadMusic::Rudiment::Pitch.get([target_letter_name(num_steps), register + octaves_delta(num_steps)].join)
   end
 
   def frequency
@@ -160,7 +163,7 @@ class HeadMusic::Pitch
   end
 
   def steps_to(other)
-    other = HeadMusic::Pitch.get(other)
+    other = HeadMusic::Rudiment::Pitch.get(other)
     letter_name_steps_to(other) + 7 * octave_changes_to(other)
   end
 
@@ -181,15 +184,15 @@ class HeadMusic::Pitch
   end
 
   def enharmonic_equivalence
-    @enharmonic_equivalence ||= HeadMusic::Pitch::EnharmonicEquivalence.get(self)
+    @enharmonic_equivalence ||= HeadMusic::Rudiment::Pitch::EnharmonicEquivalence.get(self)
   end
 
   def octave_equivalence
-    @octave_equivalence ||= HeadMusic::Pitch::OctaveEquivalence.get(self)
+    @octave_equivalence ||= HeadMusic::Rudiment::Pitch::OctaveEquivalence.get(self)
   end
 
   def tuning
-    @tuning ||= HeadMusic::Tuning.new
+    @tuning ||= HeadMusic::Rudiment::Tuning.new
   end
 
   def octaves_delta(num_steps)
@@ -216,12 +219,12 @@ class HeadMusic::Pitch
   end
 
   def helmholtz_letter_name
-    return spelling.to_s.downcase if HeadMusic::Register.get(register).helmholtz_case == :lower
+    return spelling.to_s.downcase if HeadMusic::Rudiment::Register.get(register).helmholtz_case == :lower
 
     spelling.to_s
   end
 
   def helmholtz_marks
-    HeadMusic::Register.get(register).helmholtz_marks
+    HeadMusic::Rudiment::Register.get(register).helmholtz_marks
   end
 end

data/lib/head_music/{pitch_class.rb → rudiment/pitch_class.rb}

@@ -1,5 +1,8 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
 # A pitch class is a set of pitches separated by octaves.
-class HeadMusic::PitchClass
+class HeadMusic::Rudiment::PitchClass
   include Comparable
 
   attr_reader :number, :spelling
@@ -11,8 +14,8 @@ class HeadMusic::PitchClass
 
   def self.get(identifier)
     @pitch_classes ||= {}
-    if HeadMusic::Spelling.matching_string(identifier)
-      spelling = HeadMusic::Spelling.get(identifier)
+    if HeadMusic::Rudiment::Spelling.matching_string(identifier)
+      spelling = HeadMusic::Rudiment::Spelling.get(identifier)
       number = spelling.pitch_class.to_i
     end
     number ||= identifier.to_i % 12
@@ -48,23 +51,23 @@ class HeadMusic::PitchClass
   end
 
   def smart_spelling(max_sharps_in_major_key_signature: 6)
-    sharp_key = HeadMusic::KeySignature.get(sharp_spelling)
-    return HeadMusic::Spelling.get(sharp_spelling) if sharp_key.num_sharps <= max_sharps_in_major_key_signature
+    sharp_key = HeadMusic::Rudiment::KeySignature.get(sharp_spelling)
+    return HeadMusic::Rudiment::Spelling.get(sharp_spelling) if sharp_key.num_sharps <= max_sharps_in_major_key_signature
 
-    flat_key = HeadMusic::KeySignature.get(flat_spelling)
-    return HeadMusic::Spelling.get(flat_spelling) if flat_key.num_sharps <= max_sharps_in_major_key_signature
+    flat_key = HeadMusic::Rudiment::KeySignature.get(flat_spelling)
+    return HeadMusic::Rudiment::Spelling.get(flat_spelling) if flat_key.num_sharps <= max_sharps_in_major_key_signature
 
-    HeadMusic::Spelling.get(flatter_spelling)
+    HeadMusic::Rudiment::Spelling.get(flatter_spelling)
   end
 
   # Pass in the number of semitones
   def +(other)
-    HeadMusic::PitchClass.get(to_i + other.to_i)
+    HeadMusic::Rudiment::PitchClass.get(to_i + other.to_i)
   end
 
   # Pass in the number of semitones
   def -(other)
-    HeadMusic::PitchClass.get(to_i - other.to_i)
+    HeadMusic::Rudiment::PitchClass.get(to_i - other.to_i)
   end
 
   def ==(other)
@@ -79,7 +82,7 @@ class HeadMusic::PitchClass
   def intervals_to(other)
     delta = other.to_i - to_i
     inverse = delta.positive? ? delta - 12 : delta + 12
-    [delta, inverse].sort_by(&:abs).map { |interval| HeadMusic::ChromaticInterval.get(interval) }
+    [delta, inverse].sort_by(&:abs).map { |interval| HeadMusic::Rudiment::ChromaticInterval.get(interval) }
   end
 
   def smallest_interval_to(other)

data/lib/head_music/{quality.rb → rudiment/quality.rb}

@@ -1,5 +1,8 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
 # A quality is a categorization of an interval.
-class HeadMusic::Quality
+class HeadMusic::Rudiment::Quality
   SHORTHAND = {
     perfect: "P",
     major: "M",

data/lib/head_music/{reference_pitch.rb → rudiment/reference_pitch.rb}

@@ -1,6 +1,9 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
 # A reference pitch has a pitch and a frequency
 # With no arguments, it assumes that A4 = 440.0 Hz
-class HeadMusic::ReferencePitch
+class HeadMusic::Rudiment::ReferencePitch
   include HeadMusic::Named
 
   DEFAULT_PITCH_NAME = "A4"
@@ -81,7 +84,7 @@ class HeadMusic::ReferencePitch
 
   def initialize(name = DEFAULT_REFERENCE_PITCH_NAME)
     record = named_reference_pitch_record_for_name(name)
-    @pitch = HeadMusic::Pitch.get(record.fetch(:pitch, DEFAULT_PITCH_NAME))
+    @pitch = HeadMusic::Rudiment::Pitch.get(record.fetch(:pitch, DEFAULT_PITCH_NAME))
     @frequency = record.fetch(:frequency, DEFAULT_FREQUENCY)
     initialize_keys_from_record(record)
   end

data/lib/head_music/{register.rb → rudiment/register.rb}

@@ -1,9 +1,12 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
 # The register is a numeric octave identifier used in scientific pitch notation.
 #
 # A pitch is a spelling plus a register. For example, C4 is middle C and C5 is the C one octave higher.
 # The number changes between the letter names B and C regardless of sharps and flats,
 # so as an extreme example, Cb5 is actually a semitone below B#4.
-class HeadMusic::Register
+class HeadMusic::Rudiment::Register
   include Comparable
 
   DEFAULT = 4
@@ -21,9 +24,9 @@ class HeadMusic::Register
   end
 
   def self.from_name(string)
-    return unless string.to_s.match?(HeadMusic::Spelling::MATCHER)
+    return unless string.to_s.match?(HeadMusic::Rudiment::Spelling::MATCHER)
 
-    _letter, _sign, register_string = string.to_s.match(HeadMusic::Spelling::MATCHER).captures
+    _letter, _sign, register_string = string.to_s.match(HeadMusic::Rudiment::Spelling::MATCHER).captures
     @registers ||= {}
     @registers[register_string.to_i] ||= new(register_string.to_i) if register_string
   end

data/lib/head_music/rudiment/rhythm.rb

@@ -0,0 +1,6 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
+module HeadMusic::Rudiment::Rhythm
+  PPQN = PULSES_PER_QUARTER_NOTE = 960
+end

data/lib/head_music/{rhythmic_unit.rb → rudiment/rhythmic_unit.rb}

@@ -1,5 +1,8 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
 # A rhythmic unit is a rudiment of duration consisting of doublings and divisions of a whole note.
-class HeadMusic::RhythmicUnit
+class HeadMusic::Rudiment::RhythmicUnit
   include HeadMusic::Named
 
   MULTIPLES = ["whole", "double whole", "longa", "maxima"].freeze
@@ -35,7 +38,7 @@ class HeadMusic::RhythmicUnit
   end
 
   def ticks
-    HeadMusic::Rhythm::PPQN * 4 * relative_value
+    HeadMusic::Rudiment::Rhythm::PPQN * 4 * relative_value
   end
 
   def notehead

data/lib/head_music/{scale.rb → rudiment/scale.rb}

@@ -1,11 +1,14 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
 # A scale contains ordered pitches starting at a tonal center.
-class HeadMusic::Scale
+class HeadMusic::Rudiment::Scale
   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::Pitch.get(root_pitch)
-    scale_type = HeadMusic::ScaleType.get(scale_type || :major)
+    root_pitch = HeadMusic::Rudiment::Pitch.get(root_pitch)
+    scale_type = HeadMusic::Rudiment::ScaleType.get(scale_type || :major)
     @scales ||= {}
     hash_key = HeadMusic::Utilities::HashKey.for(
       [root_pitch, scale_type].join(" ").gsub(/#|♯/, "sharp").gsub(/(\w)[b♭]/, '\\1flat')
@@ -18,8 +21,8 @@ class HeadMusic::Scale
   attr_reader :root_pitch, :scale_type
 
   def initialize(root_pitch, scale_type)
-    @root_pitch = HeadMusic::Pitch.get(root_pitch)
-    @scale_type = HeadMusic::ScaleType.get(scale_type)
+    @root_pitch = HeadMusic::Rudiment::Pitch.get(root_pitch)
+    @scale_type = HeadMusic::Rudiment::ScaleType.get(scale_type)
   end
 
   def pitches(direction: :ascending, octaves: 1)
@@ -80,7 +83,7 @@ class HeadMusic::Scale
   end
 
   def parent_scale_pitches
-    HeadMusic::Scale.get(root_pitch, scale_type.parent_name).pitches if scale_type.parent
+    HeadMusic::Rudiment::Scale.get(root_pitch, scale_type.parent_name).pitches if scale_type.parent
   end
 
   def parent_scale_pitch_for(semitones_from_root)
@@ -92,7 +95,7 @@ class HeadMusic::Scale
   def pitch_for_step(step, semitones_from_root, direction)
     pitch_number = root_pitch_number + semitones_from_root
     letter_name = letter_for_step(step, semitones_from_root, direction)
-    HeadMusic::Pitch.from_number_and_letter(pitch_number, letter_name)
+    HeadMusic::Rudiment::Pitch.from_number_and_letter(pitch_number, letter_name)
   end
 
   def letter_for_step(step, semitones_from_root, direction)
@@ -117,11 +120,11 @@ class HeadMusic::Scale
   def flat_letter_for_step(semitones_from_root)
     return unless root_pitch.flat?
 
-    HeadMusic::PitchClass::FLAT_SPELLINGS[pitch_class_number(semitones_from_root)]
+    HeadMusic::Rudiment::PitchClass::FLAT_SPELLINGS[pitch_class_number(semitones_from_root)]
   end
 
   def sharp_letter_for_step(semitones_from_root)
-    HeadMusic::PitchClass::SHARP_SPELLINGS[pitch_class_number(semitones_from_root)]
+    HeadMusic::Rudiment::PitchClass::SHARP_SPELLINGS[pitch_class_number(semitones_from_root)]
   end
 
   def pitch_class_number(semitones_from_root)

data/lib/head_music/{scale_degree.rb → rudiment/scale_degree.rb}

@@ -1,6 +1,9 @@
+# A module for music rudiments
+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::ScaleDegree
+class HeadMusic::Rudiment::ScaleDegree
   include Comparable
 
   NAME_FOR_DIATONIC_DEGREE = [nil, "tonic", "supertonic", "mediant", "subdominant", "dominant", "submediant"].freeze
@@ -12,7 +15,7 @@ class HeadMusic::ScaleDegree
 
   def initialize(key_signature, spelling)
     @key_signature = key_signature
-    @spelling = HeadMusic::Spelling.get(spelling)
+    @spelling = HeadMusic::Rudiment::Spelling.get(spelling)
   end
 
   def degree
@@ -23,7 +26,7 @@ class HeadMusic::ScaleDegree
     spelling_alteration_semitones = spelling.alteration&.semitones || 0
     usual_sign_semitones = scale_degree_usual_spelling.alteration&.semitones || 0
     delta = spelling_alteration_semitones - usual_sign_semitones
-    HeadMusic::Alteration.by(:semitones, delta) if delta != 0
+    HeadMusic::Rudiment::Alteration.by(:semitones, delta) if delta != 0
   end
 
   def alteration_semitones
@@ -35,7 +38,7 @@ class HeadMusic::ScaleDegree
   end
 
   def <=>(other)
-    if other.is_a?(HeadMusic::ScaleDegree)
+    if other.is_a?(HeadMusic::Rudiment::ScaleDegree)
       [degree, alteration_semitones] <=> [other.degree, other.alteration_semitones]
     else
       # TODO: Improve this
@@ -53,6 +56,6 @@ class HeadMusic::ScaleDegree
   private
 
   def scale_degree_usual_spelling
-    HeadMusic::Spelling.get(scale.spellings[degree - 1])
+    HeadMusic::Rudiment::Spelling.get(scale.spellings[degree - 1])
   end
 end

data/lib/head_music/{scale_type.rb → rudiment/scale_type.rb}

@@ -1,5 +1,8 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
 # A ScaleType represents a particular scale pattern, such as major, lydian, or minor pentatonic.
-class HeadMusic::ScaleType
+class HeadMusic::Rudiment::ScaleType
   H = 1 # whole step
   W = 2 # half step
 

data/lib/head_music/{solmization.rb → rudiment/solmization.rb}

@@ -1,6 +1,9 @@
+# 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.
-class HeadMusic::Solmization
+class HeadMusic::Rudiment::Solmization
   include HeadMusic::Named
 
   DEFAULT_SOLMIZATION = "solfège"