music-transcription 0.19.0 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f5b490ee5916154f2376f07568ccd234ff6fb82a
-  data.tar.gz: 2a2fff2f3b7e94deacc2438d510f1d803cf6efcb
+  metadata.gz: 31245c605d780f4ff342ad6a33f9296a05a1dba1
+  data.tar.gz: 9be01f0138f712d589178163b62d71439f6e0c4f
 SHA512:
-  metadata.gz: 797d3b962ded3291e92d8ba49a390072663d1ae37b0e7e957b3acc562d2d1793d569a7c117fd750de3bb99e03ed4d935cc0b13338c95e669993128acbd246902
-  data.tar.gz: e0ae19e64aa43b0dc274d61601db32cbcccf87b33226c312e4f76407f7e87b7694a4f678c32de08bf17a714da5aa2e113a7ca15b470dbc2e8b48dbab07360489
+  metadata.gz: 80e8d7b289839c11bf75ef05e1786d1fa058c43e82f2ae67e3bae242954dca33fbd2eb2013664e481c41c5f1517a3a38664eabe45fdab187a63f7a6c30c0b917
+  data.tar.gz: dff4b97a87751abafebc8f95364b85b47d453773e838e4c3e896840d2a31b00e32ca6688e444c2a342b96e5b0d7385bba8d602e6055d7e52a2d05d86d5bcdb97

data/lib/music-transcription.rb

@@ -46,3 +46,7 @@ require 'music-transcription/packing/part_packing'
 require 'music-transcription/packing/program_packing'
 require 'music-transcription/packing/note_score_packing'
 require 'music-transcription/packing/measure_score_packing'
+
+require 'music-transcription/conversion/tempo_conversion'
+require 'music-transcription/conversion/measure_note_map'
+require 'music-transcription/conversion/measure_score_conversion'

data/lib/music-transcription/conversion/measure_note_map.rb

@@ -0,0 +1,42 @@
+module Music
+module Transcription
+
+module Conversion
+  # Converte offsets from measure-based to note-based.
+  # @param [Array] measure_offsets Measure offsets to be converted
+  # @param [Hash] measure_durations Map measure durations to measure offsets where the duration takes effect.
+  # @raise [NonZeroError] if first measure duration is not mapped to offset 0
+  def self.measure_note_map measure_offsets, measure_durations
+    mnoff_map = {}
+    moffs = measure_offsets.uniq.sort
+    mdurs = measure_durations.sort
+    cur_noff = 0.to_r
+    j = 0 # next measure offset to be converted
+    
+    if mdurs[0][0] != 0
+      raise NonZeroError, "measure offset of 1st measure duration must be 0, not #{mdurs[0][0]}"
+    end
+    
+    (0...mdurs.size).each do |i|
+      cur_moff, cur_mdur = mdurs[i]
+      if i < (mdurs.size - 1)
+        next_moff = mdurs[i+1][0]        
+      else
+        next_moff = Float::INFINITY
+      end
+      
+      while(j < moffs.size && moffs[j] <= next_moff) do
+        moff = moffs[j]
+        mnoff_map[moff] = cur_noff + (moff - cur_moff)*cur_mdur
+        j += 1
+      end
+      
+      cur_noff += (next_moff - cur_moff) * cur_mdur
+    end
+    
+    return mnoff_map
+  end
+end
+
+end
+end

data/lib/music-transcription/conversion/measure_score_conversion.rb

@@ -0,0 +1,152 @@
+module Music
+module Transcription
+
+class MeasureScore
+  # Convert to NoteScore object by first converting measure-based offsets to
+  # note-based offsets, and eliminating the use of meters. Also, tempo is
+  # to non-BPM tempo.
+  def to_note_score tempo_class = Tempo::QNPM
+    unless valid?
+      raise NotValidError, "Current MeasureScore is invalid, so it can not be \
+                            converted to a NoteScore. Validation errors: #{self.errors}"
+    end
+    
+    unless NoteScore.valid_tempo_types.include? tempo_class
+      raise TypeError, "The desired tempo class #{tempo_class} is not valid for a NoteScore."
+    end
+    
+    mnoff_map = self.measure_note_map
+    parts = convert_parts(mnoff_map)
+    prog = convert_program(mnoff_map)
+    tcs = convert_tempo_changes(tempo_class, mnoff_map)
+    start_tempo = @start_tempo.convert(tempo_class,@start_meter.beat_duration)
+    
+    NoteScore.new(start_tempo, parts: parts, program: prog, tempo_changes: tcs)
+  end
+  
+  def measure_note_map
+    Conversion::measure_note_map(measure_offsets,measure_durations)
+  end
+  
+  def convert_parts mnoff_map = self.measure_note_map
+    Hash[ @parts.map do |name,part|
+      new_dcs = Hash[ part.dynamic_changes.map do |moff,change|
+        noff = mnoff_map[moff]
+        noff2 = mnoff_map[moff + change.duration]
+        [noff, change.resize(noff2-noff)]
+      end ]
+      new_notes = part.notes.map {|n| n.clone }
+      [name, Part.new(part.start_dynamic,
+        notes: new_notes, dynamic_changes: new_dcs)]
+    end ]
+  end
+  
+  def convert_program mnoff_map = self.measure_note_map
+    Program.new(
+      @program.segments.map do |seg|
+        mnoff_map[seg.first]...mnoff_map[seg.last]
+      end
+    )
+  end
+  
+  def convert_tempo_changes tempo_class, mnoff_map = self.measure_note_map
+    tcs = {}
+    bdurs = beat_durations
+    
+    @tempo_changes.each do |moff,change|
+      bdur = bdurs.select {|x,y| x <= moff}.max[1]
+      tempo = change.value
+      
+      case change
+      when Change::Immediate
+        tcs[mnoff_map[moff]] = Change::Immediate.new(tempo.convert(tempo_class,bdur))
+      when Change::Gradual
+        start_moff, end_moff = moff, moff + change.duration
+        start_noff, end_noff = mnoff_map[start_moff], mnoff_map[end_moff]
+        dur = end_noff - start_noff
+        cur_noff, cur_bdur = start_noff, bdur
+
+        more_bdurs = bdurs.select {|x,y| x > moff && x < end_moff }
+        if more_bdurs.any?
+          more_bdurs.each do |next_moff, next_bdur|
+            next_noff = mnoff_map[next_moff]
+            tcs[cur_noff] = Change::Partial.new(
+              tempo.convert(tempo_class, cur_bdur), dur,
+              cur_noff - start_noff, next_noff - start_noff)
+            cur_noff, cur_bdur = next_noff, next_bdur
+          end
+          tcs[cur_noff] = Change::Partial.new(
+            tempo.convert(tempo_class, cur_bdur), dur,
+            cur_noff - start_noff, dur)
+        else
+          tcs[start_noff] = Change::Gradual.new(
+            tempo.convert(tempo_class, cur_bdur), end_noff - start_noff)
+        end
+      when Change::Partial
+        raise NotImplementedError, "No support yet for converting partial tempo changes."
+      end
+    end
+    
+    return tcs
+  end
+  
+  def beat_duration_at moff
+    beat_durations.select {|k,v| k <= moff }.max[1]
+  end
+  
+  def measure_offsets
+    moffs = Set.new([0.to_r])
+    
+    @tempo_changes.each do |moff,change|
+      moffs.add(moff)
+      if change.duration > 0
+        moffs.add(moff + change.duration)
+      end
+    end
+    
+    @meter_changes.keys.each {|moff| moffs.add(moff) }
+    
+    @parts.values.each do |part|
+      part.dynamic_changes.each do |moff,change|
+        moffs.add(moff)
+        if change.duration > 0
+          moffs.add(moff + change.duration)
+        end
+      end
+    end
+    
+    @program.segments.each do |seg|
+      moffs.add(seg.first)
+      moffs.add(seg.last)
+    end
+    
+    return moffs.sort
+  end
+
+  def beat_durations
+    bdurs = @meter_changes.map do |offset,change|
+      [ offset, change.value.beat_duration ]
+    end.sort
+    
+    if bdurs.empty? || bdurs[0][0] != 0
+      bdurs.unshift([0,@start_meter.beat_duration])
+    end
+  
+    return bdurs
+  end
+  
+  def measure_durations
+    mdurs = @meter_changes.map do |offset,change|
+      [ offset, change.value.measure_duration ]
+    end.sort
+    
+    if mdurs.empty? || mdurs[0][0] != 0
+      mdurs.unshift([0,@start_meter.measure_duration])
+    end
+  
+    return Hash[ mdurs ]
+  end  
+end
+  
+end
+end

data/lib/music-transcription/conversion/tempo_conversion.rb

@@ -0,0 +1,77 @@
+module Music
+module Transcription
+
+class Tempo
+  def convert tgt_class, bdur = nil
+    args = (is_a?(BPM) || tgt_class == BPM) ? [bdur] : []
+    
+    return case tgt_class.new(1)
+    when self.class then self.clone
+    when Tempo::QNPM then to_qnpm(*args)
+    when Tempo::NPM then to_npm(*args)
+    when Tempo::NPS then to_nps(*args)
+    when Tempo::BPM then to_bpm(*args)
+    else
+      raise TypeError, "Unexpected target tempo class #{tgt_class}"
+    end
+  end
+  
+  class QNPM < Tempo
+    def to_npm
+      Tempo::NPM.new(Rational(@value,4))
+    end
+    
+    def to_nps
+      Tempo::NPS.new(Rational(@value,240))
+    end
+    
+    def to_bpm beat_dur
+      Tempo::BPM.new(Rational(@value,4*beat_dur))
+    end
+  end
+
+  class NPM < Tempo
+    def to_qnpm
+      Tempo::QNPM.new(4*@value)
+    end
+    
+    def to_nps
+      Tempo::NPS.new(Rational(@value,60))
+    end
+    
+    def to_bpm beat_dur
+      Tempo::BPM.new(Rational(@value,beat_dur))
+    end
+  end
+  
+  class BPM < Tempo
+    def to_qnpm beat_dur
+      Tempo::QNPM.new(4*beat_dur*@value)
+    end
+    
+    def to_nps beat_dur
+      Tempo::NPS.new(Rational(@value*beat_dur,60))
+    end
+    
+    def to_npm beat_dur
+      Tempo::NPM.new(beat_dur*@value)
+    end
+  end
+  
+  class NPS < Tempo
+    def to_qnpm
+      Tempo::QNPM.new(Rational(240,@value))
+    end
+    
+    def to_bpm beat_dur
+      Tempo::BPM.new(Rational(60,@value*beat_dur))
+    end
+    
+    def to_npm
+      Tempo::NPM.new(Rational(60,@value))
+    end
+  end
+end
+
+end
+end

data/lib/music-transcription/errors.rb

@@ -6,5 +6,6 @@ module Transcription
   class NonIntegerError < StandardError; end
   class NonRationalError < StandardError; end
   class NonIncreasingError < StandardError; end
+  class NotValidError < StandardError; end
 end
 end

data/lib/music-transcription/model/change.rb

@@ -2,7 +2,7 @@ module Music
 module Transcription
 
 class Change
-  attr_accessor :value, :duration
+  attr_reader :value, :duration
   
   def initialize value, duration
     @value = value
@@ -16,38 +16,66 @@ class Change
   end
 
   class Immediate < Change
-    include Validatable
-
     def initialize value
       super(value,0)
     end
     
-    def check_methods
-      [ :ensure_zero_duration ]
+    def clone
+      Immediate.new(@value)
     end
     
-    def ensure_zero_duration
-      unless @duration == 0
-        raise NonZeroError, "immediate change duration #{self.duration} must be 0"
-      end
+    def resize newdur
+      self.clone
     end
   end
   
   class Gradual < Change
-    include Validatable
+    def initialize value, transition_dur
+      if transition_dur <= 0
+        raise NonPositiveError, "transition duration #{transition_dur} must be positive"
+      end
+      super(value, transition_dur)
+    end
     
-    def initialize value, transition_duration
-      super(value, transition_duration)
+    def clone
+      Gradual.new(@value,@duration)
     end
     
-    def check_methods
-      [ :ensure_nonnegative_duration ]
+    def resize newdur
+      Gradual.new(@value,newdur)
     end
+  end
+  
+  class Partial < Change
+    attr_reader :total_duration, :elapsed, :stop
     
-    def ensure_nonnegative_duration
-      if @duration < 0
-        raise NegativeError, "gradual change duration #{self.duration} must be non-negative"
+    def initialize value, total_dur, elapsed, stop
+      if elapsed < 0
+        raise NegativeError, "elapsed (#{elapsed}) is < 0"
+      end
+      
+      if stop <= 0
+        raise NonPositiveError, "stop (#{stop}) is < 0"
       end
+
+      if stop > total_dur
+        raise ArgumentError, "stop (#{stop}) is > total duration (#{total_dur})"
+      end
+      
+      if stop <= elapsed
+        raise ArgumentError, "stop (#{stop}) is <= elapsed (#{elapsed})"
+      end
+
+      @total_duration = total_dur
+      @elapsed = elapsed
+      @stop = stop
+      super(value,stop - elapsed)
+    end
+    
+    def ==(other)
+      super() &&
+      @elapsed == other.elapsed &&
+      @stop == other.stop
     end
   end
 end

data/lib/music-transcription/model/measure_score.rb

@@ -8,21 +8,22 @@ class MeasureScore < NoteScore
     @start_meter = start_meter
     @meter_changes = meter_changes
     
-    super(start_tempo, tempo_changes: tempo_changes, program: program, parts: parts)
+    super(start_tempo, tempo_changes: tempo_changes,
+          program: program, parts: parts)
     yield(self) if block_given?
   end
   
   def check_methods
-    super() + [:check_startmeter_type, :check_meterchange_types, :check_meterchange_durs]
+    super() + [:check_startmeter_type, :check_meterchange_types,
+               :check_meterchange_durs, :check_meterchange_offsets]
   end
   
   def validatables
-    super() + [ @start_meter ] + @meter_changes.values +
-      @meter_changes.values.map {|v| v.value}
+    super() + [ @start_meter ] + @meter_changes.values.map {|v| v.value}
   end
   
-  def valid_tempo_types
-    super() + [ Tempo::BPM ]
+  def self.valid_tempo_types
+    NoteScore.valid_tempo_types + [ Tempo::BPM ]
   end
   
   def check_startmeter_type
@@ -38,24 +39,24 @@ class MeasureScore < NoteScore
     end
   end
   
+  def check_meterchange_offsets
+    badoffsets = @meter_changes.select {|k,v| k != k.to_i }
+    if badoffsets.any?
+      raise NonIntegerError, "meter changes #{badoffsets} have non-integer offsets"
+    end
+  end
+  
   def check_meterchange_durs
-    nonzero_duration = @meter_changes.select {|k,v| v.duration != 0 }
+    nonzero_duration = @meter_changes.select {|k,v| !v.is_a?(Change::Immediate) }
     if nonzero_duration.any?
-      raise NonZeroError, "meter changes #{nonzero_duration} have non-zero duration"
+      raise NonZeroError, "meter changes #{nonzero_duration} are not immediate"
     end
   end
   
   def ==(other)
     return super() && @start_meter == other.start_meter &&
       @meter_changes == other.meter_changes
-  end
-    
-  # Convert to NoteScore object by first converting measure-based offsets to
-  # note-based offsets, and eliminating the use of meters. Also, tempo is
-  # converted from beats-per-minute to notes-per-minute.
-  def to_note_score
-    
-  end
+  end    
 end
 
 end

data/lib/music-transcription/model/note.rb

@@ -13,6 +13,9 @@ class Note
   
   def initialize duration, pitches = [], articulation: DEFAULT_ARTICULATION, accented: false, links: {}
     @duration = duration
+    if !pitches.is_a? Enumerable
+      pitches = [ pitches ]
+    end
     @pitches = Set.new(pitches).sort
     @articulation = articulation
     @accented = accented

data/lib/music-transcription/model/note_score.rb

@@ -20,23 +20,25 @@ class NoteScore
   end
   
   def validatables
-    [ @program ] + @tempo_changes.values + @parts.values
+    [ @program ] + @parts.values
   end
   
-  def valid_tempo_types
+  def self.valid_tempo_types
     [ Tempo::QNPM, Tempo::NPM, Tempo::NPS ]
   end
   
   def check_start_tempo_type
-    unless valid_tempo_types.include?(@start_tempo.class)
-      raise TypeError, "type of start tempo #{@start_tempo} is not one of valid tempo types: #{valid_tempo_types}"
+    vtts = self.class.valid_tempo_types
+    unless vtts.include?(@start_tempo.class)
+      raise TypeError, "type of start tempo #{@start_tempo} is not one of valid tempo types: #{vtts}"
     end
   end
 
   def check_tempo_change_types
-    baddtypes = @tempo_changes.select {|k,v| !valid_tempo_types.include?(v.value.class) }
+    vtts = self.class.valid_tempo_types
+    baddtypes = @tempo_changes.select {|k,v| !vtts.include?(v.value.class) }
     if baddtypes.any?
-      raise NonPositiveError, "type of tempo change values #{baddtypes} are not one of valid tempo types: #{valid_tempo_types}"
+      raise NonPositiveError, "type of tempo change values #{baddtypes} are not one of valid tempo types: #{vtts}"
     end
   end
   

data/lib/music-transcription/model/part.rb

@@ -21,7 +21,7 @@ class Part
   end
   
   def validatables
-    @notes + @dynamic_changes.values
+    @notes
   end
   
   def clone

data/lib/music-transcription/model/tempo.rb

@@ -12,15 +12,14 @@ class Tempo
     self.class == other.class && self.value == other.value
   end
   
-  [ :qnpm, :bpm, :npm, :nps ].each do |sym|
-    klass = Class.new(Tempo) do
-      def to_s
-        "#{@value}#{self.class::PRINT_SYM}"
-      end
-    end
-    klass.const_set(:PRINT_SYM,sym)
-    Tempo.const_set(sym.upcase,klass)
+  def clone
+    self.class.new(@value)
   end
+  
+  class QNPM < Tempo; def to_s; "#{@value}qnpm" end; end
+  class NPM < Tempo; def to_s; "#{@value}npm" end; end
+  class BPM < Tempo; def to_s; "#{@value}bpm" end; end
+  class NPS < Tempo; def to_s; "#{@value}nps" end; end
 end
 
 end

data/lib/music-transcription/version.rb

@@ -2,6 +2,6 @@
 module Music
 module Transcription
   # music-transcription version
-  VERSION = "0.19.0"
+  VERSION = "0.20.0"
 end
 end

data/spec/conversion/measure_note_map_spec.rb

@@ -0,0 +1,73 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'Conversion.measure_note_map' do
+  before :all do
+    mdurs = Hash[ [[0, (3/4)], [1, (1/2)], [3, (3/4)]] ]
+    @moffs = [ 0, 1, 3, 4, 5, 6, 7, 8, 11, 14, 17, 20, (45/2)]
+    @mnoff_map = Conversion.measure_note_map(@moffs,mdurs)
+  end
+  
+  it 'should return a Hash' do
+    @mnoff_map.should be_a Hash
+  end
+  
+  it 'should have same size as array returned by #measure_offsets' do
+    @mnoff_map.size.should eq(@moffs.size)
+  end
+  
+  it 'should have a key for each offset in the array returned by #measure_offsets' do
+    @mnoff_map.keys.sort.should eq(@moffs)
+  end
+  
+  context 'single measure duration at 0' do
+    it 'should mutiply all measure offsets by start measure duration' do
+      [TWO_FOUR,SIX_EIGHT,FOUR_FOUR,THREE_FOUR].each do |meter|
+        mdur = meter.measure_duration
+        mdurs = { 0 => mdur }
+        tgt = @moffs.map {|moff| moff * mdur}
+        Conversion.measure_note_map(@moffs,mdurs).values.sort.should eq(tgt)
+      end
+    end
+  end
+  
+  context '1 meter change' do
+    before :all do
+      @first_mc_off = 3
+      @start_meter = THREE_FOUR
+      @new_meter = TWO_FOUR
+      @score = MeasureScore.new(@start_meter, Tempo::BPM.new(120),
+        meter_changes: { @first_mc_off => Change::Immediate.new(@new_meter) },
+        tempo_changes: {
+          "1/2".to_r => Change::Gradual.new(Tempo::BPM.new(100),1),
+          2 => Change::Immediate.new(Tempo::BPM.new(120)),
+          3 => Change::Immediate.new(Tempo::BPM.new(100)),
+          3.1 => Change::Gradual.new(Tempo::BPM.new(100),1),
+          5 => Change::Immediate.new(Tempo::BPM.new(120)),
+          6 => Change::Immediate.new(Tempo::BPM.new(100)),
+        }
+      )
+      @moffs = @score.measure_offsets
+      @mdurs = @score.measure_durations
+      @mnoff_map = Conversion.measure_note_map(@moffs,@mdurs)
+    end
+    
+    it 'should mutiply all measure offsets that occur on or before 1st meter change offset by start measure duration' do
+      moffs = @moffs.select{ |x| x <= @first_mc_off }
+      tgt = moffs.map do |moff|
+        moff * @start_meter.measure_duration
+      end.sort
+      src = @mnoff_map.select {|k,v| k <= @first_mc_off }
+      src.values.sort.should eq(tgt)
+    end
+    
+    it 'should, for any measure offsets occurring after 1st meter change offset, add 1st_meter_change_offset * 1st_measure_duration to \
+        new_measure_duration * (offset - 1st_meter_change_offset)' do
+      moffs = @moffs.select{ |x| x > @first_mc_off }
+      tgt = moffs.map do |moff|
+        @first_mc_off * @start_meter.measure_duration + (moff - @first_mc_off) * @new_meter.measure_duration
+      end.sort
+      src = @mnoff_map.select {|k,v| k > @first_mc_off }
+      src.values.sort.should eq(tgt)
+    end
+  end
+end

data/spec/conversion/measure_score_conversion_spec.rb

@@ -0,0 +1,405 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe MeasureScore do
+  before :all do
+    @parts = {
+      "piano" => Part.new(Dynamics::MP,
+        notes: [Note.quarter(C4), Note.eighth(F3), Note.whole(C4), Note.half(D4)]*12,
+        dynamic_changes: {
+          1 => Change::Immediate.new(Dynamics::MF),
+          5 => Change::Immediate.new(Dynamics::FF),
+          6 => Change::Gradual.new(Dynamics::MF,2),
+          14 => Change::Immediate.new(Dynamics::PP),
+        }
+      )
+    }
+    @prog = Program.new([0...3,4...7,1...20,17..."45/2".to_r])
+    tcs = {
+      0 => Change::Immediate.new(Tempo::BPM.new(120)),
+      4 => Change::Gradual.new(Tempo::BPM.new(60),2),
+      11 => Change::Immediate.new(Tempo::BPM.new(110))
+    }
+    mcs = {
+      1 => Change::Immediate.new(TWO_FOUR),
+      3 => Change::Immediate.new(SIX_EIGHT)
+    }
+    @score = MeasureScore.new(THREE_FOUR, Tempo::BPM.new(120),
+      parts: @parts,
+      program: @prog,
+      tempo_changes: tcs,
+      meter_changes: mcs
+    )
+  end
+
+  describe '#measure_offsets' do
+    before(:all){ @moffs = @score.measure_offsets }
+    
+    it 'should return an already-sorted array' do
+      @moffs.should eq @moffs.sort
+    end
+    
+    it 'should start with offset from start tempo/meter/dynamic' do
+      @moffs[0].should eq(0)
+    end
+    
+    it 'should include offsets from tempo changes' do
+      @score.tempo_changes.each do |moff,change|
+        @moffs.should include(moff)
+        @moffs.should include(moff + change.duration)
+      end
+    end
+    
+    it 'should include offsets from meter changes' do
+      @score.meter_changes.keys.each {|moff| @moffs.should include(moff) }
+    end
+    
+    it "should include offsets from each part's dynamic changes" do
+      @score.parts.values.each do |part|
+        part.dynamic_changes.each do |moff,change|
+          @moffs.should include(moff)
+          @moffs.should include(moff + change.duration)
+        end
+      end
+    end
+    
+    it 'should include offsets from program segments' do
+      @score.program.segments.each do |seg|
+        @moffs.should include(seg.first)
+        @moffs.should include(seg.last)
+      end
+    end
+  end
+  
+  describe '#measure_durations' do
+    before(:all){ @mdurs = @score.measure_durations }
+    
+    it 'should return a Hash' do
+      @mdurs.should be_a Hash
+    end
+    
+    context 'no meter change at offset 0' do
+      it 'should have size of meter_changes.size + 1' do
+        @mdurs.size.should eq(@score.meter_changes.size + 1)
+      end
+      
+      it 'should begin with offset 0' do
+        @mdurs.keys.min.should eq(0)
+      end
+      
+      it 'should map start meter to offset 0' do
+        @mdurs[0].should eq(@score.start_meter.measure_duration)
+      end
+    end
+    
+    context 'meter change at offset 0' do
+      before :all do
+        @change = Change::Immediate.new(THREE_FOUR)
+        @score2 = MeasureScore.new(FOUR_FOUR, Tempo::BPM.new(120), meter_changes: { 0 => @change })
+        @mdurs2 = @score2.measure_durations
+      end
+  
+      it 'should have same size as meter changes' do
+        @mdurs2.size.should eq(@score2.meter_changes.size)
+      end
+      
+      it 'should begin with offset 0' do
+        @mdurs2.keys.min.should eq(0)
+      end
+      
+      it 'should begin with meter change at offset 0, instead of start meter' do
+        @mdurs2[0].should eq(@change.value.measure_duration)
+      end
+    end
+    
+    context 'no meter changes' do
+      before :all do
+        @score3 = MeasureScore.new(FOUR_FOUR, Tempo::BPM.new(120))
+        @mdurs3 = @score3.measure_durations
+      end
+  
+      it 'should have size 1' do
+        @mdurs3.size.should eq(1)
+      end
+      
+      it 'should begin with offset 0' do
+        @mdurs3.keys.min.should eq(0)
+      end
+      
+      it 'should begin with start meter' do
+        @mdurs3[0].should eq(@score3.start_meter.measure_duration)
+      end
+    end
+  end
+    
+  describe '#covert_parts' do
+    before :each do
+      @changeA = Change::Immediate.new(Dynamics::PP)
+      @changeB = Change::Gradual.new(Dynamics::F, 2)
+      @score = MeasureScore.new(FOUR_FOUR, Tempo::BPM.new(120),
+        parts: {"simple" => Part.new(Dynamics::MP, dynamic_changes: { 1 => @changeA, 3 => @changeB })}
+      )
+    end
+    
+    it 'should return Hash with original part names' do
+      parts = @score.convert_parts
+      parts.should be_a Hash
+      parts.keys.sort.should eq(@score.parts.keys.sort)
+    end
+    
+    it 'should convert part dynamic change offsets from measure-based to note-based' do
+      parts = @score.convert_parts
+      parts.should have_key("simple")
+      part = parts["simple"]
+      part.dynamic_changes.keys.sort.should eq([1,3])
+      change = part.dynamic_changes[Rational(1,1)]
+      change.value.should eq(@changeA.value)
+      change.duration.should eq(0)
+      change = part.dynamic_changes[Rational(3,1)]
+      change.value.should eq(@changeB.value)
+      change.duration.should eq(2)
+      
+      @score.start_meter = THREE_FOUR
+      parts = @score.convert_parts
+      parts.should have_key("simple")
+      part = parts["simple"]
+      part.dynamic_changes.keys.sort.should eq([Rational(3,4),Rational(9,4)])
+      change = part.dynamic_changes[Rational(3,4)]
+      change.value.should eq(@changeA.value)
+      change.duration.should eq(0)
+      change = part.dynamic_changes[Rational(9,4)]
+      change.value.should eq(@changeB.value)
+      change.duration.should eq(1.5)
+    end
+  end
+  
+  describe '#convert_program' do
+    before :each do
+      @prog = Program.new([0...4,2...5])
+      @score = MeasureScore.new(FOUR_FOUR, Tempo::BPM.new(120), program: @prog)
+    end
+    
+    it 'shuld return Program with same number of segments' do
+      prog = @score.convert_program
+      prog.should be_a Program
+      prog.segments.size.should eq(@score.program.segments.size)
+    end
+  
+    it 'should convert program segments offsets from measure-based to note-based' do
+      prog = @score.convert_program
+      prog.segments.size.should eq(2)
+      prog.segments[0].first.should eq(0)
+      prog.segments[0].last.should eq(4)
+      prog.segments[1].first.should eq(2)
+      prog.segments[1].last.should eq(5)
+      
+      @score.start_meter = THREE_FOUR
+      prog = @score.convert_program
+      prog.segments.size.should eq(2)
+      prog.segments[0].first.should eq(0)
+      prog.segments[0].last.should eq(3)
+      prog.segments[1].first.should eq(1.5)
+      prog.segments[1].last.should eq(3.75)
+    end
+  end
+  
+  describe '#convert_tempo_changes' do
+    context 'immediate tempo changes' do
+      before :all do
+        @score = MeasureScore.new(THREE_FOUR, Tempo::BPM.new(120),
+          tempo_changes: { 1 => Change::Immediate.new(Tempo::BPM.new(100)),
+            2.5 => Change::Immediate.new(Tempo::NPS.new(1.5)),
+          4 => Change::Immediate.new(Tempo::NPM.new(22.5)),
+          7 => Change::Immediate.new(Tempo::QNPM.new(90)) }
+        )
+        @tempo_type = Tempo::QNPM
+        @tcs = @score.convert_tempo_changes(@tempo_type)
+      end
+      
+      it 'should change offset from measure-based to note-based' do
+        @tcs.keys.sort.should eq([0.75, 1.875, 3, 5.25])
+      end
+      
+      it 'should convert tempo type to given type' do
+        @tcs.values.each {|change| change.value.should be_a @tempo_type }
+      end
+    end
+    
+    context 'gradual tempo changes' do
+      context 'no meter changes within tempo change duration' do
+        before :all do
+          @score = MeasureScore.new(THREE_FOUR, Tempo::BPM.new(120),
+            tempo_changes: { 2 => Change::Gradual.new(Tempo::BPM.new(100),2) },
+            meter_changes: { 1 => Change::Immediate.new(TWO_FOUR),
+                             4 => Change::Immediate.new(SIX_EIGHT) }
+          )
+          @tempo_type = Tempo::QNPM
+          @tcs = @score.convert_tempo_changes(@tempo_type)
+        end
+  
+        it 'should change tempo change offset to note-based' do
+          @tcs.keys.should eq([Rational(5,4)])
+        end
+        
+        it 'should convert the tempo change' do
+          @tcs[Rational(5,4)].value.should be_a @tempo_type
+        end
+        
+        it 'should convert change duration to note-based' do
+          @tcs[Rational(5,4)].duration.should eq(1)
+        end
+      end
+      
+      context 'single meter change within tempo change duration' do
+        before :all do
+          @tc_moff, @mc_moff = 2, 4
+          @tc_dur = 4
+          @score = MeasureScore.new(THREE_FOUR, Tempo::BPM.new(120),
+            tempo_changes: { @tc_moff => Change::Gradual.new(Tempo::BPM.new(100),@tc_dur) },
+            meter_changes: { @mc_moff => Change::Immediate.new(SIX_EIGHT) }
+          )
+          @tempo_type = Tempo::QNPM
+          @tcs = @score.convert_tempo_changes(@tempo_type)
+          @mnoff_map = @score.measure_note_map
+        end
+  
+        it 'should split the one gradual change into two partial changes' do
+          @tcs.size.should eq(2)
+          @tcs.values.each {|x| x.should be_a Change::Partial }
+        end
+        
+        it 'should start first partial change where gradual change would start' do
+          @tcs.should have_key(@mnoff_map[@tc_moff])
+        end
+        
+        it 'should stop first partial, and start second partial change where inner meter change occurs' do
+          pc1_start_noff = @mnoff_map[@tc_moff]
+          pc1_end_noff  = pc1_start_noff + @tcs[pc1_start_noff].duration
+          
+          pc2_start_noff = @mnoff_map[@mc_moff]
+          @tcs.should have_key(pc2_start_noff)
+          pc1_end_noff.should eq(pc2_start_noff)
+        end
+        
+        it 'should stop second partial change where gradual change would end' do
+          pc2_start_noff = @mnoff_map[@mc_moff]
+          pc2_end_noff = pc2_start_noff + @tcs[pc2_start_noff].duration
+          pc2_end_noff.should eq(@mnoff_map[@tc_moff + @tc_dur])
+        end
+      end
+
+      context 'two meter changes within tempo change duration' do
+        before :all do
+          @tc_moff, @mc1_moff, @mc2_moff = 2, 4, 5
+          @tc_dur = 5
+          @score = MeasureScore.new(THREE_FOUR, Tempo::BPM.new(120),
+            tempo_changes: { @tc_moff => Change::Gradual.new(Tempo::BPM.new(100),@tc_dur) },
+            meter_changes: { @mc1_moff => Change::Immediate.new(SIX_EIGHT),
+                             @mc2_moff => Change::Immediate.new(TWO_FOUR) }
+          )
+          @tempo_type = Tempo::QNPM
+          @tcs = @score.convert_tempo_changes(@tempo_type)
+          @mnoff_map = @score.measure_note_map
+        end
+  
+        it 'should split the one gradual change into three partial changes' do
+          @tcs.size.should eq(3)
+          @tcs.values.each {|x| x.should be_a Change::Partial }
+        end
+        
+        it 'should start first partial change where gradual change would start' do
+          @tcs.should have_key(@mnoff_map[@tc_moff])
+        end
+        
+        it 'should stop first partial, and start second partial change where 1st meter change occurs' do
+          pc1_start_noff = @mnoff_map[@tc_moff]
+          pc1_end_noff  = pc1_start_noff + @tcs[pc1_start_noff].duration
+          
+          pc2_start_noff = @mnoff_map[@mc1_moff]
+          @tcs.should have_key(pc2_start_noff)
+          pc1_end_noff.should eq(pc2_start_noff)
+        end
+        
+        it 'should stop second partial, and start third partial change where 2st meter change occurs' do
+          pc2_start_noff = @mnoff_map[@mc1_moff]
+          pc2_end_noff  = pc2_start_noff + @tcs[pc2_start_noff].duration
+          
+          pc3_start_noff = @mnoff_map[@mc2_moff]
+          @tcs.should have_key(pc3_start_noff)
+          pc2_end_noff.should eq(pc3_start_noff)
+        end
+        
+        it 'should stop third partial change where gradual change would end' do
+          pc3_start_noff = @mnoff_map[@mc2_moff]
+          pc3_end_noff = pc3_start_noff + @tcs[pc3_start_noff].duration
+          pc3_end_noff.should eq(@mnoff_map[@tc_moff + @tc_dur])
+        end
+      end
+    end
+    
+    context 'partial tempo changes' do
+      it 'should raise NotImplementedError' do
+        @score = MeasureScore.new(THREE_FOUR, Tempo::BPM.new(120),
+          tempo_changes: { 1 => Change::Partial.new(Tempo::BPM.new(100),10,2,3)}
+        )
+        expect { @score.convert_tempo_changes(Tempo::QNPM) }.to raise_error(NotImplementedError)
+      end
+    end
+  end
+  
+  describe '#to_note_score' do
+    context 'current score is invalid' do
+      it 'should raise NotValidError' do
+        score = MeasureScore.new(1, Tempo::BPM.new(120))
+        expect { score.to_note_score }.to raise_error(NotValidError)
+      end
+    end
+    
+    context 'given desired tempo class is not valid for NoteScore' do
+      it 'should raise TypeError' do
+        score = MeasureScore.new(FOUR_FOUR, Tempo::BPM.new(120))
+        expect {score.to_note_score(Tempo::BPM) }.to raise_error(TypeError)
+      end
+    end
+    
+    it 'should return a NoteScore' do
+      score = MeasureScore.new(FOUR_FOUR, Tempo::BPM.new(120))
+      score.to_note_score(Tempo::QNPM).should be_a NoteScore
+    end
+  
+    it 'should convert start tempo according to given desired tempo class' do
+      score = MeasureScore.new(FOUR_FOUR, Tempo::BPM.new(120))
+      { Tempo::QNPM => 120, Tempo::NPM => 30, Tempo::NPS => 0.5 }.each do |tempo_class, tgt_val|
+        nscore = score.to_note_score(tempo_class)
+        nscore.start_tempo.should be_a tempo_class
+        nscore.start_tempo.value.should eq(tgt_val)
+      end
+    end
+    
+    it 'should use output from convert_program' do
+      prog = Program.new([0...4,2...5])
+      score = MeasureScore.new(FOUR_FOUR, Tempo::BPM.new(120), program: prog)
+      nscore = score.to_note_score(Tempo::QNPM)
+      nscore.program.should eq(score.convert_program)
+    end
+    
+    it 'should use output from convert_parts' do
+      changeA = Change::Immediate.new(Dynamics::PP)
+      changeB = Change::Gradual.new(Dynamics::F, 2)
+      score = MeasureScore.new(FOUR_FOUR, Tempo::BPM.new(120),
+        parts: {"simple" => Part.new(Dynamics::MP, dynamic_changes: { 1 => changeA, 3 => changeB })}
+      )
+      nscore = score.to_note_score(Tempo::QNPM)
+      nscore.parts.should eq(score.convert_parts)
+    end
+  
+    it 'should use output from convert_program' do
+      changeA = Change::Immediate.new(Dynamics::PP)
+      changeB = Change::Gradual.new(Dynamics::F, 2)
+      score = MeasureScore.new(FOUR_FOUR, Tempo::BPM.new(120),
+        parts: {"simple" => Part.new(Dynamics::MP, dynamic_changes: { 1 => changeA, 3 => changeB })}
+      )
+      nscore = score.to_note_score(Tempo::QNPM)
+      nscore.parts.should eq(score.convert_parts)
+    end
+  end
+end

data/spec/conversion/tempo_conversion_spec.rb

@@ -0,0 +1,152 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Tempo::QNPM do
+  before :all do
+    @tempo = Tempo::QNPM.new(60)
+  end
+  
+  describe '#to_npm' do
+    it 'should return a Tempo::NPM object' do
+      @tempo.to_npm.should be_a Tempo::NPM
+    end
+    
+    it 'should change tempo value to be 1/4th' do
+      @tempo.to_npm.value.should eq(Rational(60,4))
+    end
+  end
+  
+  describe '#to_nps' do
+    it 'should return a Tempo::NPS object' do
+      @tempo.to_nps.should be_a Tempo::NPS
+    end
+    
+    it 'should change tempo value to be 1/240th' do
+      @tempo.to_nps.value.should eq(Rational(1,4))
+    end
+  end
+  
+  describe '#to_bpm' do
+    it 'should return a Tempo::BPM object' do
+      @tempo.to_bpm(Rational(1,4)).should be_a Tempo::BPM
+    end
+    
+    it 'should divide tempo value by (4*beatdur)' do
+      @tempo.to_bpm(Rational(1,4)).value.should eq(60)
+      @tempo.to_bpm(Rational(1,2)).value.should eq(30)
+    end
+  end
+end
+
+describe Tempo::NPM do
+  before :all do
+    @tempo = Tempo::NPM.new(60)
+  end
+  
+  describe '#to_qnpm' do
+    it 'should return a Tempo::QNPM object' do
+      @tempo.to_qnpm.should be_a Tempo::QNPM
+    end
+    
+    it 'should multiply tempo value by 4' do
+      @tempo.to_qnpm.value.should eq(240)
+    end
+  end
+  
+  describe '#to_nps' do
+    it 'should return a Tempo::NPS object' do
+      @tempo.to_nps.should be_a Tempo::NPS
+    end
+    
+    it 'should change tempo value to be 1/60th' do
+      @tempo.to_nps.value.should eq(1)
+    end
+  end
+  
+  describe '#to_bpm' do
+    it 'should return a Tempo::BPM object' do
+      @tempo.to_bpm(Rational(1,4)).should be_a Tempo::BPM
+    end
+    
+    it 'should divide tempo value by beatdur' do
+      @tempo.to_bpm(Rational(1,1)).value.should eq(60)
+      @tempo.to_bpm(Rational(1,4)).value.should eq(240)
+      @tempo.to_bpm(Rational(1,2)).value.should eq(120)
+    end
+  end
+end
+
+describe Tempo::NPS do
+  before :all do
+    @tempo = Tempo::NPS.new(1)
+  end
+  
+  describe '#to_qnpm' do
+    it 'should return a Tempo::QNPM object' do
+      @tempo.to_qnpm.should be_a Tempo::QNPM
+    end
+    
+    it 'should multiply tempo value by 240' do
+      @tempo.to_qnpm.value.should eq(240)
+    end
+  end
+  
+  describe '#to_npm' do
+    it 'should return a Tempo::NPM object' do
+      @tempo.to_npm.should be_a Tempo::NPM
+    end
+    
+    it 'should multiply tempo value by 60' do
+      @tempo.to_npm.value.should eq(60)
+    end
+  end
+
+  describe '#to_bpm' do
+    it 'should return a Tempo::BPM object' do
+      @tempo.to_bpm(Rational(1,4)).should be_a Tempo::BPM
+    end
+    
+    it 'should multiply tempo value by 60/beatdur' do
+      @tempo.to_bpm(Rational(1,1)).value.should eq(60)
+      @tempo.to_bpm(Rational(1,4)).value.should eq(240)
+      @tempo.to_bpm(Rational(1,2)).value.should eq(120)
+    end
+  end
+end
+
+describe Tempo::BPM do
+  before :all do
+    @tempo = Tempo::BPM.new(60)
+  end
+  
+  describe '#to_npm' do
+    it 'should return a Tempo::NPM object' do
+      @tempo.to_npm(Rational(1,4)).should be_a Tempo::NPM
+    end
+    
+    it 'should multiply tempo value by beatdur' do
+      @tempo.to_npm(Rational(1,4)).value.should eq(15)
+    end
+  end
+  
+  describe '#to_nps' do
+    it 'should return a Tempo::NPS object' do
+      @tempo.to_nps(Rational(1,4)).should be_a Tempo::NPS
+    end
+    
+    it 'should multiply tempo value by beatdur/60' do
+      @tempo.to_nps(Rational(1,4)).value.should eq(Rational(1,4))
+    end
+  end
+  
+  describe '#to_qnpm' do
+    it 'should return a Tempo::QNPM object' do
+      @tempo.to_qnpm(Rational(1,4)).should be_a Tempo::QNPM
+    end
+    
+    it 'should multiply tempo value by (4*beatdur)' do
+      @tempo.to_qnpm(Rational(1,8)).value.should eq(30)
+      @tempo.to_qnpm(Rational(1,4)).value.should eq(60)
+      @tempo.to_qnpm(Rational(1,2)).value.should eq(120)
+    end
+  end
+end

data/spec/model/change_spec.rb

@@ -1,7 +1,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe Change::Immediate do
-  context '.new' do
+  context '#initialize' do
     it 'should set value to given' do
       Change::Immediate.new(5).value.should eq 5
     end
@@ -29,6 +29,39 @@ describe Change::Immediate do
   end
 end
 
+describe Change::Gradual do
+  context '#initialize' do
+    it 'should set value to given value' do
+      Change::Gradual.new(5,2).value.should eq 5
+    end
+    
+    it 'should set duration to given duration' do
+      Change::Gradual.new(5,2).duration.should eq 2
+    end
+  end
+    
+  describe '==' do
+    it 'should return true if two gradual changes have the same value and duration' do
+      Change::Gradual.new(5,2).should eq(Change::Gradual.new(5,2))
+    end
+    
+    it 'should return false if two gradual changes do not have the same value' do
+      Change::Gradual.new(5,2).should_not eq(Change::Gradual.new(4,2))
+    end
+    
+    it 'should return false if two gradual changes do not have the same duration' do
+      Change::Gradual.new(5,2).should_not eq(Change::Gradual.new(5,1))
+    end
+  end
+  
+  describe '#to_yaml' do
+    it 'should produce YAML that can be loaded' do
+      c = Change::Gradual.new(4,2)
+      YAML.load(c.to_yaml).should eq c
+    end
+  end
+end
+
 describe Change::Gradual do
   context '.new' do
     it 'should set value to given value' do
@@ -60,4 +93,45 @@ describe Change::Gradual do
       YAML.load(c.to_yaml).should eq c
     end
   end
+end
+
+describe Change::Partial do
+  context '#initialize' do
+    it 'should set value to given value' do
+      Change::Partial.new(200,5,1,2).value.should eq(200)
+    end
+    
+    it 'should set duration to given elapsed_dur - stop_dur' do
+      Change::Partial.new(200,5,1,2).duration.should eq(1)
+    end
+
+    it 'should not raise NegativeError if given elapsed == 0' do
+      expect { Change::Partial.new(200,5,0,2) }.to_not raise_error
+    end
+    
+    it 'should raise NegativeError if given elapsed < 0' do
+      expect { Change::Partial.new(200,5,-1e-15,2) }.to raise_error(NegativeError)
+    end
+
+    it 'should raise NonPositiveError if given stop <= 0' do
+      expect { Change::Partial.new(200,5,0,0) }.to raise_error(NonPositiveError)
+      expect { Change::Partial.new(200,5,0,-1) }.to raise_error(NonPositiveError)
+    end
+    
+    it 'should raise ArgumentError if given stop > total dur' do
+      expect { Change::Partial.new(200,5,1,5.001) }.to raise_error(ArgumentError)
+      expect { Change::Partial.new(200,5,1,10) }.to raise_error(ArgumentError)
+    end
+
+    it 'should not raise ArgumentError if given stop == total dur' do
+      expect { Change::Partial.new(200,5,1,5) }.to_not raise_error
+    end
+    
+    it 'should raise ArgumentError if elapsed >= stop' do
+      expect { Change::Partial.new(200,5,1,1) }.to raise_error(ArgumentError)
+      expect { Change::Partial.new(200,5,3,2) }.to raise_error(ArgumentError)
+      expect { Change::Partial.new(200,5,5,5) }.to raise_error(ArgumentError)
+      expect { Change::Partial.new(200,5,6,5) }.to raise_error(ArgumentError)
+    end
+  end
 end

data/spec/model/measure_score_spec.rb

@@ -70,6 +70,8 @@ describe MeasureScore do
         :meter_changes => { 1 => Change::Immediate.new(5) } ],
       'non-immediate meter change' => [ FOUR_FOUR, Tempo::BPM.new(120),
         :meter_changes => { 1 => Change::Gradual.new(TWO_FOUR,1) } ],
+      'non-integer meter change offset' => [ FOUR_FOUR, Tempo::BPM.new(120),
+        :meter_changes => { 1.1 => Change::Immediate.new(TWO_FOUR) } ],
       'tempo change value is not a Tempo object' => [ FOUR_FOUR, Tempo::QNPM.new(120),
         :tempo_changes => { 1 => Change::Gradual.new(140,1) } ],
       'invalid part' => [ FOUR_FOUR, 120, :parts => { "piano" => Part.new(-0.1) }],

data/spec/model/part_spec.rb

@@ -41,9 +41,6 @@ describe Part do
         :dynamic_changes => { 0.2 => Change::Immediate.new(-0.01), 0.3 => Change::Gradual.new(1.01,0.2) }],
       'notes with 0 duration' => [ 0.5, :notes => [ Note.new(0) ]],
       'notes with negative duration' => [ 0.5, :notes => [ Note.new(-1) ]],
-      'gradual change with negative duration' => [
-        0.5, :notes => [ Note.new(1) ],
-        :dynamic_changes => { 0.2 => Change::Gradual.new(0.6,-0.1) }]
     }.each do |context_str, args|
       context context_str do
         it 'should return false' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: music-transcription
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.20.0
 platform: ruby
 authors:
 - James Tunnell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-11 00:00:00.000000000 Z
+date: 2014-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -169,6 +169,9 @@ files:
 - examples/song2.yml
 - examples/song2_packed.yml
 - lib/music-transcription.rb
+- lib/music-transcription/conversion/measure_note_map.rb
+- lib/music-transcription/conversion/measure_score_conversion.rb
+- lib/music-transcription/conversion/tempo_conversion.rb
 - lib/music-transcription/errors.rb
 - lib/music-transcription/model/articulations.rb
 - lib/music-transcription/model/change.rb
@@ -226,6 +229,9 @@ files:
 - lib/music-transcription/validatable.rb
 - lib/music-transcription/version.rb
 - music-transcription.gemspec
+- spec/conversion/measure_note_map_spec.rb
+- spec/conversion/measure_score_conversion_spec.rb
+- spec/conversion/tempo_conversion_spec.rb
 - spec/model/change_spec.rb
 - spec/model/link_spec.rb
 - spec/model/measure_score_spec.rb
@@ -288,6 +294,9 @@ specification_version: 4
 summary: Classes for representing music notational features like pitch, note, loudness,
   tempo, etc.
 test_files:
+- spec/conversion/measure_note_map_spec.rb
+- spec/conversion/measure_score_conversion_spec.rb
+- spec/conversion/tempo_conversion_spec.rb
 - spec/model/change_spec.rb
 - spec/model/link_spec.rb
 - spec/model/measure_score_spec.rb