head_music 0.8.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 56a211e11bb35239af47cdf2e79e2032b6b97f7b
-  data.tar.gz: 293be36552913da8cd64f946b4b1ece210114991
+  metadata.gz: f3c4a7d9f36e3a577a3b3e15dde8e3b9b8719937
+  data.tar.gz: dc196e99e9f17077d7135fb17047a07a8fee13be
 SHA512:
-  metadata.gz: d809adbad72a56eca2910a2c234d6497028d3c0a9723bfd02a214cf62f22e44777c38ff08a20707beff1d65e59cd9b5e8ddacacce82d2d64b9b826c48a5c3329
-  data.tar.gz: a2aa89d2b462c9a8dd938ddef98376a78a4a1a2ba7dd721e2f4e39913f5074c53d201465ae1ba0e59e11d6706e4905cb74434bb596b892b903dc298604e2ba06
+  metadata.gz: 1fa70d04a30f7f652420d88224192f4a2dd89a8436a363a3306129336d3a61a390ecd0d4c8baf2a7ca9cd05798dc4bbd09e0969bf0107335a7adaa3a3ae7f195
+  data.tar.gz: 95a836da90aa931b77935d7558c2fb6710b9b559ec69578b39451655551e058bfa19ef68fdea8541dbb24912011d34490d61e34f9baf4eff65f22fd8fec48f85

data/lib/head_music/accidental.rb

@@ -11,7 +11,6 @@ class HeadMusic::Accidental
   def self.get(identifier)
     for_symbol(identifier) || for_interval(identifier)
   end
-  singleton_class.send(:alias_method, :[], :get)
 
   def self.for_symbol(identifier)
     @accidentals ||= {}

data/lib/head_music/{measure.rb → bar.rb}

@@ -1,4 +1,4 @@
-class HeadMusic::Measure
+class HeadMusic::Bar
   attr_reader :composition
 
   delegate :key_signature, :meter, to: :composition
@@ -8,7 +8,7 @@ class HeadMusic::Measure
   end
 
   # TODO: encapsulate key changes and meter changes
-  # Assume the key and meter of the previous measure
-  # all the way back to the first measure,
+  # Assume the key and meter of the previous bar
+  # all the way back to the first bar,
   # which defaults to the key and meter of the composition
 end

data/lib/head_music/circle.rb

@@ -11,7 +11,6 @@ class HeadMusic::Circle
     @circles ||= {}
     @circles[interval.to_i] ||= new(interval)
   end
-  singleton_class.send(:alias_method, :[], :get)
 
   attr_reader :interval, :pitch_classes
 

data/lib/head_music/composition.rb

@@ -1,26 +1,26 @@
 class HeadMusic::Composition
-  attr_reader :name, :key_signature, :meter, :measures, :voices
+  attr_reader :name, :key_signature, :meter, :bars, :voices
 
   def initialize(name:, key_signature: nil, meter: nil)
     ensure_attributes(name, key_signature, meter)
-    add_measure
+    add_bar
     add_voice
   end
 
-  def add_measure
-    add_measures(1)
+  def add_bar
+    add_bars(1)
   end
 
-  def add_measures(number)
-    @measures ||= []
+  def add_bars(number)
+    @bars ||= []
     number.times do
-      @measures << HeadMusic::Measure.new(self)
+      @bars << HeadMusic::Bar.new(self)
     end
   end
 
   def add_voice
     @voices ||= []
-    @voices << HeadMusic::Voice.new(self)
+    @voices << HeadMusic::Voice.new(composition: self)
   end
 
   private

data/lib/head_music/consonance.rb

@@ -5,7 +5,6 @@ class HeadMusic::Consonance
     @consonances ||= {}
     @consonances[name.to_sym] ||= new(name) if LEVELS.include?(name.to_s)
   end
-  singleton_class.send(:alias_method, :[], :get)
 
   attr_reader :name
 

data/lib/head_music/functional_interval.rb

@@ -22,10 +22,9 @@ class HeadMusic::FunctionalInterval
     seventeenth: { major: 28 }
   }
 
-  attr_reader :lower_pitch, :higher_pitch
+  attr_reader :lower_pitch, :higher_pitch, :direction
 
   delegate :to_s, to: :name
-  delegate :==, to: :to_s
   delegate :perfect?, :major?, :minor?, :diminished?, :augmented?, :doubly_diminished?, :doubly_augmented?, to: :quality
 
   def self.get(name)
@@ -38,7 +37,6 @@ class HeadMusic::FunctionalInterval
     higher_pitch = HeadMusic::Pitch.from_number_and_letter(lower_pitch + semitones, higher_letter)
     new(lower_pitch, higher_pitch)
   end
-  singleton_class.send(:alias_method, :[], :get)
 
   def self.degree_quality_semitones
     @degree_quality_semitones ||= begin
@@ -62,7 +60,29 @@ class HeadMusic::FunctionalInterval
   end
 
   def initialize(pitch1, pitch2)
-    @lower_pitch, @higher_pitch = [HeadMusic::Pitch.get(pitch1), HeadMusic::Pitch.get(pitch2)].sort
+    pitch1 = HeadMusic::Pitch.get(pitch1)
+    pitch2 = HeadMusic::Pitch.get(pitch2)
+    set_direction(pitch1, pitch2)
+    @lower_pitch, @higher_pitch = [pitch1, pitch2].sort
+  end
+
+  def set_direction(pitch1, pitch2)
+    @direction =
+      if pitch1 == pitch2
+        :none
+      elsif pitch1 < pitch2
+        :ascending
+      else
+        :descending
+      end
+  end
+
+  def descending?
+    direction == :descending
+  end
+
+  def ascending?
+    direction == :ascending
   end
 
   def number
@@ -108,7 +128,8 @@ class HeadMusic::FunctionalInterval
   end
 
   def shorthand
-    [quality.shorthand, number].join
+    step_shorthand = number == 1 ? 'U' : number
+    [quality.shorthand, step_shorthand].join
   end
 
   def quality
@@ -157,12 +178,20 @@ class HeadMusic::FunctionalInterval
     end
   end
 
+  def step?
+    number <= 2
+  end
+
   def skip?
-    number > 2
+    number == 3
   end
 
-  def step?
-    number <= 2
+  def leap?
+    number > 3
+  end
+
+  def ==(other)
+    self.to_s.gsub(/\W/, '_') == other.to_s.gsub(/\W/, '_')
   end
 
   NUMBER_NAMES.each do |method_name|

data/lib/head_music/interval.rb

@@ -11,7 +11,6 @@ class HeadMusic::Interval
     @intervals ||= {}
     @intervals[semitones.to_i] ||= new(semitones.to_i)
   end
-  singleton_class.send(:alias_method, :[], :get)
 
   def self.named(name)
     name = name.to_s

data/lib/head_music/letter_name.rb

@@ -18,7 +18,6 @@ class HeadMusic::LetterName
   def self.get(identifier)
     from_name(identifier) || from_pitch_class(identifier)
   end
-  singleton_class.send(:alias_method, :[], :get)
 
   def self.from_name(name)
     @letter_names ||= {}

data/lib/head_music/melodic_interval.rb

@@ -0,0 +1,29 @@
+class HeadMusic::MelodicInterval
+  attr_reader :voice, :first_note, :second_note
+
+  def initialize(voice, note1, note2)
+    @voice = voice
+    @first_note = note1
+    @second_note = note2
+  end
+
+  def functional_interval
+    @functional_interval ||= HeadMusic::FunctionalInterval.new(first_note.pitch, second_note.pitch)
+  end
+
+  def position_start
+    first_note.position
+  end
+
+  def position_end
+    second_note.next_position
+  end
+
+  def to_s
+    [direction, functional_interval].join(' ')
+  end
+
+  def method_missing(method_name, *args, &block)
+    functional_interval.send(method_name, *args, &block)
+  end
+end

data/lib/head_music/meter.rb

@@ -50,11 +50,11 @@ class HeadMusic::Meter
     top_number == 4
   end
 
-  def beats_per_measure
+  def beats_per_bar
     compound? ? top_number / 3 : top_number
   end
 
-  def counts_per_measure
+  def counts_per_bar
     top_number
   end
 
@@ -101,12 +101,12 @@ class HeadMusic::Meter
 
   def strong_counts
     @strong_counts ||= begin
-      (1..counts_per_measure).select do |count|
+      (1..counts_per_bar).select do |count|
         count == 1 ||
-        count == counts_per_measure / 2.0 + 1 ||
+        count == counts_per_bar / 2.0 + 1 ||
         (
-          counts_per_measure % 3 == 0 &&
-          counts_per_measure > 6 &&
+          counts_per_bar % 3 == 0 &&
+          counts_per_bar > 6 &&
           count % 3 == 1
         )
       end

data/lib/head_music/note.rb

@@ -1,14 +1,18 @@
 class HeadMusic::Note
-  attr_reader :pitch, :rhythmic_value
+  attr_accessor :pitch, :rhythmic_value, :voice, :position
 
-  delegate :ticks, to: :rhythmic_value
-
-  def initialize(pitch, rhythmic_unit, rhythmic_value_modifiers = {})
+  def initialize(pitch, rhythmic_value, voice = nil, position = nil)
     @pitch = HeadMusic::Pitch.get(pitch)
-    @rhythmic_value = HeadMusic::RhythmicValue.new(rhythmic_unit, rhythmic_value_modifiers)
+    @rhythmic_value = HeadMusic::RhythmicValue.get(rhythmic_value)
+    @voice = voice || Voice.new
+    @position = position || HeadMusic::Position.new(@voice.composition, '1:1')
+  end
+
+  def placement
+    @placement ||= HeadMusic::Placement.new(voice, position, rhythmic_value, pitch)
   end
 
-  def duration
-    rhythmic_value.total_value
+  def method_missing(method_name, *args, &block)
+    placement.send(method_name, *args, &block)
   end
 end

data/lib/head_music/octave.rb

@@ -8,7 +8,6 @@ class HeadMusic::Octave
   def self.get(identifier)
     from_number(identifier) || from_name(identifier) || default
   end
-  singleton_class.send(:alias_method, :[], :get)
 
   def self.from_number(identifier)
     return nil unless identifier.to_s == identifier.to_i.to_s

data/lib/head_music/pitch.rb

@@ -14,7 +14,6 @@ class HeadMusic::Pitch
   def self.get(value)
     from_name(value) || from_number(value)
   end
-  singleton_class.send(:alias_method, :[], :get)
 
   def self.from_name(name)
     return nil unless name == name.to_s

data/lib/head_music/pitch_class.rb

@@ -10,7 +10,6 @@ class HeadMusic::PitchClass
     number ||= identifier.to_i % 12
     @pitch_classes[number] ||= new(number)
   end
-  singleton_class.send(:alias_method, :[], :get)
 
   class << self
     alias_method :[], :get

data/lib/head_music/placement.rb

@@ -3,8 +3,9 @@ class HeadMusic::Placement
 
   attr_reader :voice, :position, :rhythmic_value, :pitch
   delegate :composition, to: :voice
+  delegate :spelling, to: :pitch, allow_nil: true
 
-  def initialize(voice, position, rhythmic_value, pitch)
+  def initialize(voice, position, rhythmic_value, pitch = nil)
     ensure_attributes(voice, position, rhythmic_value, pitch)
   end
 
@@ -16,6 +17,10 @@ class HeadMusic::Placement
     !note?
   end
 
+  def next_position
+    position + rhythmic_value
+  end
+
   def <=>(other)
     self.position <=> other.position
   end

data/lib/head_music/position.rb

@@ -1,20 +1,22 @@
 class HeadMusic::Position
   include Comparable
 
-  attr_reader :composition, :measure_number, :count, :tick
+  attr_reader :composition, :bar_number, :count, :tick
   delegate :to_s, to: :code
   delegate :meter, to: :composition
 
-  def initialize(composition, code_or_measure, count = nil, tick = nil)
-    if code_or_measure.is_a?(String) && code_or_measure =~ /\D/
-      ensure_state(composition, *code_or_measure.split(/\D+/))
+  def initialize(composition, code_or_bar, count = nil, tick = nil)
+    if code_or_bar.is_a?(String) && code_or_bar =~ /\D/
+      bar, count, tick = code_or_bar.split(/\D+/)
+      ensure_state(composition, bar, count, tick)
     else
-      ensure_state(composition, code_or_measure, count, tick)
+      ensure_state(composition, code_or_bar, count, tick)
     end
   end
 
   def code
-    values.join(':')
+    tick_string = tick.to_s.rjust(3, '0')
+    [bar_number, count, tick_string].join(':')
   end
 
   def state
@@ -22,10 +24,13 @@ class HeadMusic::Position
   end
 
   def values
-    [measure_number, count, tick]
+    [bar_number, count, tick]
   end
 
   def <=>(other)
+    if other.is_a?(String) && other =~ /\D/
+      other = self.class.new(composition, other)
+    end
     self.values <=> other.values
   end
 
@@ -41,11 +46,22 @@ 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)
+  end
+
+  def start_of_next_bar
+    self.class.new(composition, bar_number + 1, 1, 0)
+  end
+
   private
 
-  def ensure_state(composition, measure_number, count, tick)
+  def ensure_state(composition, bar_number, count, tick = nil)
     @composition = composition
-    @measure_number = measure_number.to_i
+    @bar_number = bar_number.to_i
     @count = (count || 1).to_i
     @tick = (tick || 0).to_i
     roll_over_units
@@ -57,16 +73,18 @@ class HeadMusic::Position
   end
 
   def roll_over_ticks
-    while @tick > meter.ticks_per_count
+    # TODO account for meter changes in bars
+    while @tick >= meter.ticks_per_count
       @tick -= meter.ticks_per_count.to_i
       @count += 1
     end
   end
 
   def roll_over_counts
-    while @count > meter.counts_per_measure
-      @count -= meter.counts_per_measure
-      @measure_number += 1
+    # TODO account for meter changes in bars
+    while @count > meter.counts_per_bar
+      @count -= meter.counts_per_bar
+      @bar_number += 1
     end
   end
 end

data/lib/head_music/quality.rb

@@ -31,7 +31,6 @@ class HeadMusic::Quality
     identifier = identifier.to_s.to_sym
     @qualities[identifier] ||= new(identifier) if NAMES.include?(identifier)
   end
-  singleton_class.send(:alias_method, :[], :get)
 
   def self.from(starting_quality, delta)
     if starting_quality == :perfect

data/lib/head_music/rhythmic_unit.rb

@@ -10,7 +10,6 @@ class HeadMusic::RhythmicUnit
     hash_key = HeadMusic::Utilities::HashKey.for(name)
     @rhythmic_units[hash_key] ||= new(name.to_s)
   end
-  singleton_class.send(:alias_method, :[], :get)
 
   def self.for_denominator_value(denominator)
     get(FRACTIONS[Math.log2(denominator).to_i])

data/lib/head_music/rhythmic_value.rb

@@ -4,6 +4,39 @@ class HeadMusic::RhythmicValue
   delegate :name, to: :unit, prefix: true
   delegate :to_s, to: :name
 
+  def self.get(identifier)
+    case identifier
+    when RhythmicValue
+      identifier
+    when RhythmicUnit
+      new(identifier)
+    when Symbol, String
+      identifier = identifier.to_s.downcase.strip.gsub(/\W+/, '_')
+      from_words(identifier)
+    end
+  end
+
+  def self.from_words(identifier)
+    new(unit_from_words(identifier), dots: dots_from_words(identifier))
+  end
+
+  def self.unit_from_words(identifier)
+    identifier.gsub(/^\w*dotted_/, '')
+  end
+
+  def self.dots_from_words(identifier)
+    return 0 unless identifier =~ /dotted/
+    modifier, _ = identifier.split(/_*dotted_*/)
+    case modifier
+    when /tripl\w/
+      3
+    when /doubl\w/
+      2
+    else
+      1
+    end
+  end
+
   def initialize(unit, dots: nil, tied_value: nil)
     @unit = HeadMusic::RhythmicUnit.get(unit)
     @dots = [0, 1, 2, 3].include?(dots) ? dots : 0

data/lib/head_music/scale_type.rb

@@ -64,7 +64,6 @@ class HeadMusic::ScaleType
     attributes = SCALE_TYPES[name]
     @scale_types[name] ||= new(name, attributes)
   end
-  singleton_class.send(:alias_method, :[], :get)
 
   def self.default
     get(:major)

data/lib/head_music/spelling.rb

@@ -13,7 +13,6 @@ class HeadMusic::Spelling
   def self.get(identifier)
     from_name(identifier) || from_number(identifier)
   end
-  singleton_class.send(:alias_method, :[], :get)
 
   def self.match(string)
     string.to_s.match(MATCHER)

data/lib/head_music/style/analysis.rb

@@ -0,0 +1,17 @@
+module HeadMusic
+  module Style
+    class Analysis
+      attr_reader :ruleset, :subject, :annotations
+
+      def initialize(ruleset, subject)
+        @ruleset = ruleset
+        @subject = subject
+        @annotations = @ruleset.analyze(subject)
+      end
+
+      def fitness
+        annotations.map(&:fitness).reduce(1, :*)
+      end
+    end
+  end
+end

data/lib/head_music/style/annotation.rb

@@ -0,0 +1,28 @@
+class HeadMusic::Style::Annotation
+  attr_reader :fitness, :message, :marks, :subject
+
+  def initialize(subject:, fitness:, message: nil, marks: nil)
+    @subject = subject
+    @fitness = fitness
+    @message = message
+    @marks = [marks].flatten.compact
+  end
+
+  def voice
+    subject if subject.is_a?(HeadMusic::Voice)
+  end
+
+  def composition
+    voice ? voice.composition : subject
+  end
+
+  def marks_count
+    marks ? marks.length : 0
+  end
+
+  def first_mark_code
+    marks.first.code if marks.first
+  end
+
+  alias_method :to_s, :message
+end

data/lib/head_music/style/mark.rb

@@ -0,0 +1,29 @@
+class HeadMusic::Style::Mark
+  attr_reader :start_position, :end_position, :placements
+
+  def self.for(placement)
+    new(placement.position, placement.next_position, placement)
+  end
+
+  def self.for_all(placements)
+    placements = [placements].flatten
+    start_position = placements.map { |placement| placement.position }.sort.first
+    end_position = placements.map { |placement| placement.next_position }.sort.last
+    new(start_position, end_position, placements)
+  end
+
+  def self.for_each(placements)
+    placements = [placements].flatten
+    placements.map { |placement| new(placement.position, placement.next_position, placement) }
+  end
+
+  def initialize(start_position, end_position, placements = [])
+    @start_position = start_position
+    @end_position = end_position
+    @placements = [placements].flatten
+  end
+
+  def code
+    [start_position, end_position].join(' to ')
+  end
+end

data/lib/head_music/style/rule.rb

@@ -0,0 +1,13 @@
+class HeadMusic::Style::Rule
+  # returns a score between 0 and 1
+  # Note: absence of a problem or 'not applicable' should score as a 1.
+  # for example, if the rule is to end on the tonic,
+  #   a composition with no notes should count as a 1.
+  def fitness(object)
+    raise NotImplementedError, 'A fitness method is required for all style rules.'
+  end
+
+  def self.annotations(object)
+    raise NotImplementedError, 'An annotations method is required for all style rules.'
+  end
+end

data/lib/head_music/style/rules/always_move.rb

@@ -0,0 +1,19 @@
+module HeadMusic::Style::Rules
+end
+
+class HeadMusic::Style::Rules::AlwaysMove < HeadMusic::Style::Rule
+  def self.analyze(voice)
+    marks = marks(voice)
+    fitness = HeadMusic::GOLDEN_RATIO_INVERSE**marks.length
+    message = "Always move to another note." if fitness < 1
+    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: marks, message: message)
+  end
+
+  def self.marks(voice)
+    voice.melodic_intervals.map.with_index do |interval, i|
+      if interval.shorthand == 'PU'
+        HeadMusic::Style::Mark.for_all(voice.notes[i..i+1])
+      end
+    end.reject(&:nil?)
+  end
+end

data/lib/head_music/style/rules/at_least_eight_notes.rb

@@ -0,0 +1,26 @@
+module HeadMusic::Style::Rules
+end
+
+class HeadMusic::Style::Rules::AtLeastEightNotes < HeadMusic::Style::Rule
+  MINIMUM_NOTES = 8
+
+  def self.analyze(voice)
+    fitness = fitness(voice)
+    mark = mark(voice)
+    message = "Add notes until you have at least eight notes." if fitness < 1
+    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: mark, message: message)
+  end
+
+  def self.fitness(voice)
+    deficiency = MINIMUM_NOTES - voice.notes.length
+    deficiency > 0 ? HeadMusic::GOLDEN_RATIO_INVERSE**deficiency : 1
+  end
+
+  def self.mark(voice)
+    if voice.placements.empty?
+      Style::Mark.new(Position.new(voice.composition, "1:1"), Position.new(voice.composition, "2:1"))
+    else
+      Style::Mark.for_all(voice.placements)
+    end
+  end
+end

data/lib/head_music/style/rules/diatonic.rb

@@ -0,0 +1,15 @@
+module HeadMusic::Style::Rules
+end
+
+class HeadMusic::Style::Rules::Diatonic < HeadMusic::Style::Rule
+  def self.analyze(voice)
+    marks = marks(voice)
+    fitness = HeadMusic::GOLDEN_RATIO_INVERSE**marks.length
+    message = "Use only notes in the key signature." if fitness < 1
+    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: marks, message: message)
+  end
+
+  def self.marks(voice)
+    HeadMusic::Style::Mark.for_each(voice.notes_not_in_key)
+  end
+end

data/lib/head_music/style/rules/end_on_tonic.rb

@@ -0,0 +1,27 @@
+module HeadMusic::Style::Rules
+end
+
+class HeadMusic::Style::Rules::EndOnTonic < HeadMusic::Style::Rule
+  def self.analyze(voice)
+    fitness = fitness(voice)
+    if fitness < 1
+      message = 'End on the tonic'
+      mark = HeadMusic::Style::Mark.for(voice.notes.last)
+    end
+    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: mark, message: message)
+  end
+
+  def self.fitness(voice)
+    return 1 if voice.notes.empty?
+    return 1 if ends_on_tonic?(voice)
+    HeadMusic::GOLDEN_RATIO_INVERSE
+  end
+
+  def self.ends_on_tonic?(voice)
+    voice.notes &&
+    voice.notes.last &&
+    voice.composition &&
+    voice.composition.key_signature &&
+    voice.composition.key_signature.tonic_spelling == voice.notes.last.spelling
+  end
+end

data/lib/head_music/style/rules/limit_range.rb

@@ -0,0 +1,31 @@
+module HeadMusic::Style::Rules
+end
+
+class HeadMusic::Style::Rules::LimitRange < HeadMusic::Style::Rule
+  MAXIMUM_RANGE = 10
+
+  def self.analyze(voice)
+    fitness = fitness(voice)
+    if fitness < 1
+      message = 'Limit melodic range to a 10th.'
+      marks = marks(voice)
+    end
+    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: marks, message: message)
+  end
+
+  def self.fitness(voice)
+    return 1 unless voice.notes.length > 0
+    HeadMusic::GOLDEN_RATIO_INVERSE**overage(voice)
+  end
+
+  def self.overage(voice)
+    voice.notes.length > 0 ? [voice.range.number - MAXIMUM_RANGE, 0].max : 0
+  end
+
+  def self.marks(voice)
+    if voice.notes
+      extremes = (voice.highest_notes + voice.lowest_notes).sort
+      HeadMusic::Style::Mark.for_each(extremes)
+    end
+  end
+end

data/lib/head_music/style/rules/mostly_conjunct.rb

@@ -0,0 +1,30 @@
+module HeadMusic::Style::Rules
+end
+
+class HeadMusic::Style::Rules::MostlyConjunct < HeadMusic::Style::Rule
+  def self.analyze(voice)
+    fitness = fitness(voice)
+    if fitness < 1
+      marks = marks(voice)
+      message = "Use only notes in the key signature."
+    end
+    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: marks, message: message)
+  end
+
+  def self.fitness(voice)
+    intervals = voice.melodic_intervals.length
+    steps = voice.melodic_intervals.count { |interval| interval.step? }
+    fitness = 1
+    fitness *= HeadMusic::GOLDEN_RATIO_INVERSE if steps.to_f / intervals < 0.5
+    fitness *= HeadMusic::GOLDEN_RATIO_INVERSE if steps.to_f / intervals < 0.25
+    fitness
+  end
+
+  def self.marks(voice)
+    voice.melodic_intervals.map.with_index do |interval, i|
+      if !interval.step?
+        HeadMusic::Style::Mark.for_all(voice.notes[i..i+1])
+      end
+    end
+  end
+end

data/lib/head_music/style/rules/no_rests.rb

@@ -0,0 +1,14 @@
+module HeadMusic::Style::Rules
+end
+
+class HeadMusic::Style::Rules::NoRests < HeadMusic::Style::Rule
+  def self.analyze(voice)
+    rests = voice.rests
+    fitness = HeadMusic::GOLDEN_RATIO_INVERSE**rests.length
+    if rests.length > 0
+      message = "Change rests to notes."
+      marks = rests.map { |rest| HeadMusic::Style::Mark.for_all(rest) }
+    end
+    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: marks, message: message)
+  end
+end

data/lib/head_music/style/rules/notes_same_length.rb

@@ -0,0 +1,49 @@
+module HeadMusic::Style::Rules
+end
+
+class HeadMusic::Style::Rules::NotesSameLength < HeadMusic::Style::Rule
+  def self.analyze(voice)
+    fitness = fitness(voice)
+    if fitness < 1
+      message = "Use consistent rhythmic unit."
+    end
+    marks = marks(voice)
+    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: marks, message: message)
+  end
+
+  def self.fitness(voice)
+    distinct_values = [distinct_values(voice), 1].max
+    HeadMusic::GOLDEN_RATIO_INVERSE**(distinct_values-1)
+  end
+
+  def self.distinct_values(voice)
+    voice.notes[0..-2].map(&:rhythmic_value).uniq.length
+  end
+
+  def self.marks(voice)
+    preferred_value = first_most_common_rhythmic_value(voice)
+    wrong_length_notes = voice.notes.select { |note| note.rhythmic_value != preferred_value }
+    HeadMusic::Style::Mark.for_each(wrong_length_notes)
+  end
+
+  def self.first_most_common_rhythmic_value(voice)
+    candidates = most_common_rhythmic_values(voice)
+    first_match = voice.notes.detect { |note| candidates.include?(note.rhythmic_value) }
+    first_match ? first_match.rhythmic_value : nil
+  end
+
+  def self.most_common_rhythmic_values(voice)
+    return [] if voice.notes.empty?
+    occurrences = occurrences_by_rhythmic_value(voice)
+    highest_count = occurrences.values.sort.last
+    occurrences.select { |rhythmic_value, count| count == highest_count }.keys
+  end
+
+  def self.occurrences_by_rhythmic_value(voice)
+    rhythmic_values(voice).inject(Hash.new(0)) { |hash, value| hash[value] += 1; hash }
+  end
+
+  def self.rhythmic_values(voice)
+    voice.notes.map(&:rhythmic_value)
+  end
+end

data/lib/head_music/style/rules/start_on_tonic.rb

@@ -0,0 +1,27 @@
+module HeadMusic::Style::Rules
+end
+
+class HeadMusic::Style::Rules::StartOnTonic < HeadMusic::Style::Rule
+  def self.analyze(voice)
+    fitness = fitness(voice)
+    if fitness < 1
+      message = 'Start on the tonic.'
+      mark = HeadMusic::Style::Mark.for(voice.notes.last)
+    end
+    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: mark, message: message)
+  end
+
+  def self.fitness(voice)
+    return 1 if voice.notes.empty?
+    return 1 if starts_on_tonic?(voice)
+    HeadMusic::GOLDEN_RATIO_INVERSE
+  end
+
+  def self.starts_on_tonic?(voice)
+    voice.notes &&
+    voice.notes.first &&
+    voice.composition &&
+    voice.composition.key_signature &&
+    voice.composition.key_signature.tonic_spelling == voice.notes.first.spelling
+  end
+end

data/lib/head_music/style/rules/step_down_to_final_note.rb

@@ -0,0 +1,34 @@
+module HeadMusic::Style::Rules
+end
+
+class HeadMusic::Style::Rules::StepDownToFinalNote < HeadMusic::Style::Rule
+  def self.analyze(voice)
+    fitness = fitness(voice)
+    if fitness < 1
+      message = 'Step down to final note.'
+      mark = HeadMusic::Style::Mark.for_all(voice.notes[-2..-1])
+    end
+    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: mark, message: message)
+  end
+
+  def self.fitness(voice)
+    return 1 unless voice.notes.length >= 2
+    fitness = 1
+    fitness *= HeadMusic::GOLDEN_RATIO_INVERSE unless step?(voice)
+    fitness *= HeadMusic::GOLDEN_RATIO_INVERSE unless descending?(voice)
+    fitness
+  end
+
+  def self.descending?(voice)
+    last_melodic_interval(voice).descending?
+  end
+
+  def self.step?(voice)
+    last_melodic_interval(voice).step?
+  end
+
+  def self.last_melodic_interval(voice)
+    @last_melodic_interval ||= {}
+    @last_melodic_interval[voice] ||= voice.melodic_intervals.last
+  end
+end

data/lib/head_music/style/rules/up_to_thirteen_notes.rb

@@ -0,0 +1,24 @@
+module HeadMusic::Style::Rules
+end
+
+class HeadMusic::Style::Rules::UpToThirteenNotes < HeadMusic::Style::Rule
+  MAXIMUM_NOTES = 13
+
+  def self.analyze(voice)
+    fitness = fitness(voice)
+    if fitness < 1
+      mark = mark(voice)
+    end
+    message = "Remove notes until you have at most thirteen notes." if fitness < 1
+    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: mark, message: message)
+  end
+
+  def self.fitness(voice)
+    overage = voice.notes.length - MAXIMUM_NOTES
+    overage > 0 ? HeadMusic::GOLDEN_RATIO_INVERSE**overage : 1
+  end
+
+  def self.mark(voice)
+    Style::Mark.for_all(voice.notes[13..-1])
+  end
+end

data/lib/head_music/style/rulesets/cantus_firmus.rb

@@ -0,0 +1,22 @@
+module HeadMusic::Style::Rulesets
+end
+
+class HeadMusic::Style::Rulesets::CantusFirmus
+  RULESET = [
+    HeadMusic::Style::Rules::AlwaysMove,
+    HeadMusic::Style::Rules::AtLeastEightNotes,
+    HeadMusic::Style::Rules::Diatonic,
+    HeadMusic::Style::Rules::EndOnTonic,
+    HeadMusic::Style::Rules::LimitRange,
+    HeadMusic::Style::Rules::MostlyConjunct,
+    HeadMusic::Style::Rules::NoRests,
+    HeadMusic::Style::Rules::NotesSameLength,
+    HeadMusic::Style::Rules::StartOnTonic,
+    HeadMusic::Style::Rules::StepDownToFinalNote,
+    HeadMusic::Style::Rules::UpToThirteenNotes,
+  ]
+
+  def self.analyze(voice)
+    RULESET.map { |rule| rule.analyze(voice) }
+  end
+end

data/lib/head_music/utilities/hash_key.rb

@@ -1,8 +1,8 @@
 module HeadMusic
   module Utilities
     class HashKey
-      def self.for(name)
-        name.to_s.downcase.gsub(/\W+/, '_').to_sym
+      def self.for(identifier)
+        identifier.to_s.downcase.gsub(/\W+/, '_').to_sym
       end
     end
   end

data/lib/head_music/version.rb

@@ -1,3 +1,3 @@
 module HeadMusic
-  VERSION = "0.8.0"
+  VERSION = "0.10.0"
 end

data/lib/head_music/voice.rb

@@ -1,10 +1,12 @@
 class HeadMusic::Voice
   include Comparable
 
-  attr_reader :composition, :placements
+  attr_reader :composition, :placements, :role
+  delegate :key_signature, to: :composition
 
-  def initialize(composition = nil)
-    @composition = composition || Composition.new(name: "Unnamed")
+  def initialize(composition: nil, role: nil)
+    @composition = composition || Composition.new(name: "Composition")
+    @role = role
     @placements = []
   end
 
@@ -14,6 +16,49 @@ class HeadMusic::Voice
     }
   end
 
+  def notes
+    @placements.select(&:note?)
+  end
+
+  def notes_not_in_key
+    key_spellings = key_signature.pitches.map(&:spelling).uniq
+    notes.reject { |note| key_spellings.include? note.pitch.spelling }
+  end
+
+  def pitches
+    notes.map(&:pitch)
+  end
+
+  def rests
+    @placements.select(&:rest?)
+  end
+
+  def highest_pitch
+    pitches.sort.last
+  end
+
+  def lowest_pitch
+    pitches.sort.first
+  end
+
+  def highest_notes
+    notes.select { |note| note.pitch == highest_pitch }
+  end
+
+  def lowest_notes
+    notes.select { |note| note.pitch == lowest_pitch }
+  end
+
+  def range
+    HeadMusic::FunctionalInterval.new(lowest_pitch, highest_pitch)
+  end
+
+  def melodic_intervals
+    notes.map.with_index do |note, i|
+      HeadMusic::MelodicInterval.new(self, notes[i-1], note) if i > 0
+    end.reject(&:nil?)
+  end
+
   private
 
   def insert_into_placements(placement)

data/lib/head_music.rb

@@ -5,8 +5,10 @@ require 'active_support/core_ext/string/access'
 require 'humanize'
 
 require 'head_music/accidental'
+require 'head_music/bar'
 require 'head_music/circle'
 require 'head_music/clef'
+require 'head_music/composition'
 require 'head_music/consonance'
 require 'head_music/functional_interval'
 require 'head_music/grand_staff'
@@ -14,13 +16,12 @@ require 'head_music/instrument'
 require 'head_music/interval'
 require 'head_music/key_signature'
 require 'head_music/letter_name'
-require 'head_music/composition'
-require 'head_music/measure'
+require 'head_music/melodic_interval'
 require 'head_music/meter'
 require 'head_music/note'
 require 'head_music/octave'
-require 'head_music/pitch_class'
 require 'head_music/pitch'
+require 'head_music/pitch_class'
 require 'head_music/placement'
 require 'head_music/position'
 require 'head_music/quality'
@@ -31,8 +32,30 @@ require 'head_music/scale'
 require 'head_music/scale_type'
 require 'head_music/spelling'
 require 'head_music/staff'
-require 'head_music/voice'
+
+require 'head_music/style/analysis'
+require 'head_music/style/annotation'
+require 'head_music/style/mark'
+require 'head_music/style/rule'
+
+require 'head_music/style/rules/always_move'
+require 'head_music/style/rules/at_least_eight_notes'
+require 'head_music/style/rules/diatonic'
+require 'head_music/style/rules/end_on_tonic'
+require 'head_music/style/rules/limit_range'
+require 'head_music/style/rules/mostly_conjunct'
+require 'head_music/style/rules/no_rests'
+require 'head_music/style/rules/notes_same_length'
+require 'head_music/style/rules/start_on_tonic'
+require 'head_music/style/rules/step_down_to_final_note'
+require 'head_music/style/rules/up_to_thirteen_notes'
+
+require 'head_music/style/rulesets/cantus_firmus'
+
 require 'head_music/utilities/hash_key'
+require 'head_music/voice'
 
 module HeadMusic
+  GOLDEN_RATIO = (1 + 5**0.5) / 2.0
+  GOLDEN_RATIO_INVERSE = 1 / GOLDEN_RATIO
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: head_music
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Rob Head
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-04 00:00:00.000000000 Z
+date: 2017-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -117,6 +117,7 @@ files:
 - head_music.gemspec
 - lib/head_music.rb
 - lib/head_music/accidental.rb
+- lib/head_music/bar.rb
 - lib/head_music/circle.rb
 - lib/head_music/clef.rb
 - lib/head_music/composition.rb
@@ -127,7 +128,7 @@ files:
 - lib/head_music/interval.rb
 - lib/head_music/key_signature.rb
 - lib/head_music/letter_name.rb
-- lib/head_music/measure.rb
+- lib/head_music/melodic_interval.rb
 - lib/head_music/meter.rb
 - lib/head_music/note.rb
 - lib/head_music/octave.rb
@@ -143,6 +144,22 @@ files:
 - lib/head_music/scale_type.rb
 - lib/head_music/spelling.rb
 - lib/head_music/staff.rb
+- lib/head_music/style/analysis.rb
+- lib/head_music/style/annotation.rb
+- lib/head_music/style/mark.rb
+- lib/head_music/style/rule.rb
+- lib/head_music/style/rules/always_move.rb
+- lib/head_music/style/rules/at_least_eight_notes.rb
+- lib/head_music/style/rules/diatonic.rb
+- lib/head_music/style/rules/end_on_tonic.rb
+- lib/head_music/style/rules/limit_range.rb
+- lib/head_music/style/rules/mostly_conjunct.rb
+- lib/head_music/style/rules/no_rests.rb
+- lib/head_music/style/rules/notes_same_length.rb
+- lib/head_music/style/rules/start_on_tonic.rb
+- lib/head_music/style/rules/step_down_to_final_note.rb
+- lib/head_music/style/rules/up_to_thirteen_notes.rb
+- lib/head_music/style/rulesets/cantus_firmus.rb
 - lib/head_music/utilities/hash_key.rb
 - lib/head_music/version.rb
 - lib/head_music/voice.rb