head_music 0.17.0 → 0.18.0

data/lib/head_music/language.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# A language.
 class HeadMusic::Language
   include Comparable
   include HeadMusic::NamedRudiment
@@ -10,22 +13,24 @@ class HeadMusic::Language
     { name: 'Italian', native_name: 'Italiano', abbreviation: 'it' },
     { name: 'Spanish', native_name: 'Español', abbreviation: 'es' },
     { name: 'Russian', native_name: 'русский', abbreviation: 'ru' },
-  ]
+  ].freeze
 
-  LANGUAGES.map { |language| ::HeadMusic::Utilities::HashKey.for(language[:name]) }.each do |language_key|
-    define_singleton_method(language_key) { HeadMusic::Language.get(language_key) }
-  end
+  LANGUAGES.
+    map { |language| ::HeadMusic::Utilities::HashKey.for(language[:name]) }.
+    each { |language_key| define_singleton_method(language_key) { HeadMusic::Language.get(language_key) } }
 
-  LANGUAGES.map { |language| ::HeadMusic::Utilities::HashKey.for(language[:native_name]) }.reject(&:nil?).each do |language_key|
-    define_singleton_method(language_key) { HeadMusic::Language.get(language_key) }
-  end
+  LANGUAGES.
+    map { |language| ::HeadMusic::Utilities::HashKey.for(language[:native_name]) }.
+    reject(&:nil?).
+    each { |language_key| define_singleton_method(language_key) { HeadMusic::Language.get(language_key) } }
 
-  LANGUAGES.map { |language| ::HeadMusic::Utilities::HashKey.for(language[:short_name]) }.reject(&:nil?).each do |language_key|
-    define_singleton_method(language_key) { HeadMusic::Language.get(language_key) }
-  end
+  LANGUAGES.
+    map { |language| ::HeadMusic::Utilities::HashKey.for(language[:short_name]) }.
+    reject(&:nil?).
+    each { |language_key| define_singleton_method(language_key) { HeadMusic::Language.get(language_key) } }
 
   def self.default
-    self.english
+    english
   end
 
   def self.get(name)
@@ -36,9 +41,11 @@ class HeadMusic::Language
 
   def initialize(identifier)
     identifier_key = HeadMusic::Utilities::HashKey.for(identifier)
-    language_data = LANGUAGES.detect { |data|
-      [:name, :native_name, :short_name].map { |key| HeadMusic::Utilities::HashKey.for(data[key]) }.include?(identifier_key)
-    }
+    language_data = LANGUAGES.detect do |data|
+      %i[name native_name short_name].
+        map { |key| HeadMusic::Utilities::HashKey.for(data[key]) }.
+        include?(identifier_key)
+    end
     @name = language_data[:name]
     @native_name = language_data[:native_name]
     @short_name = language_data[:short_name]

data/lib/head_music/letter_name.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
+# Music has seven lette names that are used to identify pitches and pitch classes.
 class HeadMusic::LetterName
-  NAMES = %w[C D E F G A B]
+  NAMES = %w[C D E F G A B].freeze
 
   NATURAL_PITCH_CLASS_NUMBERS = {
     'C' => 0,
@@ -9,10 +12,10 @@ class HeadMusic::LetterName
     'G' => 7,
     'A' => 9,
     'B' => 11,
-  }
+  }.freeze
 
   def self.all
-    NAMES.map { |letter_name| get(letter_name)}
+    NAMES.map { |letter_name| get(letter_name) }
   end
 
   def self.get(identifier)
@@ -48,12 +51,12 @@ class HeadMusic::LetterName
     HeadMusic::PitchClass.get(NATURAL_PITCH_CLASS_NUMBERS[name])
   end
 
-  def ==(value)
-    to_s == value.to_s
+  def ==(other)
+    to_s == other.to_s
   end
 
   def position
-    NAMES.index(self.to_s) + 1
+    NAMES.index(to_s) + 1
   end
 
   def steps(num)
@@ -73,11 +76,11 @@ class HeadMusic::LetterName
   end
 
   def cycle
-    cycle = NAMES
-    while cycle.first != self.to_s
-      cycle = cycle.rotate
+    @cycle ||= begin
+      cycle = NAMES
+      cycle = cycle.rotate while cycle.first != to_s
+      cycle
     end
-    cycle
   end
 
   private_class_method :new

data/lib/head_music/melodic_interval.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
+# A melodic interval is the distance between one note and the next.
 class HeadMusic::MelodicInterval
-  attr_reader :voice, :first_note, :second_note
+  attr_reader :first_note, :second_note
 
-  def initialize(voice, note1, note2)
-    @voice = voice
+  def initialize(note1, note2)
     @first_note = note1
     @second_note = note2
   end
@@ -86,6 +88,10 @@ class HeadMusic::MelodicInterval
   end
 
   def method_missing(method_name, *args, &block)
-    functional_interval.send(method_name, *args, &block)
+    respond_to_missing?(method_name) ? functional_interval.send(method_name, *args, &block) : super
+  end
+
+  def respond_to_missing?(method_name, *_args)
+    functional_interval.respond_to?(method_name)
   end
 end

data/lib/head_music/meter.rb

@@ -1,10 +1,13 @@
+# frozen_string_literal: true
+
+# Meter is the rhythmic size of a measure, such as 4/4 or 6/8
 class HeadMusic::Meter
   attr_reader :top_number, :bottom_number
 
   NAMED = {
     common_time: '4/4',
-    cut_time: '2/2'
-  }
+    cut_time: '2/2',
+  }.freeze
 
   def self.get(identifier)
     identifier = identifier.to_s
@@ -27,7 +30,8 @@ class HeadMusic::Meter
   end
 
   def initialize(top_number, bottom_number)
-    @top_number, @bottom_number = top_number, bottom_number
+    @top_number = top_number
+    @bottom_number = bottom_number
   end
 
   def simple?
@@ -43,7 +47,7 @@ class HeadMusic::Meter
   end
 
   def triple?
-    top_number % 3 == 0
+    (top_number % 3).zero?
   end
 
   def quadruple?
@@ -77,8 +81,7 @@ class HeadMusic::Meter
   def beat_unit
     @beat_unit ||=
       if compound?
-        unit = HeadMusic::RhythmicUnit.for_denominator_value(bottom_number / 2)
-        HeadMusic::RhythmicValue.new(unit, dots: 1)
+        HeadMusic::RhythmicValue.new(HeadMusic::RhythmicUnit.for_denominator_value(bottom_number / 2), dots: 1)
       else
         HeadMusic::RhythmicValue.new(count_unit)
       end
@@ -101,10 +104,7 @@ class HeadMusic::Meter
   end
 
   def strong_ticks
-    @strong_ticks ||=
-      [2,3,4].map do |sixths|
-        ticks_per_count * (sixths / 6.0)
-      end
+    @strong_ticks ||= [2, 3, 4].map { |sixths| ticks_per_count * (sixths / 6.0) }
   end
 
   private
@@ -122,10 +122,10 @@ class HeadMusic::Meter
   end
 
   def strong_beat_in_triple?(count, tick = 0)
-    beat?(tick) && counts_per_bar % 3 == 0 && counts_per_bar > 6 && count % 3 == 1
+    beat?(tick) && (counts_per_bar % 3).zero? && counts_per_bar > 6 && count % 3 == 1
   end
 
   def beat?(tick)
-    tick == 0
+    tick.zero?
   end
 end

data/lib/head_music/motion.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# Motion defines the relative pitch direction of the upper and lower voices of subsequence intervals.
 class HeadMusic::Motion
   attr_reader :first_harmonic_interval, :second_harmonic_interval
 
@@ -12,7 +15,7 @@ class HeadMusic::Motion
 
   def oblique?
     upper_melodic_interval.repetition? && lower_melodic_interval.moving? ||
-    lower_melodic_interval.repetition? && upper_melodic_interval.moving?
+      lower_melodic_interval.repetition? && upper_melodic_interval.moving?
   end
 
   def direct?
@@ -21,19 +24,19 @@ class HeadMusic::Motion
 
   def parallel?
     upper_melodic_interval.moving? &&
-    upper_melodic_interval.direction == lower_melodic_interval.direction &&
-    upper_melodic_interval.steps == lower_melodic_interval.steps
+      upper_melodic_interval.direction == lower_melodic_interval.direction &&
+      upper_melodic_interval.steps == lower_melodic_interval.steps
   end
 
   def similar?
     upper_melodic_interval.direction == lower_melodic_interval.direction &&
-    upper_melodic_interval.steps != lower_melodic_interval.steps
+      upper_melodic_interval.steps != lower_melodic_interval.steps
   end
 
   def contrary?
     upper_melodic_interval.moving? &&
-    lower_melodic_interval.moving? &&
-    upper_melodic_interval.direction != lower_melodic_interval.direction
+      lower_melodic_interval.moving? &&
+      upper_melodic_interval.direction != lower_melodic_interval.direction
   end
 
   def notes
@@ -41,7 +44,7 @@ class HeadMusic::Motion
   end
 
   def contrapuntal_motion
-    [:parallel, :similar, :oblique, :contrary, :repetition].detect do |motion_type|
+    %i[parallel similar oblique contrary repetition].detect do |motion_type|
       send("#{motion_type}?")
     end
   end
@@ -53,11 +56,11 @@ class HeadMusic::Motion
   private
 
   def upper_melodic_interval
-    HeadMusic::MelodicInterval.new(upper_notes.first.voice, upper_notes.first, upper_notes.last)
+    HeadMusic::MelodicInterval.new(upper_notes.first, upper_notes.last)
   end
 
   def lower_melodic_interval
-    HeadMusic::MelodicInterval.new(lower_notes.first.voice, lower_notes.first, lower_notes.last)
+    HeadMusic::MelodicInterval.new(lower_notes.first, lower_notes.last)
   end
 
   def upper_notes

data/lib/head_music/named_rudiment.rb

@@ -1,27 +1,29 @@
-module HeadMusic
-  module NamedRudiment
-    attr_reader :name
-    delegate :to_s, to: :name
+# frozen_string_literal: true
 
-    def initialize(name)
-      @name = name.to_s
-    end
+# NameRudiment is a module to be included in classes whose instances may be identified by name.
+module HeadMusic::NamedRudiment
+  attr_reader :name
+  delegate :to_s, to: :name
 
-    def hash_key
-      HeadMusic::Utilities::HashKey.for(name)
-    end
+  def initialize(name)
+    @name = name.to_s
+  end
 
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
+  def hash_key
+    HeadMusic::Utilities::HashKey.for(name)
+  end
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
 
-    module ClassMethods
-      def get_by_name(name)
-        name = name.to_s
-        @instances_by_name ||= {}
-        key = HeadMusic::Utilities::HashKey.for(name)
-        @instances_by_name[key] ||= new(name)
-      end
+  # Adds .get_by_name to the including class.
+  module ClassMethods
+    def get_by_name(name)
+      name = name.to_s
+      @instances_by_name ||= {}
+      key = HeadMusic::Utilities::HashKey.for(name)
+      @instances_by_name[key] ||= new(name)
     end
   end
 end

data/lib/head_music/note.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Note is like a placement, except:
 #   - always has a pitch
 #   - doesn't require voice and position
@@ -20,6 +22,10 @@ class HeadMusic::Note
   end
 
   def method_missing(method_name, *args, &block)
-    placement.send(method_name, *args, &block)
+    respond_to_missing?(method_name) ? placement.send(method_name, *args, &block) : super
+  end
+
+  def respond_to_missing?(method_name, *_args)
+    placement.respond_to?(method_name)
   end
 end

data/lib/head_music/octave.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# The Octave identifier is a number used in scientific pitch notation.
 class HeadMusic::Octave
   include Comparable
 
@@ -9,17 +12,16 @@ class HeadMusic::Octave
 
   def self.from_number(identifier)
     return nil unless identifier.to_s == identifier.to_i.to_s
-    return nil unless (-2..12).include?(identifier.to_i)
+    return nil unless (-2..12).cover?(identifier.to_i)
     @octaves ||= {}
     @octaves[identifier.to_i] ||= new(identifier.to_i)
   end
 
   def self.from_name(string)
-    if string.to_s.match(HeadMusic::Spelling::MATCHER)
-      _letter, _sign, octave_string = string.to_s.match(HeadMusic::Spelling::MATCHER).captures
-      @octaves ||= {}
-      @octaves[octave_string.to_i] ||= new(octave_string.to_i) if octave_string
-    end
+    return unless string.to_s.match?(HeadMusic::Spelling::MATCHER)
+    _letter, _sign, octave_string = string.to_s.match(HeadMusic::Spelling::MATCHER).captures
+    @octaves ||= {}
+    @octaves[octave_string.to_i] ||= new(octave_string.to_i) if octave_string
   end
 
   def self.default
@@ -34,7 +36,7 @@ class HeadMusic::Octave
   end
 
   def <=>(other)
-    self.to_i <=> other.to_i
+    to_i <=> other.to_i
   end
 
   private_class_method :new

data/lib/head_music/pitch.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# A pitch is a named frequency represented by a spelling and an octive.
 class HeadMusic::Pitch
   include Comparable
 
@@ -15,6 +18,10 @@ class HeadMusic::Pitch
     from_name(value) || from_number(value)
   end
 
+  def self.middle_c
+    get('C4')
+  end
+
   def self.from_name(name)
     return nil unless name == name.to_s
     fetch_or_create(HeadMusic::Spelling.get(name), HeadMusic::Octave.get(name).to_i)
@@ -29,21 +36,24 @@ class HeadMusic::Pitch
 
   def self.from_number_and_letter(number, letter_name)
     letter_name = HeadMusic::LetterName.get(letter_name)
-    natural_letter_pitch = get(HeadMusic::LetterName.get(letter_name).pitch_class)
-    natural_letter_pitch += 12 while (number - natural_letter_pitch.to_i).to_i >= 11
-    natural_letter_pitch = get(natural_letter_pitch)
+    natural_letter_pitch = natural_letter_pitch(number, letter_name)
     sign_interval = natural_letter_pitch.smallest_interval_to(HeadMusic::PitchClass.get(number))
     sign = HeadMusic::Sign.by(:semitones, sign_interval) if sign_interval != 0
     spelling = HeadMusic::Spelling.fetch_or_create(letter_name, sign)
     fetch_or_create(spelling, natural_letter_pitch.octave)
   end
 
+  def self.natural_letter_pitch(number, letter_name)
+    natural_letter_pitch = get(HeadMusic::LetterName.get(letter_name).pitch_class)
+    natural_letter_pitch += 12 while (number - natural_letter_pitch.to_i).to_i >= 11
+    get(natural_letter_pitch)
+  end
+
   def self.fetch_or_create(spelling, octave)
+    return unless spelling && (-1..9).cover?(octave)
     @pitches ||= {}
-    if spelling && (-1..9).include?(octave)
-      hash_key = [spelling, octave].join
-      @pitches[hash_key] ||= new(spelling, octave)
-    end
+    hash_key = [spelling, octave].join
+    @pitches[hash_key] ||= new(spelling, octave)
   end
 
   def initialize(spelling, octave)
@@ -59,8 +69,8 @@ class HeadMusic::Pitch
     (octave + 1) * 12 + letter_name.pitch_class.to_i + sign_semitones.to_i
   end
 
-  alias_method :midi, :midi_note_number
-  alias_method :number, :midi_note_number
+  alias midi midi_note_number
+  alias number midi_note_number
 
   def to_s
     name
@@ -71,34 +81,34 @@ class HeadMusic::Pitch
   end
 
   def natural
-    HeadMusic::Pitch.get(self.to_s.gsub(/[#b]/, ''))
+    HeadMusic::Pitch.get(to_s.gsub(/[#b]/, ''))
   end
 
   def enharmonic?(other)
-    self.midi_note_number == other.midi_note_number
+    midi_note_number == other.midi_note_number
   end
 
-  def +(value)
-    HeadMusic::Pitch.get(self.to_i + value.to_i)
+  def +(other)
+    HeadMusic::Pitch.get(to_i + other.to_i)
   end
 
-  def -(value)
-    if value.is_a?(HeadMusic::Pitch)
+  def -(other)
+    if other.is_a?(HeadMusic::Pitch)
       # return an interval
-      HeadMusic::Interval.get(self.to_i - value.to_i)
+      HeadMusic::Interval.get(to_i - other.to_i)
     else
       # assume value represents an interval in semitones and return another pitch
-      HeadMusic::Pitch.get(self.to_i - value.to_i)
+      HeadMusic::Pitch.get(to_i - other.to_i)
     end
   end
 
-  def ==(value)
-    other = HeadMusic::Pitch.get(value)
+  def ==(other)
+    other = HeadMusic::Pitch.get(other)
     to_s == other.to_s
   end
 
   def <=>(other)
-    self.midi_note_number <=> other.midi_note_number
+    midi_note_number <=> other.midi_note_number
   end
 
   def scale(scale_type_name = nil)
@@ -106,16 +116,33 @@ class HeadMusic::Pitch
   end
 
   def natural_steps(num_steps)
-    target_letter_name = self.letter_name.steps(num_steps)
-    direction = num_steps >= 0 ? 1 : -1
-    octaves_delta = (num_steps.abs / 7) * direction
-    if num_steps < 0 && target_letter_name.position > letter_name.position
+    HeadMusic::Pitch.get([target_letter_name(num_steps), octave + octaves_delta(num_steps)].join)
+  end
+
+  private_class_method :new
+
+  private
+
+  def octaves_delta(num_steps)
+    octaves_delta = (num_steps.abs / 7) * (num_steps >= 0 ? 1 : -1)
+    if wrapped_down?(num_steps)
       octaves_delta -= 1
-    elsif num_steps > 0 && target_letter_name.position < letter_name.position
+    elsif wrapped_up?(num_steps)
       octaves_delta += 1
     end
-    HeadMusic::Pitch.get([target_letter_name, octave + octaves_delta].join)
+    octaves_delta
   end
 
-  private_class_method :new
+  def wrapped_down?(num_steps)
+    num_steps.negative? && target_letter_name(num_steps).position > letter_name.position
+  end
+
+  def wrapped_up?(num_steps)
+    num_steps.positive? && target_letter_name(num_steps).position < letter_name.position
+  end
+
+  def target_letter_name(num_steps)
+    @target_letter_name ||= {}
+    @target_letter_name[num_steps] ||= letter_name.steps(num_steps)
+  end
 end

data/lib/head_music/pitch_class.rb

@@ -1,18 +1,21 @@
+# frozen_string_literal: true
+
+# A pitch class is a set of notes separated by octaves.
 class HeadMusic::PitchClass
   attr_reader :number
 
-  SHARP_SPELLINGS = %w[C C# D D# E F F# G G# A A# B]
-  FLAT_SPELLINGS = %w[C Db D Eb E F Gb G Ab A Bb B]
+  SHARP_SPELLINGS = %w[C C# D D# E F F# G G# A A# B].freeze
+  FLAT_SPELLINGS = %w[C Db D Eb E F Gb G Ab A Bb B].freeze
 
   def self.get(identifier)
     @pitch_classes ||= {}
-    number = HeadMusic::Spelling.get(identifier).pitch_class.to_i if HeadMusic::Spelling.match(identifier)
+    number = HeadMusic::Spelling.get(identifier).pitch_class.to_i if HeadMusic::Spelling.matching_string(identifier)
     number ||= identifier.to_i % 12
     @pitch_classes[number] ||= new(number)
   end
 
   class << self
-    alias_method :[], :get
+    alias [] get
   end
 
   def initialize(pitch_class_or_midi_number)
@@ -23,22 +26,24 @@ class HeadMusic::PitchClass
     number
   end
 
-  def +(semitones)
-    HeadMusic::PitchClass.get(to_i + semitones.to_i)
+  # Pass in the number of semitones
+  def +(other)
+    HeadMusic::PitchClass.get(to_i + other.to_i)
   end
 
-  def -(semitones)
-    HeadMusic::PitchClass.get(to_i - semitones.to_i)
+  # Pass in the number of semitones
+  def -(other)
+    HeadMusic::PitchClass.get(to_i - other.to_i)
   end
 
-  def ==(value)
-    to_i == value.to_i
+  def ==(other)
+    to_i == other.to_i
   end
-  alias_method :enharmonic?, :==
+  alias enharmonic? ==
 
   def intervals_to(other)
     delta = other.to_i - to_i
-    inverse = delta > 0 ? delta - 12 : delta + 12
+    inverse = delta.positive? ? delta - 12 : delta + 12
     [delta, inverse].sort_by(&:abs).map { |interval| HeadMusic::Interval.get(interval) }
   end
 

data/lib/head_music/placement.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# A placement is a note or rest at a position within a voice in a composition
 class HeadMusic::Placement
   include Comparable
 
@@ -22,13 +25,11 @@ class HeadMusic::Placement
   end
 
   def <=>(other)
-    self.position <=> other.position
+    position <=> other.position
   end
 
   def during?(other_placement)
-    (other_placement.position >= position && other_placement.position < next_position) ||
-    (other_placement.next_position > position && other_placement.next_position <= next_position) ||
-    (other_placement.position <= position && other_placement.next_position >= next_position)
+    starts_during?(other_placement) || ends_during?(other_placement) || within?(other_placement)
   end
 
   def to_s
@@ -37,6 +38,18 @@ class HeadMusic::Placement
 
   private
 
+  def starts_during?(other_placement)
+    (other_placement.next_position > position && other_placement.next_position <= next_position)
+  end
+
+  def ends_during?(other_placement)
+    (other_placement.position >= position && other_placement.position < next_position)
+  end
+
+  def within?(other_placement)
+    (other_placement.position <= position && other_placement.next_position >= next_position)
+  end
+
   def ensure_attributes(voice, position, rhythmic_value, pitch)
     @voice = voice
     ensure_position(position)
@@ -45,10 +58,10 @@ class HeadMusic::Placement
   end
 
   def ensure_position(position)
-    if position.is_a?(HeadMusic::Position)
-      @position = position
-    else
-      @position = HeadMusic::Position.new(composition, position)
-    end
+    @position = if position.is_a?(HeadMusic::Position)
+                  position
+                else
+                  HeadMusic::Position.new(composition, position)
+                end
   end
 end

data/lib/head_music/position.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# A position is a moment in time within the rhythmic framework of a composition.
 class HeadMusic::Position
   include Comparable
 
@@ -35,10 +38,8 @@ class HeadMusic::Position
   end
 
   def <=>(other)
-    if other.is_a?(String) && other =~ /\D/
-      other = self.class.new(composition, other)
-    end
-    self.values <=> other.values
+    other = self.class.new(composition, other) if other.is_a?(String) && other =~ /\D/
+    values <=> other.values
   end
 
   def strength
@@ -53,11 +54,9 @@ class HeadMusic::Position
     !strong?
   end
 
-  def +(rhythmic_value)
-    if [HeadMusic::RhythmicUnit, Symbol, String].include?(rhythmic_value.class)
-      rhythmic_value = HeadMusic::RhythmicValue.new(rhythmic_value)
-    end
-    self.class.new(composition, bar_number, count, tick + rhythmic_value.ticks)
+  def +(other)
+    other = HeadMusic::RhythmicValue.new(other) if [HeadMusic::RhythmicUnit, Symbol, String].include?(other.class)
+    self.class.new(composition, bar_number, count, tick + other.ticks)
   end
 
   def start_of_next_bar