musicality 0.1.0

data/spec/notation/conversion/unmeasured_score_converter_spec.rb

@@ -0,0 +1,116 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe UnmeasuredScoreConverter do
+  describe '#initialize' do
+    context 'current score is invalid' do
+      it 'should raise NotValidError' do
+        score = Score::Unmeasured.new(-1)
+        expect { UnmeasuredScoreConverter.new(score,200) }.to raise_error(NotValidError)
+      end
+    end
+  end
+  
+  describe '#convert_parts' do
+    before :each do
+      @changeA = Change::Immediate.new(Dynamics::PP)
+      @changeB = Change::Gradual.new(Dynamics::F, 2)
+      @score = Score::Unmeasured.new(120,
+        parts: {
+          "normal" => Part.new(Dynamics::MP,
+            dynamic_changes: { 1 => @changeA, 3 => @changeB },
+            notes: "/4C2 /8D2 /8E2 /2C2".to_notes * 4),
+          "empty" => Part.new(Dynamics::PP)
+        }
+      )
+      @parts = UnmeasuredScoreConverter.new(@score,200).convert_parts
+    end
+    
+    it 'should return Hash with original part names' do
+      @parts.should be_a Hash
+      @parts.keys.sort.should eq(@score.parts.keys.sort)
+    end
+    
+    it 'should convert part dynamic change offsets from note-based to time-based' do
+      part = @parts["normal"]
+      part.dynamic_changes.keys.sort.should eq([2,6])
+      change = part.dynamic_changes[2.0]
+      change.value.should eq(@changeA.value)
+      change.duration.should eq(0)
+      change = part.dynamic_changes[6.0]
+      change.value.should eq(@changeB.value)
+      change.duration.should eq(4.0)
+    end
+    
+    it 'should convert note durations to time durations' do
+      part = @parts["normal"]
+      part.notes.map {|x| x.duration }.should eq([0.5,0.25,0.25,1]*4)
+    end
+    
+    context 'gradual changes with positive elapsed and/or remaining' do
+      it 'should change elapsed and remaining so they reflect time-based duration' do
+        score = Score::Unmeasured.new(120, parts: {
+          "abc" => Part.new(Dynamics::P, dynamic_changes: {
+              2 => Change::Gradual.new(Dynamics::F,2,1,3),
+              7 => Change::Gradual.new(Dynamics::F,1,4,5)
+          })
+        })
+        converter = UnmeasuredScoreConverter.new(score,200)
+        parts = converter.convert_parts
+        dcs = parts["abc"].dynamic_changes
+        
+        dcs.keys.should eq([4,14])
+        dcs[4.0].should eq(Change::Gradual.new(Dynamics::F,4,2,6))
+        dcs[14.0].should eq(Change::Gradual.new(Dynamics::F,2,8,10))
+      end
+    end
+  end
+  
+  describe '#convert_program' do
+    before :each do
+      @prog = Program.new([0...4,2...5])
+      @score = Score::Unmeasured.new(120, program: @prog)
+      @converter = UnmeasuredScoreConverter.new(@score,200)
+      @prog2 = @converter.convert_program
+    end
+    
+    it 'should return Program with same number of segments' do
+      @prog2.should be_a Program
+      @prog2.segments.size.should eq(@prog.segments.size)
+    end
+  
+    it 'should convert program segments offsets from note-based to time-based' do
+      prog = @prog2
+      prog.segments[0].first.should eq(0)
+      prog.segments[0].last.should eq(8)
+      prog.segments[1].first.should eq(4)
+      prog.segments[1].last.should eq(10)
+    end
+  end
+  
+  describe '#convert_score' do    
+    it 'should return an timed score' do
+      score = Score::Unmeasured.new(120)
+      converter = UnmeasuredScoreConverter.new(score,200)
+      converter.convert_score.should be_a Score::Timed
+    end
+  
+    it 'should use output from convert_program' do
+      prog = Program.new([0...4,2...5])
+      score = Score::Unmeasured.new(120, program: prog)
+      converter = UnmeasuredScoreConverter.new(score,200)
+      nscore = converter.convert_score
+      nscore.program.should eq(converter.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 = Score::Unmeasured.new(120,
+        parts: {"simple" => Part.new(Dynamics::MP, dynamic_changes: { 1 => changeA, 3 => changeB })}
+      )
+      converter = UnmeasuredScoreConverter.new(score,200)
+      nscore = converter.convert_score
+      nscore.parts.should eq(converter.convert_parts)
+    end
+  end
+end

data/spec/notation/model/change_spec.rb

@@ -0,0 +1,90 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Change::Immediate do
+  context '#initialize' do
+    it 'should set value to given' do
+      Change::Immediate.new(5).value.should eq 5
+    end
+    
+    it 'should set duration to 0' do
+      Change::Immediate.new(5).duration.should eq 0
+    end
+  end
+    
+  describe '==' do
+    it 'should return true if two immediate changes have the same value' do
+      Change::Immediate.new(5).should eq(Change::Immediate.new(5))
+    end
+    
+    it 'should return false if two immediate changes do not have the same value' do
+      Change::Immediate.new(5).should_not eq(Change::Immediate.new(4))
+    end
+  end
+  
+  describe '#to_yaml' do
+    it 'should produce YAML that can be loaded' do
+      c = Change::Immediate.new(4)
+      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
+      Change::Gradual.new(5,2).value.should eq 5
+    end
+    
+    it 'should set duration to given impending duration' do
+      c = Change::Gradual.new(5,2)
+      c.duration.should eq 2
+      c.impending.should eq 2
+    end
+    
+    it 'should set elapsed to 0 by default' do
+      Change::Gradual.new(5,2).elapsed.should eq 0
+    end
+    
+    it 'should set remaining to 0 by default' do
+      Change::Gradual.new(5,2).remaining.should eq 0
+    end
+    
+    it 'should compute total_duration to be elapsed + impending + remaining' do
+      Change::Gradual.new(100,7,2,3).total_duration.should eq(12)
+    end
+    
+    it 'should raise NonPositiveError if impending is <= 0' do
+      expect { Change::Gradual.new(11,0) }.to raise_error(NonPositiveError)
+      expect { Change::Gradual.new(11,-1) }.to raise_error(NonPositiveError)
+    end
+
+    it 'should raise NegativeError if elapsed is < 0' do
+      expect { Change::Gradual.new(11,1,-1) }.to raise_error(NegativeError)
+    end
+    
+    it 'should raise NegativeError if remaining is < 0' do
+      expect { Change::Gradual.new(11,1,0,-1) }.to raise_error(NegativeError)
+    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

data/spec/notation/model/link_spec.rb

@@ -0,0 +1,83 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+{
+  Link::Glissando => Link::Portamento,
+  Link::Portamento => Link::Glissando,
+  Link::Slur => Link::Legato,
+  Link::Legato => Link::Slur
+}.each do |klass,klass2|
+  describe klass do
+    describe '#initialize' do
+      it 'should assign the given pitch to :target_pitch' do
+        klass.new(C2).target_pitch.should eq(C2)
+      end
+    end
+    
+    describe '#==' do
+      it 'should return true if two links have the same target pitch' do
+        klass.new(C2).should eq(klass.new(C2))
+      end
+      
+      it 'should return false if two links do not have the same target pitch' do
+        klass.new(C2).should_not eq(klass.new(F5))
+      end
+      
+      it 'should return false if the link type is different' do
+        klass.new(C2).should_not eq(klass2.new(C2))
+      end
+    end
+    
+    describe '#clone' do
+      it 'should return a link equal to original' do
+        l = klass.new(C4)
+        l.clone.should eq l
+      end
+    end
+    
+    describe '#to_yaml' do
+      it 'should produce YAML that can be loaded' do
+        l = klass.new(C5)
+        YAML.load(l.to_yaml).should eq l
+      end
+    end
+    
+    describe '#to_s' do
+      it 'should produce string that include link char and target pitch str' do
+        l = klass.new(C3)
+        l.to_s.should eq(l.link_char + "C3")
+      end
+    end
+  end
+end
+
+describe Link::Tie do
+  describe '#==' do
+    it 'should return true if another Tie object is given' do
+      Link::Tie.new.should eq(Link::Tie.new)
+    end
+    
+    it 'should return false if a non-Tie object is given' do
+      Link::Tie.new.should_not eq(Link::Portamento.new(C2))
+    end
+  end
+  
+  describe '#clone' do
+    it 'should return a link equal to original' do
+      l = Link::Tie.new
+      l.clone.should eq l
+    end
+  end
+  
+  describe '#to_yaml' do
+    it 'should produce YAML that can be loaded' do
+      l = Link::Tie.new
+      YAML.load(l.to_yaml).should eq l
+    end
+  end
+  
+  describe '#to_s' do
+    it 'should return =' do
+      Link::Tie.new.to_s.should eq("=")
+    end
+  end
+end

data/spec/notation/model/meter_spec.rb

@@ -0,0 +1,97 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Meter do
+  describe '#initialize' do
+    it 'should assign beats per measure and beat duration' do
+      [[4,"1/4".to_r],[3,"1/4".to_r],[6,"1/8".to_r]].each do |bpm,bd|
+        m = Meter.new(bpm,bd)
+        m.beats_per_measure.should eq bpm
+        m.beat_duration.should eq bd
+      end      
+    end
+    
+    it 'should derive measure duration' do
+      {
+        [4,"1/4".to_r] => "1/1".to_r,
+        [3,"1/4".to_r] => "3/4".to_r,
+        [6,"1/8".to_r] => "6/8".to_r,
+        [12,"1/8".to_r] => "12/8".to_r,
+      }.each do |bpm,bd|
+        m = Meter.new(bpm,bd)
+        m.measure_duration.should eq(bpm*bd)
+      end      
+    end
+  end
+  
+  describe '#==' do
+    context 'meters with same beat duration and beats per measure' do
+      it 'should return true' do
+        m1 = Meter.new(4,"1/4".to_r)
+        m2 = Meter.new(4,"1/4".to_r)
+        m1.should eq m2
+      end
+    end
+    
+    context 'meters with same meausre duration but different beat duration' do
+      it 'should return false' do
+        m1 = Meter.new(4,"1/4".to_r)
+        m2 = Meter.new(2,"1/2".to_r)
+        m1.should_not eq m2
+      end
+    end
+  end
+  
+  describe '#to_yaml' do
+    it 'should produce YAML that can be loaded' do
+      m = Meter.new(4,"1/4".to_r)
+      YAML.load(m.to_yaml).should eq m
+    end
+  end
+  
+  describe '#to_s' do
+    context 'beat duration with 1 in denominator' do
+      it 'should return string of fraction: beats_per_measure / beat_duration.denom' do
+        FOUR_FOUR.to_s.should eq("4/4")
+        TWO_FOUR.to_s.should eq("2/4")
+        THREE_FOUR.to_s.should eq("3/4")
+        TWO_TWO.to_s.should eq("2/2")
+      end
+    end
+    
+    context 'beat duration with >1 in denominator' do
+      it 'should return beats_per_measure * beat_dur fraction' do
+        SIX_EIGHT.to_s.should eq("2*3/8")
+        Meter.new(3,"3/8".to_r).to_s.should eq("3*3/8")
+      end
+    end
+  end
+  
+  describe '#valid?' do
+    {
+      '4/4 meter' => [4,'1/4'.to_r],
+      '2/4 meter' => [2,'1/4'.to_r],
+      '3/4 meter' => [2,'1/4'.to_r],
+      '6/8 meter' => [6,'1/8'.to_r],
+      '12/8 meter' => [12,'1/8'.to_r],
+    }.each do |context_str,args|
+      context context_str do
+        it 'should return true' do
+          Meter.new(*args).should be_valid
+        end
+      end
+    end
+    
+    {
+      'non-integer positive beats per measure' => [4.0,"1/4".to_r],
+      'integer negative beats per measure' => [-1,"1/4".to_r],
+      'zero beat duration' => [4,0.to_r],
+      'negative beat duration' => [4,-1.to_r],
+    }.each do |context_str,args|
+      context context_str do
+        it 'should return false' do
+          Meter.new(*args).should be_invalid
+        end
+      end      
+    end
+  end
+end

data/spec/notation/model/note_spec.rb

@@ -0,0 +1,183 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Note do
+  before :all do
+    @pitch = C4
+  end
+  
+  describe '.new' do
+    it 'should assign :duration that is given during construction' do
+      Note.new(2).duration.should eq(2)
+    end
+
+    it "should assign :articulation to Note::DEFAULT_ARTICULATION if not given" do
+      Note.new(2).articulation.should eq(Note::DEFAULT_ARTICULATION)
+    end
+    
+    it "should assign :articulation parameter if given during construction" do
+      Note.new(2, articulation: STACCATO).articulation.should eq(STACCATO)
+    end
+    
+    it 'should assign :accented to false if not given' do
+      Note.new(2).accented.should be false
+    end
+    
+    it 'should assign :accented if given' do
+      Note.new(2, accented: true).accented.should be true
+    end
+    
+    it 'should have no pitches if not given' do
+      Note.new(2).pitches.should be_empty
+    end
+    
+    it 'should assign pitches when given' do
+      pitches = [ C2, D2 ]
+      n = Note.new(2, pitches)
+      n.pitches.should include(pitches[0])
+      n.pitches.should include(pitches[1])
+    end
+  end
+  
+  describe '#duration=' do
+    it 'should assign duration' do
+      note = Note.new 2, [@pitch]
+      note.duration = 3
+      note.duration.should eq 3
+    end
+  end
+  
+  {
+    :sixteenth => Rational(1,16),
+    :dotted_SIXTEENTH => Rational(3,32),
+    :eighth => Rational(1,8),
+    :dotted_eighth => Rational(3,16),
+    :quarter => Rational(1,4),
+    :dotted_quarter => Rational(3,8),
+    :half => Rational(1,2),
+    :dotted_half => Rational(3,4),
+    :whole => Rational(1)
+  }.each do |fn_name,tgt_dur|
+    describe ".#{fn_name}" do
+      it "should make a note with duration #{tgt_dur}" do
+        Note.send(fn_name).duration.should eq tgt_dur
+      end
+    end
+  end
+  
+  describe '#transpose' do
+    context 'given pitch diff' do
+      before(:all) do
+        @note1 = Note::quarter([C2,F2], links:{C2=>Link::Glissando.new(D2)})
+        @interval = 4
+        @note2 = @note1.transpose(@interval)
+      end
+        
+      it 'should modifiy pitches by adding pitch diff' do
+        @note2.pitches.each_with_index do |p,i|
+          p.diff(@note1.pitches[i]).should eq(@interval)
+        end
+      end
+        
+      it 'should also affect link targets' do
+        @note1.links.each do |k,v|
+          kt = k.transpose(@interval)
+          @note2.links.should have_key kt
+          @note2.links[kt].target_pitch.should eq(v.target_pitch.transpose(@interval))
+        end
+      end
+    end
+    
+    context 'with links that have no target pitch' do
+      it 'should not raise error' do
+        n = Note::half([E2],links: {E2 => Link::Tie.new})
+        expect { n.transpose(1) }.to_not raise_error
+      end
+    end
+  end
+  
+  describe '#stretch' do
+    it 'should multiply note duration by ratio' do
+      note = Note::quarter.stretch(2)
+      note.duration.should eq(Rational(1,2))
+      
+      note = Note::quarter.stretch(Rational(1,2))
+      note.duration.should eq(Rational(1,8))
+    end
+  end
+  
+  describe '#to_s' do
+    before :all do
+      @note_parser = Parsing::NoteParser.new
+    end
+    
+    context 
+    it 'should produce string that when parsed produces an equal note' do
+      durations = ["1/8".to_r,"1".to_r,"5/3".to_r]
+      include Articulations
+      articulations = [NORMAL, SLUR, LEGATO, TENUTO, PORTATO, STACCATO, STACCATISSIMO ]
+      pitches_links_sets = [
+        [[],{}],
+        [[C2],{}],
+        [[A5,D6],{ A5 => Link::Tie.new }],
+        [[C5,E6,Gb2],{ C5 => Link::Glissando.new(D5) }],
+        [[A5,D6],{ A5 => Link::Legato.new(B5), D6 => Link::Slur.new(E6) }],
+        [[C5,E6,Gb2],{ C5 => Link::Portamento.new(D5), Gb2 => Link::Tie.new }],
+      ]
+      
+      notes = []
+      durations.each do |d|
+        articulations.each do |art|
+          pitches_links_sets.each do |pitches_links_set|
+            pitches,links = pitches_links_set
+            [true,false].each do |acc|
+              notes.push Note.new(d, pitches, articulation: art, links: links, accented: acc)
+            end
+          end
+        end
+      end
+      
+      notes.each do |note|
+        str = note.to_s
+        res = @note_parser.parse(str)
+        note2 = res.to_note
+        note2.should eq(note)
+      end
+    end
+  end
+  
+  describe '#to_yaml' do
+    it 'should produce YAML that can be loaded' do
+      n = Note.new(1,[C2])
+      YAML.load(n.to_yaml).should eq n
+      
+      n = Note.new(1,[C2,E2])
+      YAML.load(n.to_yaml).should eq n
+      
+      n = Note.new(1,[C2], articulation: STACCATO)
+      YAML.load(n.to_yaml).should eq n
+      
+      n = Note.new(1,[E2], links: {E2 => Link::Portamento.new(F2)})
+      YAML.load(n.to_yaml).should eq n
+    end
+  end
+  
+  describe '#valid?' do
+    context 'note with positive duration' do
+      it 'should return true' do
+        Note.new(1,[C2]).should be_valid
+      end
+    end
+    
+    context 'note with 0 duration' do
+      it 'should return false' do
+        Note.new(0,[C2]).should be_invalid
+      end
+    end
+    
+    context 'note with negative duration' do
+      it 'should be invalid' do
+        Note.new(-1,[C2]).should be_invalid
+      end
+    end
+  end
+end

data/spec/notation/model/part_spec.rb

@@ -0,0 +1,69 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Part do
+  describe '#initialize' do
+    it 'should use empty containers for parameters not given' do
+      p = Part.new(Dynamics::MP)
+      p.notes.should be_empty
+      p.dynamic_changes.should be_empty
+    end
+    
+    it "should assign parameters given during construction" do
+      p = Part.new(Dynamics::PPP)
+      p.start_dynamic.should eq Dynamics::PPP
+      
+      notes = [Note::whole([A2]), Note::half]
+      dcs = { "1/2".to_r => Change::Immediate.new(Dynamics::P), 1 => Change::Gradual.new(Dynamics::MF,1) }
+      p = Part.new(Dynamics::FF, notes: notes, dynamic_changes: dcs)
+      p.notes.should eq notes
+      p.dynamic_changes.should eq dcs
+    end
+  end
+  
+  describe '#to_yaml' do
+    it 'should produce YAML that can be loaded' do
+      p = Samples::SAMPLE_PART
+      YAML.load(p.to_yaml).should eq p
+    end
+  end
+  
+  describe '#valid?' do
+    { 'negative start dynamic' => [-0.01],
+      'start dynamic > 1' => [1.01],
+      #'dynamic change offsets outside 0..d' => [
+      #  0.5, :notes => [ Note::whole ],
+      #  :dynamic_changes => { 1.2 => Change::Immediate.new(0.5) }],
+      #'dynamic change offsets outside 0..d' => [
+      #  0.5, :notes => [ Note::whole ],
+      #  :dynamic_changes => { -0.2 => Change::Immediate.new(0.5) }],
+      'dynamic change values outside 0..1' => [
+        0.5, :notes => [ Note::whole ],
+        :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) ]],
+    }.each do |context_str, args|
+      context context_str do
+        it 'should return false' do
+          Part.new(*args).should be_invalid
+        end
+      end
+    end
+    
+    {
+      'valid notes' => [ Dynamics::PP,
+        :notes => [ Note::whole, quarter([C5]) ]],
+      'valid dynamic values' => [ Dynamics::MF,
+        :notes => [ Note::whole([C4]), Note::quarter ],
+        :dynamic_changes => {
+          0.5 => Change::Immediate.new(Dynamics::MP),
+          1.2 => Change::Gradual.new(Dynamics::FF, 0.05) } ],
+    }.each do |context_str, args|
+      context context_str do
+        it 'should return true' do
+          part = Part.new(*args)
+          part.should be_valid
+        end
+      end
+    end
+  end
+end