musicality 0.8.0 → 0.9.0

data/spec/notation/model/pitch_spec.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'yaml'
 
 describe Pitch do
 
@@ -158,6 +159,20 @@ describe Pitch do
       YAML.load(p.to_yaml).should eq p
     end
   end
+
+  describe '#pack' do
+    it 'should produce a Hash' do
+      Bb3.pack.should be_a Hash
+    end
+  end
+
+  describe 'unpack' do
+    it 'should produce an object equal the original' do
+      p2 = Pitch.unpack Bb3.pack
+      p2.should be_a Pitch
+      p2.should eq Bb3
+    end
+  end
   
   describe '#to_s' do
     context 'on-letter semitones' do

data/spec/notation/model/score_spec.rb

@@ -117,17 +117,31 @@ describe Score do
   end
 end
 
-describe Score::Measured do
+describe Score::Tempo do
+  before :all do
+    @basic_score = Score::Tempo.new(TWO_FOUR, 120,
+      meter_changes: {
+        2 => Change::Immediate.new(FOUR_FOUR),
+        4 => Change::Immediate.new(SIX_EIGHT),
+      },
+      parts: {
+        "abc" => Part.new(Dynamics::MF, notes: "/4 /4 /2 3/4".to_notes),
+        "def" => Part.new(Dynamics::MF, notes: "/4 /4 /2 1 /2".to_notes)
+      },
+      program: [ (0.5)..Rational(1,2), 0..1, 1..2 ]
+    )
+  end
+
   describe '#initialize' do
     it 'should use empty containers for parameters not given' do
-      s = Score::Measured.new(FOUR_FOUR,120)
+      s = Score::Tempo.new(FOUR_FOUR,120)
       s.parts.should be_empty
       s.program.should be_empty
     end
     
     it 'should assign given parameters' do
       m = FOUR_FOUR
-      s = Score::Measured.new(m,120)
+      s = Score::Tempo.new(m,120)
       s.start_meter.should eq m
       s.start_tempo.should eq 120
       
@@ -136,7 +150,7 @@ describe Score::Measured do
       mcs = { 1 => Change::Immediate.new(THREE_FOUR) }
       tcs = { 1 => Change::Immediate.new(100) }
       
-      s = Score::Measured.new(m,120,
+      s = Score::Tempo.new(m,120,
         parts: parts,
         program: program,
         meter_changes: mcs,
@@ -153,13 +167,13 @@ describe Score::Measured do
     context 'with no meter changes' do
       context 'with no parts' do
         it 'should return 0' do
-          Score::Measured.new(TWO_FOUR, 120).measures_long.should eq(0)
+          Score::Tempo.new(TWO_FOUR, 120).measures_long.should eq(0)
         end
       end
 
       context 'with one part' do
         it 'should return the duration of the part, in measures' do
-          Score::Measured.new(TWO_FOUR, 120, parts: {
+          Score::Tempo.new(TWO_FOUR, 120, parts: {
             "abc" => Part.new(Dynamics::MF, notes: "/4 /4 /2 3/4".to_notes)
           }).measures_long.should eq(3.5)
         end
@@ -167,7 +181,7 @@ describe Score::Measured do
       
       context 'with two parts' do
         it 'should return the duration of the longest part, in measures' do
-          Score::Measured.new(TWO_FOUR, 120, parts: {
+          Score::Tempo.new(TWO_FOUR, 120, parts: {
             "abc" => Part.new(Dynamics::MF, notes: "/4 /4 /2 3/4".to_notes),
             "def" => Part.new(Dynamics::MF, notes: "/4 /4 /2 1".to_notes)
           }).measures_long.should eq(4)
@@ -177,7 +191,7 @@ describe Score::Measured do
     
     context 'with meter changes' do
       it 'should return the duration of the longest part, in measures' do
-        Score::Measured.new(TWO_FOUR, 120,
+        Score::Tempo.new(TWO_FOUR, 120,
           meter_changes: {
             2 => Change::Immediate.new(FOUR_FOUR),
           },
@@ -187,7 +201,7 @@ describe Score::Measured do
           }
         ).measures_long.should eq(3)
         
-        Score::Measured.new(TWO_FOUR, 120,
+        Score::Tempo.new(TWO_FOUR, 120,
           meter_changes: {
             2 => Change::Immediate.new(FOUR_FOUR),
             4 => Change::Immediate.new(SIX_EIGHT),
@@ -202,7 +216,7 @@ describe Score::Measured do
     
     context 'given specific note duration' do
       it 'should change the given note duration to measures' do
-        score = Score::Measured.new(TWO_FOUR, 120,
+        score = Score::Tempo.new(TWO_FOUR, 120,
             meter_changes: {
               2 => Change::Immediate.new(FOUR_FOUR),
               4 => Change::Immediate.new(SIX_EIGHT)
@@ -228,7 +242,7 @@ describe Score::Measured do
     }.each do |context_str,args|
       context context_str do
         it 'should return true' do
-          Score::Measured.new(*args).should be_valid
+          Score::Tempo.new(*args).should be_valid
         end
       end
     end
@@ -251,77 +265,33 @@ describe Score::Measured do
     }.each do |context_str,args|
       context context_str do
         it 'should return false' do
-          Score::Measured.new(*args).should be_invalid
+          Score::Tempo.new(*args).should be_invalid
         end
       end      
     end
   end
-end
 
-describe Score::Unmeasured do
-  describe '#initialize' do
-    it 'should use empty containers for parameters not given' do
-      s = Score::Unmeasured.new(30)
-      s.parts.should be_empty
-      s.program.should be_empty
+  describe '#pack' do
+    it 'should produce a Hash' do
+      @basic_score.pack.should be_a Hash
     end
-    
-    it 'should assign given parameters' do
-      s = Score::Unmeasured.new(30)
-      s.start_tempo.should eq(30)
-      
-      parts = { "piano (LH)" => Samples::SAMPLE_PART }
-      program = [0...0.75, 0...0.75]
-      tcs = { 1 => Change::Immediate.new(40) }
-      
-      s = Score::Unmeasured.new(30,
-        parts: parts,
-        program: program,
-        tempo_changes: tcs
-      )
-      s.parts.should eq parts
-      s.program.should eq program
-      s.tempo_changes.should eq tcs
+
+    it 'should pack program as an array of strings' do
+      program = @basic_score.pack[:program]
+      program.each {|entry| entry.should be_a String}
     end
-  end
 
-  describe '#notes_long' do
-    it 'should return the duration of the longest part' do
-      Score::Unmeasured.new(120, parts: {
-        "abc" => Part.new(Dynamics::MF, notes: "/4 /4 /2 3/4".to_notes),
-        "def" => Part.new(Dynamics::MF, notes: "/4 /4 /2 1".to_notes)
-      }).notes_long.should eq(2)
+    it 'should pack sections as a Hash of strings' do
+      program = @basic_score.pack[:sections]
+      program.each {|name,entry| entry.should be_a String}
     end
   end
-  
-  describe '#valid?' do
-    {
-      'valid start tempo' => [ 40 ],
-      'valid tempo changes' => [ 30,
-        :tempo_changes => { 1 => Change::Gradual.linear(40, 2), 2 => Change::Immediate.new(50) } ],
-      'valid part' => [ 30, :parts => { "piano" => Samples::SAMPLE_PART }],
-      'valid program' => [ 30, :program => [0..2,0..2] ]
-    }.each do |context_str,args|
-      context context_str do
-        it 'should return true' do
-          Score::Unmeasured.new(*args).should be_valid
-        end
-      end
-    end
-    
-    {
-      'start tempo valid is zero' => [ 0 ],
-      'start tempo valid is negative' => [ -1 ],
-      'tempo change value is not a valid value' => [ 30,
-        :tempo_changes => { 1 => Change::Gradual.linear(-1,1) } ],
-      'invalid part' => [ 30, :parts => { "piano" => Part.new(-0.1) }],
-      'invalid program' => [ 30, :program => [2..0] ],
-    }.each do |context_str,args|
-      context context_str do
-        it 'should return false' do
-          Score::Unmeasured.new(*args).should be_invalid
-        end
-      end 
+
+  describe 'unpack' do
+    it 'should produce an object equal the original' do
+      score2 = Score::Tempo.unpack @basic_score.pack
+      score2.should be_a Score
+      score2.should eq @basic_score
     end
   end
 end
@@ -376,4 +346,26 @@ describe Score::Timed do
       end 
     end
   end
+
+  describe '#pack' do
+    it 'should produce a Hash' do
+      score = Score::Timed.new(parts: {
+        "abc" => Part.new(Dynamics::MF, notes: "/4 /4 /2 3/4".to_notes),
+        "def" => Part.new(Dynamics::MF, notes: "/4 /4 /2 1".to_notes)
+      })
+      score.pack.should be_a Hash
+    end
+  end
+
+  describe 'unpack' do
+    it 'should produce an object equal the original' do
+      score = Score::Timed.new(parts: {
+        "abc" => Part.new(Dynamics::MF, notes: "/4 /4 /2 3/4".to_notes),
+        "def" => Part.new(Dynamics::MF, notes: "/4 /4 /2 1".to_notes)
+      })
+      score2 = Score::Timed.unpack score.pack
+      score2.should be_a score.class
+      score2.should eq score
+    end
+  end
 end

data/spec/notation/parsing/link_nodes_spec.rb

@@ -4,9 +4,9 @@ describe Parsing::LinkNode do
   parser = Parsing::LinkParser.new
   
   {
-    LINK_SYMBOLS[Links::TIE] => Link::Tie.new,
-    (LINK_SYMBOLS[Links::GLISSANDO] + Db2.to_s) => Link::Glissando.new(Db2),
-    (LINK_SYMBOLS[Links::PORTAMENTO] + Db2.to_s) => Link::Portamento.new(Db2),
+    LINK_SYMBOLS[Link::Tie] => Link::Tie.new,
+    (LINK_SYMBOLS[Link::Glissando] + Db2.to_s) => Link::Glissando.new(Db2),
+    (LINK_SYMBOLS[Link::Portamento] + Db2.to_s) => Link::Portamento.new(Db2),
   }.each do |str,tgt|
     res = parser.parse(str)
     context str do

data/spec/notation/parsing/link_parsing_spec.rb

@@ -5,15 +5,15 @@ describe Parsing::LinkParser do
     @parser = Parsing::LinkParser.new
   end
   
-  it "should parse #{LINK_SYMBOLS[Links::TIE]}" do
-    @parser.should parse(LINK_SYMBOLS[Links::TIE])
+  it "should parse #{LINK_SYMBOLS[Link::Tie]}" do
+    @parser.should parse(LINK_SYMBOLS[Link::Tie])
   end
 
-  it "should parse #{LINK_SYMBOLS[Links::GLISSANDO]} with target pitch" do
-    @parser.should parse(LINK_SYMBOLS[Links::GLISSANDO] + C3.to_s)
+  it "should parse #{LINK_SYMBOLS[Link::Glissando]} with target pitch" do
+    @parser.should parse(LINK_SYMBOLS[Link::Glissando] + C3.to_s)
   end
 
-  it "should parse #{LINK_SYMBOLS[Links::PORTAMENTO]} with target pitch" do
-    @parser.should parse(LINK_SYMBOLS[Links::GLISSANDO] + C3.to_s)
+  it "should parse #{LINK_SYMBOLS[Link::Portamento]} with target pitch" do
+    @parser.should parse(LINK_SYMBOLS[Link::Portamento] + C3.to_s)
   end
 end

data/spec/notation/parsing/note_node_spec.rb

@@ -32,15 +32,15 @@ describe Parsing::NoteNode do
 
   context 'monophonic note' do
     {
-      '/2C2=' => Note.new(Rational(1,2),[C2], links: { C2 => Link::Tie.new}),
+      '/2C2~' => Note.new(Rational(1,2),[C2], links: { C2 => Link::Tie.new}),
       '4/2D#6.' => Note.new(Rational(4,2),[Eb6],articulation:STACCATO),
-      '28Eb7%!' => Note.new(Rational(28,1),[Eb7],articulation:PORTATO, accented: true),
-      "56/33B1'" => Note.new(Rational(56,33),[B1],articulation:STACCATISSIMO),
+      '28Eb7_' => Note.new(Rational(28,1),[Eb7],articulation:PORTATO),
+      "56/33B1!" => Note.new(Rational(56,33),[B1],articulation:STACCATISSIMO),
     }.each do |str,tgt|
       res = NOTE_PARSER.parse(str)
       
       context str do
-        it 'should parse as MonophonicNoteNode' do
+        it 'should parse as `Node' do
           res.should be_a Parsing::NoteNode
         end
   
@@ -60,20 +60,21 @@ describe Parsing::NoteNode do
 
   context 'polyphonic note' do
     {
-      '/2C2,D2,E2(' => Note.new(Rational(1,2),[C2,D2,E2],articulation: Articulations::SLUR),
-      '/2C2,D2,E2[' => Note.new(Rational(1,2),[C2,D2,E2],articulation: Articulations::LEGATO),
+      '/2C2,D2,E2>' => Note.new(Rational(1,2),[C2,D2,E2],articulation: Articulations::ACCENT),
+      '/2C2,D2,E2^' => Note.new(Rational(1,2),[C2,D2,E2],articulation: Articulations::MARCATO),
       '4/2D#6,G4.' => Note.new(Rational(4,2),[Eb6,G4], articulation: Articulations::STACCATO),
-      '28Eb7,D7,G7_' => Note.new(Rational(28,1),[Eb7,D7,G7],articulation: Articulations::TENUTO),
-      '56/33B1,B2,B3,B4,B5!' => Note.new(Rational(56,33),[B1,B2,B3,B4,B5], accented: true),
+      '28Eb7,D7,G7-' => Note.new(Rational(28,1),[Eb7,D7,G7], articulation: Articulations::TENUTO),
+      '56/33B1,B2,B3,B4,B5_' => Note.new(Rational(56,33),[B1,B2,B3,B4,B5], articulation: Articulations::PORTATO),
     }.each do |str,tgt|
       res = NOTE_PARSER.parse(str)
       context str do
-        it 'should parse as PolyphonicNoteNode' do
+        it 'should parse as NoteNode' do
           res.should be_a Parsing::NoteNode
         end
   
         describe '#to_note' do
           n = res.to_note
+
           it 'should produce a Note' do
             n.should be_a Note
           end
@@ -85,4 +86,28 @@ describe Parsing::NoteNode do
       end
     end
   end
+
+  context 'with marks' do
+    [[BEGIN_SLUR],[BEGIN_SLUR, BEGIN_TRIPLET],[BEGIN_TRIPLET]].each do |begin_marks|
+      begin_marks_str = begin_marks.map {|m| m.to_s}.join
+      [[END_SLUR],[END_SLUR, END_TRIPLET],[END_TRIPLET]].each do |end_marks|
+        end_marks_str = end_marks.map {|m| m.to_s}.join
+        describe '#to_note' do
+          it 'should produce a Note with marks set correctly' do
+            str = "#{begin_marks_str}/4Bb2#{end_marks_str}"
+            n = NOTE_PARSER.parse(str).to_note
+            n.marks.should eq(begin_marks+end_marks)
+          end
+        end
+      end
+    end
+  end
+
+  context 'without marks' do
+    it 'should produce a Note with marks set to []' do
+      str = "/4Bb2"
+      n = NOTE_PARSER.parse(str).to_note
+      n.marks.should eq([])
+    end
+  end
 end

data/spec/notation/parsing/note_parsing_spec.rb

@@ -9,20 +9,22 @@ describe Parsing::NoteParser do
     'duration only' => ['1/4','/2','1','55/33'],
     'single pitch' => ['/4C2','5/3Db3','/33E#8'],
     'multiple pitches' => ['/4C2,C3,c5','5/3Db3,Bb2,E5','/33E#8,F1,B9'],
-    'with articulation' => ['/4C2.',"5/3Db3,Bb2,E5'",'/33F3(','/2D3,F4_'],
-    'with accent' => ['/4C2!','3/2Db3,Bb4!'],
-    'with links' => ['/2C2=','/2C2|D2','/4D4|E4,G4~A5.'],
+    'with articulation' => ['/4C2.',"5/3Db3,Bb2,E5.",'/2D3,F4_'],
+    'with accent' => ['/4C2','3/2Db3,Bb4'],
+    'with links' => ['/2C2~','/2C2:D2','/4D4:E4,G4;A5.'],
+    'with marks' => ['(3/4Bb3]', '[/2F3,G3)', '[(2/4C3', '([1B2', '/3B2,C2)]', '2/3D4])'],
     'with single pitch + articulation + link + accent' => [
-      '3/4D2=(!','5/8F2~G2.!','/8Db4|Db5!','/3G4~B4_!'],
+      '(3/4D2~','5/8F2;G2.','/8Db4:Db5','/3G4;B4_'],
     'with multiple pitches + articulation + links + accent' => [
-      '5/4D2=,G4|A4,C3~D3.!','5/8F2=,B4|A4_!'],
+      '5/4D2~,G4:A4,C3;D3.','5/8F2~,B4:A4_'],
   }
   invalid_cases = {
-    'duration + accent' => ['1/4!','/2!'],
-    'duration + articulation' => ['1/4.','/2%','2/3('],
-    'duration + accent + link' => ['1/4!~','/2!/','2/3=!'],
+    'duration + articulation' => ['1/4.','/2.','2/3!'],
+    'duration + accent + link' => ['1/4;','/2:','2/3~'],
     'single pith with bad letter' => ['5/3Hb3'],
-    'single pitch without octave' => ['/33E(2'],
+    'single pitch without octave' => ['/33E)'],
+    'begins marks at the end' => ['1Bb3(', '2Bb3['],
+    'end marks at the beginning ' => [']1B5', ')3C3']
   }
   
   valid_cases.each do |descr, strs|

data/spec/notation/parsing/numbers/nonnegative_integer_spec.rb

@@ -8,4 +8,8 @@ describe Parsing::NonnegativeIntegerParser do
       parser.parse(str).should_not be nil
     end
   end
+
+  it 'should not parse an empty string' do
+    parser.parse("").should be nil
+  end
 end

data/spec/notation/parsing/pitch_node_spec.rb

@@ -7,7 +7,6 @@ describe Parsing::PitchNode do
     'C4' => C4,
     'Db2' => Db2,
     'C#2' => Db2,
-    'Db2' => Db2,
     'F7' => F7,
     'B1' => B1,
     "Bb22" => Pitch.new(octave: 22, semitone: 10),

data/spec/notation/util/value_computer_spec.rb

@@ -14,7 +14,7 @@ describe ValueComputer do
       end
       
       it "should always return default value if no changes are given" do
-        [ValueComputer::DOMAIN_MIN, -1000, 0, 1, 5, 100, 10000, ValueComputer::DOMAIN_MAX].each do |offset|
+        [ValueComputer::DOMAIN_MIN, -1000, 0, 1, 5, 100, 10000].each do |offset|
           @comp.at(offset).should eq(0.5)
         end
       end
@@ -38,7 +38,7 @@ describe ValueComputer do
       end
       
       it "should be at the second value for all time after" do
-        @comp.at(ValueComputer::DOMAIN_MAX).should eq(0.6)
+        @comp.at(100_000).should eq(0.6)
       end
     end
     

data/spec/performance/conversion/glissando_converter_spec.rb

@@ -70,12 +70,12 @@ describe GlissandoConverter do
   describe '.glissando_elements' do
     before :all do
       @dur = Rational(3,2)
-      @acc = false
-      @els = GlissandoConverter.glissando_elements(C4,A4,@dur,@acc)
+      @att = Attack::TENUTO
+      @els = GlissandoConverter.glissando_elements(C4,A4,@dur,@att)
     end
     
-    it 'should return an array of LegatoElement objects' do
-      @els.each {|el| el.should be_a LegatoElement }
+    it 'should return an array of NoteSequence::Element objects' do
+      @els.each {|el| el.should be_a NoteSequence::Element }
     end
     
     it 'should split up duration among elements' do
@@ -83,11 +83,11 @@ describe GlissandoConverter do
       sum.should eq(@dur)
     end
     
-    it 'should set accented as given' do
-      els = GlissandoConverter.glissando_elements(C4,A4,1,false)
-      els.each {|el| el.accented.should eq(false) }
-      els = GlissandoConverter.glissando_elements(C4,A4,1,true)
-      els.each {|el| el.accented.should eq(true) }
+    it 'should set attack as given for each element' do
+      els = GlissandoConverter.glissando_elements(C4,A4,1,Attack::TENUTO)
+      els.each {|el| el.attack.should eq(Attack::TENUTO) }
+      els = GlissandoConverter.glissando_elements(C4,A4,1,Attack::ACCENT)
+      els.each {|el| el.attack.should eq(Attack::ACCENT) }
     end
   end
 end