head_music 0.5.3 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 326a9d839392519ee341ca47ec34eb63ea461bd1
-  data.tar.gz: 95dbb21634187c2ba6764829ce37e16759347d39
+  metadata.gz: 26fa77af760e9919b585bfb9db2e53d30b382ecf
+  data.tar.gz: 244d2c9e9d85800cfc0f897773e17d4a1410c885
 SHA512:
-  metadata.gz: d7b40960fcf36045cfd9d512e27d41024fc2a1a37c10cbcffa1c89c125ac2fd3fba06108b457f6ae99c612bc956c23763636999239c05250c0842314be75fb11
-  data.tar.gz: 6a7971653dad527be88f1321e9e3cab80b4855e8a460a82f885fd17d96a78fe1bb98e0b3fd21bfe2b6f49529bda891fadce86979dcf9669da5657ad82c51d5eb
+  metadata.gz: 89befc698de10095285b790246b6102bcd6d1ca94c3cf50ea19ee39c9f60e00de277c954172a652e7af1209d3660d33e8d002111aa1c4a426e3be82a574d683e
+  data.tar.gz: 71e3d3c4ed45c6b7407d077fb500227d1a372518190bd3cc3400d8bcdb49aea803c2d11b8815c4568b44ef2e5b5a2cc0022e1bef9eabee0eedb7c6ab5d23ec22

data/lib/head_music/clef.rb

@@ -0,0 +1,54 @@
+class HeadMusic::Clef
+  CLEFS = [
+    { pitch: 'G4', line: 2, names: ['treble', 'G-clef'], modern: true },
+    { pitch: 'G4', line: 1, names: ['French', 'French violin'] },
+    { pitch: 'G3', line: 2, names: ['tenor'], modern: true },
+
+    { pitch: 'F3', line: 3, names: ['baritone'] },
+    { pitch: 'F3', line: 4, names: ['bass', 'F-clef'], modern: true },
+    { pitch: 'F3', line: 5, names: ['sub-bass'] },
+
+    { pitch: 'C4', line: 1, names: ['soprano'] },
+    { pitch: 'C4', line: 2, names: ['mezzo-soprano'] },
+    { pitch: 'C4', line: 3, names: ['alto', 'viola', 'counter-tenor', 'countertenor'], modern: true },
+    { pitch: 'C4', line: 4, names: ['tenor'], modern: true },
+    { pitch: 'C4', line: 5, names: ['baritone'] },
+
+    { pitch: nil, line: 3, names: ['neutral', 'percussion'] }
+  ]
+
+  def self.get(name)
+    name = name.to_s
+    @clefs ||= {}
+    @clefs[name.to_s.to_sym] = new(name)
+  end
+
+  attr_reader :name, :pitch, :line
+
+  def initialize(name)
+    @name = name.to_s
+    clef_data = CLEFS.detect { |clef| clef[:names].include?(name) }
+    @pitch = HeadMusic::Pitch.get(clef_data[:pitch])
+    @line = clef_data[:line]
+  end
+
+  def clef_type
+    "#{pitch.letter_name}-clef"
+  end
+
+  def line_pitch(line_number)
+    @line_pitches ||= {}
+    @line_pitches[line_number] ||= begin
+      steps = (line_number - line) * 2
+      pitch.natural_steps(steps)
+    end
+  end
+
+  def space_pitch(space_number)
+    @space_pitches ||= {}
+    @space_pitches[space_number] ||= begin
+      steps = (space_number - line) * 2 + 1
+      pitch.natural_steps(steps)
+    end
+  end
+end

data/lib/head_music/functional_interval.rb

@@ -33,7 +33,7 @@ class HeadMusic::FunctionalInterval
     quality_name, degree_name = words[0..-2].join(' '), words.last
     lower_pitch = HeadMusic::Pitch.get('C4')
     steps = NUMBER_NAMES.index(degree_name)
-    higher_letter = lower_pitch.letter.steps(steps)
+    higher_letter = lower_pitch.letter_name.steps(steps)
     semitones = degree_quality_semitones.dig(degree_name.to_sym, quality_name.to_sym)
     higher_pitch = HeadMusic::Pitch.from_number_and_letter(lower_pitch + semitones, higher_letter)
     new(lower_pitch, higher_pitch)
@@ -70,7 +70,7 @@ class HeadMusic::FunctionalInterval
   end
 
   def simple_number
-    @simple_number ||= @lower_pitch.letter.steps_to(@higher_pitch.letter) + 1
+    @simple_number ||= @lower_pitch.letter_name.steps_to(@higher_pitch.letter_name) + 1
   end
 
   def simple_semitones

data/lib/head_music/letter_name.rb

@@ -1,7 +1,5 @@
 class HeadMusic::LetterName
-  # Defines the natural relationship between the natural letter-named notes
-
-  NAMES = ('A'..'G').to_a
+  NAMES = %w[C D E F G A B]
 
   NATURAL_PITCH_CLASS_NUMBERS = {
     'C' => 0,
@@ -23,18 +21,18 @@ class HeadMusic::LetterName
   singleton_class.send(:alias_method, :[], :get)
 
   def self.from_name(name)
-    @letters ||= {}
+    @letter_names ||= {}
     name = name.to_s.first.upcase
-    @letters[name] ||= new(name) if NAMES.include?(name)
+    @letter_names[name] ||= new(name) if NAMES.include?(name)
   end
 
   def self.from_pitch_class(pitch_class)
-    @letters ||= {}
+    @letter_names ||= {}
     return nil if pitch_class.to_s == pitch_class
     pitch_class = pitch_class.to_i % 12
     name = NAMES.detect { |name| pitch_class == NATURAL_PITCH_CLASS_NUMBERS[name] }
     name ||= HeadMusic::PitchClass::PREFERRED_SPELLINGS[pitch_class].first
-    @letters[name] ||= new(name) if NAMES.include?(name)
+    @letter_names[name] ||= new(name) if NAMES.include?(name)
   end
 
   attr_reader :name
@@ -60,7 +58,7 @@ class HeadMusic::LetterName
   end
 
   def steps(num)
-    cycle[num]
+    HeadMusic::LetterName.get(cycle[num % NAMES.length])
   end
 
   def steps_to(other, direction = :ascending)

data/lib/head_music/note.rb

@@ -0,0 +1,14 @@
+class HeadMusic::Note
+  attr_reader :pitch, :rhythmic_value
+
+  delegate :ticks, to: :rhythmic_value
+
+  def initialize(pitch, rhythmic_unit, rhythmic_value_modifiers = {})
+    @pitch = HeadMusic::Pitch.get(pitch)
+    @rhythmic_value = HeadMusic::RhythmicValue.new(rhythmic_unit, rhythmic_value_modifiers)
+  end
+
+  def duration
+    rhythmic_value.total_value
+  end
+end

data/lib/head_music/pitch.rb

@@ -4,7 +4,7 @@ class HeadMusic::Pitch
   attr_reader :spelling
   attr_reader :octave
 
-  delegate :letter, :letter_cycle, to: :spelling
+  delegate :letter_name, :letter_name_cycle, to: :spelling
   delegate :accidental, :sharp?, :flat?, to: :spelling
   delegate :pitch_class, to: :spelling
   delegate :semitones, to: :accidental, prefix: true, allow_nil: true
@@ -28,14 +28,14 @@ class HeadMusic::Pitch
     fetch_or_create(spelling, octave)
   end
 
-  def self.from_number_and_letter(number, letter)
-    letter = HeadMusic::LetterName.get(letter)
-    natural_letter_pitch = get(HeadMusic::LetterName.get(letter).pitch_class)
+  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)
     accidental_interval = natural_letter_pitch.smallest_interval_to(HeadMusic::PitchClass.get(number))
     accidental = HeadMusic::Accidental.for_interval(accidental_interval)
-    spelling = HeadMusic::Spelling.fetch_or_create(letter, accidental)
+    spelling = HeadMusic::Spelling.fetch_or_create(letter_name, accidental)
     fetch_or_create(spelling, natural_letter_pitch.octave)
   end
 
@@ -57,7 +57,7 @@ class HeadMusic::Pitch
   end
 
   def midi_note_number
-    (octave + 1) * 12 + letter.pitch_class.to_i + accidental_semitones.to_i
+    (octave + 1) * 12 + letter_name.pitch_class.to_i + accidental_semitones.to_i
   end
 
   alias_method :midi, :midi_note_number
@@ -71,6 +71,10 @@ class HeadMusic::Pitch
     midi_note_number
   end
 
+  def natural
+    HeadMusic::Pitch.get(self.to_s.gsub(/[#b]/, ''))
+  end
+
   def enharmonic?(other)
     self.midi_note_number == other.midi_note_number
   end
@@ -101,5 +105,17 @@ class HeadMusic::Pitch
     HeadMusic::Scale.get(self, scale_type_name)
   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
+      octaves_delta -= 1
+    elsif num_steps > 0 && target_letter_name.position < letter_name.position
+      octaves_delta += 1
+    end
+    HeadMusic::Pitch.get([target_letter_name, octave + octaves_delta].join)
+  end
+
   private_class_method :new
 end

data/lib/head_music/rhythmic_unit.rb

@@ -0,0 +1,59 @@
+class HeadMusic::RhythmicUnit
+  MULTIPLES = ['whole', 'double whole', 'longa', 'maxima']
+  DIVISIONS = ['whole', 'half', 'quarter', 'eighth', 'sixteenth', 'thirty-second', 'sixty-fourth', 'hundred twenty-eighth', 'two hundred fifty-sixth']
+
+  BRITISH_MULTIPLE_NAMES = %w[semibreve breve longa maxima]
+  BRITISH_DIVISION_NAMES = %w[semibreve minim crotchet quaver semiquaver demisemiquaver hemidemisemiquaver semihemidemisemiquaver demisemihemidemisemiquaver]
+
+  def self.get(name)
+    @rhythmic_units ||= {}
+    @rhythmic_units[name.to_s] ||= new(name.to_s)
+  end
+  singleton_class.send(:alias_method, :[], :get)
+
+  attr_reader :name, :numerator, :denominator
+  delegate :to_s, to: :name
+
+  def initialize(canonical_name)
+    @name ||= canonical_name
+    @numerator ||= MULTIPLES.include?(name) ? 2**MULTIPLES.index(name) : 1
+    @denominator ||= DIVISIONS.include?(name) ? 2**DIVISIONS.index(name) : 1
+  end
+
+  def relative_value
+    @numerator.to_f / @denominator
+  end
+
+  def notehead
+    case relative_value
+    when 8
+      :maxima
+    when 4
+      :longa
+    when 2
+      :breve
+    when 0.5, 1
+      :open
+    else
+      :closed
+    end
+  end
+
+  def flags
+    DIVISIONS.include?(name) ? [DIVISIONS.index(name) - 2, 0].max : 0
+  end
+
+  def has_stem?
+    relative_value < 1
+  end
+
+  def british_name
+    if MULTIPLES.include?(name)
+      BRITISH_MULTIPLE_NAMES[MULTIPLES.index(name)]
+    elsif DIVISIONS.include?(name)
+      BRITISH_DIVISION_NAMES[DIVISIONS.index(name)]
+    end
+  end
+
+  private_class_method :new
+end

data/lib/head_music/rhythmic_value.rb

@@ -1,63 +1,60 @@
 class HeadMusic::RhythmicValue
-  MULTIPLES = ['whole', 'double whole', 'longa', 'maxima']
-  DIVISIONS = ['whole', 'half', 'quarter', 'eighth', 'sixteenth', 'thirty-second', 'sixty-fourth', 'hundred twenty-eighth note', 'two hundred fifty-sixth note']
+  PPQN = PULSES_PER_QUARTER_NOTE = 960
 
-  BRITISH_MULTIPLE_NAMES = %w[semibreve breve longa maxima]
-  BRITISH_DIVISION_NAMES = %w[semibreve minim crotchet quaver semiquaver demisemiquaver hemidemisemiquaver semihemidemisemiquaver demisemihemidemisemiquaver]
+  attr_reader :unit, :dots, :tied_value
 
-  def self.get(name)
-    @rhythmic_values ||= {}
-    @rhythmic_values[name.to_s] ||= new(name.to_s)
-  end
-  singleton_class.send(:alias_method, :[], :get)
+  delegate :name, to: :unit, prefix: true
 
-  attr_reader :name
-  delegate :to_s, to: :name
-  delegate :to_i, to: :relative_value
+  def initialize(unit, dots: nil, tied_value: nil)
+    @unit = HeadMusic::RhythmicUnit.get(unit)
+    @dots = [0, 1, 2, 3].include?(dots) ? dots : 0
+    @tied_value = tied_value
+  end
 
-  def initialize(canonical_name)
-    @name ||= canonical_name
+  def unit_value
+    unit.relative_value
   end
 
   def relative_value
-    @relative_value ||=
-      if MULTIPLES.include?(name)
-        1.0 * 2**MULTIPLES.index(name)
-      elsif DIVISIONS.include?(name)
-        1.0 / 2**DIVISIONS.index(name)
-      end
+    unit_value * multiplier
   end
 
-  def per_whole
-    @per_whole ||=
-      if MULTIPLES.include?(name)
-        1.0 / 2**MULTIPLES.index(name)
-      elsif DIVISIONS.include?(name)
-        1.0 * 2**DIVISIONS.index(name)
-      end
+  def total_value
+    relative_value + (tied_value ? tied_value.total_value : 0)
   end
 
-  def note_head
-    return :breve if relative_value == 2
-    return :open if relative_value >= 0.5
-    :closed
+  def multiplier
+    (0..dots).reduce(0) { |sum, i| sum += (1.0/2)**i }
   end
 
-  def flags
-    DIVISIONS.include?(name) ? [DIVISIONS.index(name) - 2, 0].max : 0
+  def ticks
+    PPQN * 4 * total_value
   end
 
-  def has_stem?
-    relative_value < 1
+  def per_whole
+    1.0 / relative_value
   end
 
-  def british_name
-    if MULTIPLES.include?(name)
-      BRITISH_MULTIPLE_NAMES[MULTIPLES.index(name)]
-    elsif DIVISIONS.include?(name)
-      BRITISH_DIVISION_NAMES[DIVISIONS.index(name)]
+  def name_modifier_prefix
+    case dots
+    when 1
+      'dotted'
+    when 2
+      'double-dotted'
+    when 3
+      'triple-dotted'
     end
   end
 
-  private_class_method :new
+  def single_value_name
+    [name_modifier_prefix, unit_name].reject(&:nil?).join(' ')
+  end
+
+  def name
+    if tied_value
+      [single_value_name, tied_value.name].reject(&:nil?).join(' tied to ')
+    else
+      single_value_name
+    end
+  end
 end

data/lib/head_music/scale.rb

@@ -19,7 +19,7 @@ class HeadMusic::Scale
     @pitches ||= {}
     @pitches[direction] ||= {}
     @pitches[direction][octaves] ||= begin
-      letter_cycle = root_pitch.letter_cycle
+      letter_name_cycle = root_pitch.letter_name_cycle
       semitones_from_root = 0
       [root_pitch].tap do |pitches|
         if [:ascending, :both].include?(direction)
@@ -50,8 +50,8 @@ class HeadMusic::Scale
     pitches(direction: direction, octaves: octaves).map(&:name)
   end
 
-  def letter_cycle
-    @letter_cycle ||= root_pitch.letter_cycle
+  def letter_name_cycle
+    @letter_name_cycle ||= root_pitch.letter_name_cycle
   end
 
   def root_pitch_number
@@ -77,9 +77,9 @@ class HeadMusic::Scale
   def letter_for_step(step, semitones_from_root, direction)
     pitch_class_number = (root_pitch.pitch_class.to_i + semitones_from_root) % 12
     if scale_type.intervals.length == 7
-      direction == :ascending ? letter_cycle[step % 7] : letter_cycle[-step % 7]
+      direction == :ascending ? letter_name_cycle[step % 7] : letter_name_cycle[-step % 7]
     elsif scale_type.intervals.length < 7 && parent_scale_pitches
-      parent_scale_pitch_for(semitones_from_root).letter
+      parent_scale_pitch_for(semitones_from_root).letter_name
     elsif root_pitch.flat?
       HeadMusic::PitchClass::FLAT_SPELLINGS[pitch_class_number]
     else
@@ -89,7 +89,7 @@ class HeadMusic::Scale
 
   def pitch_for_step(step, semitones_from_root, direction)
     pitch_number = root_pitch_number + semitones_from_root
-    letter = letter_for_step(step, semitones_from_root, direction)
-    HeadMusic::Pitch.from_number_and_letter(pitch_number, letter)
+    letter_name = letter_for_step(step, semitones_from_root, direction)
+    HeadMusic::Pitch.from_number_and_letter(pitch_number, letter_name)
   end
 end

data/lib/head_music/spelling.rb

@@ -1,14 +1,13 @@
-# A Spelling is a pitch class with a letter name and possibly an accidental
 class HeadMusic::Spelling
   MATCHER = /^\s*([A-G])([b#]*)(\-?\d+)?\s*$/
 
   attr_reader :pitch_class
-  attr_reader :letter
+  attr_reader :letter_name
   attr_reader :accidental
 
   delegate :number, to: :pitch_class, prefix: true
   delegate :to_i, to: :pitch_class_number
-  delegate :cycle, to: :letter, prefix: true
+  delegate :cycle, to: :letter_name, prefix: true
   delegate :enharmonic?, to: :pitch_class
 
   def self.get(identifier)
@@ -23,43 +22,43 @@ class HeadMusic::Spelling
   def self.from_name(name)
     if match(name)
       letter_name, accidental_string, _octave = match(name).captures
-      letter = HeadMusic::LetterName.get(letter_name)
-      return nil unless letter
+      letter_name = HeadMusic::LetterName.get(letter_name)
+      return nil unless letter_name
       accidental = HeadMusic::Accidental.get(accidental_string)
-      fetch_or_create(letter, accidental)
+      fetch_or_create(letter_name, accidental)
     end
   end
 
   def self.from_number(number)
     return nil unless number == number.to_i
     pitch_class_number = number.to_i % 12
-    letter = HeadMusic::LetterName.from_pitch_class(pitch_class_number)
-    from_number_and_letter(number, letter)
+    letter_name = HeadMusic::LetterName.from_pitch_class(pitch_class_number)
+    from_number_and_letter(number, letter_name)
   end
 
-  def self.from_number_and_letter(number, letter)
-    letter = HeadMusic::LetterName.get(letter)
-    natural_letter_pitch_class = HeadMusic::LetterName.get(letter).pitch_class
-    accidental_interval = letter.pitch_class.smallest_interval_to(HeadMusic::PitchClass.get(number))
+  def self.from_number_and_letter(number, letter_name)
+    letter_name = HeadMusic::LetterName.get(letter_name)
+    natural_letter_pitch_class = HeadMusic::LetterName.get(letter_name).pitch_class
+    accidental_interval = letter_name.pitch_class.smallest_interval_to(HeadMusic::PitchClass.get(number))
     accidental = HeadMusic::Accidental.for_interval(accidental_interval)
-    fetch_or_create(letter, accidental)
+    fetch_or_create(letter_name, accidental)
   end
 
-  def self.fetch_or_create(letter, accidental)
+  def self.fetch_or_create(letter_name, accidental)
     @spellings ||= {}
-    key = [letter, accidental].join
-    @spellings[key] ||= new(letter, accidental)
+    key = [letter_name, accidental].join
+    @spellings[key] ||= new(letter_name, accidental)
   end
 
-  def initialize(letter, accidental = nil)
-    @letter = HeadMusic::LetterName.get(letter.to_s)
+  def initialize(letter_name, accidental = nil)
+    @letter_name = HeadMusic::LetterName.get(letter_name.to_s)
     @accidental = HeadMusic::Accidental.get(accidental.to_s)
     accidental_semitones = @accidental ? @accidental.semitones : 0
-    @pitch_class = HeadMusic::PitchClass.get(letter.pitch_class + accidental_semitones)
+    @pitch_class = HeadMusic::PitchClass.get(letter_name.pitch_class + accidental_semitones)
   end
 
   def name
-    [letter, accidental].join
+    [letter_name, accidental].join
   end
 
   def to_s

data/lib/head_music/version.rb

@@ -1,3 +1,3 @@
 module HeadMusic
-  VERSION = "0.5.3"
+  VERSION = "0.5.4"
 end

data/lib/head_music.rb

@@ -6,16 +6,19 @@ require 'humanize'
 
 require 'head_music/accidental'
 require 'head_music/circle'
+require 'head_music/clef'
 require 'head_music/consonance'
 require 'head_music/functional_interval'
 require 'head_music/interval'
 require 'head_music/key_signature'
 require 'head_music/letter_name'
 require 'head_music/meter'
+require 'head_music/note'
 require 'head_music/octave'
 require 'head_music/pitch_class'
 require 'head_music/pitch'
 require 'head_music/quality'
+require 'head_music/rhythmic_unit'
 require 'head_music/rhythmic_value'
 require 'head_music/scale'
 require 'head_music/scale_type'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: head_music
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.5.4
 platform: ruby
 authors:
 - Rob Head
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-23 00:00:00.000000000 Z
+date: 2017-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -116,16 +116,19 @@ files:
 - lib/head_music.rb
 - lib/head_music/accidental.rb
 - lib/head_music/circle.rb
+- lib/head_music/clef.rb
 - lib/head_music/consonance.rb
 - lib/head_music/functional_interval.rb
 - lib/head_music/interval.rb
 - lib/head_music/key_signature.rb
 - lib/head_music/letter_name.rb
 - lib/head_music/meter.rb
+- lib/head_music/note.rb
 - lib/head_music/octave.rb
 - lib/head_music/pitch.rb
 - lib/head_music/pitch_class.rb
 - lib/head_music/quality.rb
+- lib/head_music/rhythmic_unit.rb
 - lib/head_music/rhythmic_value.rb
 - lib/head_music/scale.rb
 - lib/head_music/scale_type.rb