musicality 0.8.0 → 0.9.0

data/spec/notation/model/change_spec.rb

@@ -23,6 +23,22 @@ describe Change::Immediate do
       YAML.load(c.to_yaml).should eq c
     end
   end
+
+  describe '#pack' do
+    it 'should produce a Hash' do
+      h = Change::Immediate.new(2).pack
+      h.should be_a Hash
+    end
+  end
+
+  describe '.unpack' do
+    it 'should return a Change::Immediate equal to the original' do
+      c1 = Change::Immediate.new(2)
+      c2 = Change::Immediate.unpack(c1.pack)
+      c2.should be_a Change::Immediate
+      c2.should eq c1
+    end
+  end
 end
 
 describe Change::Gradual do
@@ -122,6 +138,22 @@ describe Change::Gradual do
       YAML.load(c.to_yaml).should eq c
     end
   end
+
+  describe '#pack' do
+    it 'should produce a Hash' do
+      h = Change::Gradual.linear(4,2).pack
+      h.should be_a Hash
+    end
+  end
+
+  describe '.unpack' do
+    it 'should return a Change::Gradual equal to the original' do
+      c1 = Change::Gradual.linear(4,2)
+      c2 = Change::Gradual.unpack(c1.pack)
+      c2.should be_a Change::Gradual
+      c2.should eq c1
+    end
+  end
 end
 
 describe Change::Gradual::Trimmed do
@@ -190,4 +222,27 @@ describe Change::Gradual::Trimmed do
       Change::Gradual.linear(41,19).trim(4,9).trailing.should eq(9)
     end
   end
+
+  describe '#to_yaml' do
+    it 'should produce YAML that can be loaded' do
+      c = Change::Gradual::Trimmed.linear(4,2, preceding: 1, remaining: 0.5)
+      YAML.load(c.to_yaml).should eq c
+    end
+  end
+
+  describe '#pack' do
+    it 'should produce a Hash' do
+      h = Change::Gradual::Trimmed.linear(4,2, preceding: 1, remaining: 0.5).pack
+      h.should be_a Hash
+    end
+  end
+
+  describe '.unpack' do
+    it 'should return a Change::Gradual::Trimmed equal to the original' do
+      c1 = Change::Gradual::Trimmed.linear(4,2, preceding: 1, remaining: 0.5)
+      c2 = Change::Gradual::Trimmed.unpack(c1.pack)
+      c2.should be_a Change::Gradual::Trimmed
+      c2.should eq c1
+    end
+  end
 end

data/spec/notation/model/key_spec.rb

@@ -0,0 +1,171 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Key do
+  describe '.major_flat' do
+    it 'should set triad to MAJOR and accidental_pref to FLAT' do
+      k = Key.major_flat(0)
+      k.triad.should eq(Key::MAJOR)
+      k.accidental_pref.should eq(Key::FLAT)
+    end
+  end
+
+  describe '.minor_flat' do
+    it 'should set triad to MAJOR and accidental_pref to SHARP' do
+      k = Key.major_sharp(0)
+      k.triad.should eq(Key::MAJOR)
+      k.accidental_pref.should eq(Key::SHARP)
+    end
+  end
+
+  describe '.major_sharp' do
+    it 'should set triad to MINOR and accidental_pref to FLAT' do
+      k = Key.minor_flat(0)
+      k.triad.should eq(Key::MINOR)
+      k.accidental_pref.should eq(Key::FLAT)
+    end
+  end
+
+  describe '.minor_sharp' do
+    it 'should set triad to MINOR and accidental_pref to SHARP' do
+      k = Key.minor_sharp(0)
+      k.triad.should eq(Key::MINOR)
+      k.accidental_pref.should eq(Key::SHARP)
+    end
+  end
+
+  describe '.new' do
+    context 'given tonic_pc that is not in 0..11' do
+      it 'should apply mod 12 to bring it in range' do
+        { 12 => 0, 13 => 1, -1 => 11, 24 => 0, 18 => 6 
+        }.each do |t1,t2|
+          Key.major_flat(t1).tonic_pc.should eq(t2)
+        end
+      end
+    end
+
+    context 'given tonic_pc in 0..11' do
+      it 'should not change' do
+        (0..11).each do |pc|
+          Key.major_flat(pc).tonic_pc.should eq(pc)
+        end
+      end
+    end
+    
+    context 'given triad that is not MAJOR or MINOR' do
+      it 'should raise ArgumentError' do
+        expect { Key.new(0, triad: :flipping) }.to raise_error(ArgumentError)
+      end
+    end
+    
+    context 'given accidental_pref that is not FLAT or SHARP' do
+      it 'should raise ArgumentError' do
+        expect { Key.new(0, accidental_pref: :squiggle) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+  
+  describe '#flat?' do
+    context 'given accidental_pref is FLAT' do
+      it 'should return true' do
+        Key.major_flat(0).flat?.should be true
+      end
+    end
+    context 'given accidental_pref is SHARP' do
+      it 'should return false' do
+        Key.major_sharp(0).flat?.should be false
+      end
+    end
+  end
+
+  describe '#sharp?' do
+    context 'given accidental_pref is FLAT' do
+      it 'should return false' do
+        Key.major_flat(0).sharp?.should be false
+      end
+    end
+    context 'given accidental_pref is SHARP' do
+      it 'should return true' do
+        Key.major_sharp(0).sharp?.should be true
+      end
+    end
+  end
+
+  describe '#major?' do
+    context 'given triad is MAJOR' do
+      it 'should return true' do
+        Key.major_flat(0).major?.should be true
+      end
+    end
+    context 'given triad is MINOR' do
+      it 'should return false' do
+        Key.minor_flat(0).major?.should be false
+      end
+    end
+  end
+
+  describe '#minor?' do
+    context 'given triad is MAJOR' do
+      it 'should return false' do
+        Key.major_flat(0).minor?.should be false
+      end
+    end
+    context 'given triad is MINOR' do
+      it 'should return true' do
+        Key.minor_flat(0).minor?.should be true
+      end
+    end
+  end
+  
+  describe '#==' do
+    context 'objects with different tonic_pc' do
+      it 'should return false' do
+        Key.major_flat(0).should_not eq(Key.major_flat(1))
+      end
+    end
+    
+    context 'objects with different triad' do
+      it 'should return false' do
+        Key.major_flat(0).should_not eq(Key.minor_flat(0))
+      end
+    end
+    
+    context 'objects with different accidental_type' do
+      it 'should return false' do
+        Key.major_flat(0).should_not eq(Key.major_sharp(0))
+      end
+    end
+    
+    context 'objects with same tonic_pc, triad, and accidental_type' do
+      it 'should return true' do
+        Key.major_flat(0).should eq(Key.major_flat(0))
+      end
+    end
+  end
+  
+  describe '#clone' do
+    it 'should return a different, equal object' do
+      k1 = Key.major_flat(0)
+      k2 = k1.clone
+      k1.should_not be k2
+      k1.should eq k2
+    end
+  end
+  
+  describe '#accidentals' do
+  end
+
+  describe '#pack' do
+    it 'should return a Hash' do
+      Key.major_sharp(1).pack.should be_a Hash
+    end
+  end
+
+  describe '.unpack' do
+    it 'should return a Key object equal to the original' do
+      k1 = Key.major_sharp(1)
+      k2 = Key.unpack k1.pack
+      k2.should be_a Key
+      k2.should eq(k1)
+    end
+  end
+end

data/spec/notation/model/link_spec.rb

@@ -1,8 +1,9 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'yaml'
 
 [
-  [Link::Glissando, Link::Portamento, LINK_SYMBOLS[Links::GLISSANDO]],
-  [Link::Portamento, Link::Glissando, LINK_SYMBOLS[Links::PORTAMENTO]],
+  [Link::Glissando, Link::Portamento, LINK_SYMBOLS[Link::Glissando]],
+  [Link::Portamento, Link::Glissando, LINK_SYMBOLS[Link::Portamento]],
 ].each do |klass,klass2,link_symbol|
   describe klass do
     before :all do
@@ -41,6 +42,20 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
         YAML.load(@obj.to_yaml).should eq @obj
       end
     end
+
+    describe '#pack' do
+      it 'should produce a Hash' do
+        @obj.pack.should be_a Hash
+      end
+    end
+
+    describe 'unpack' do
+      it 'should produce a Link object equal the original' do
+        obj2 = @obj.class.unpack @obj.pack
+        obj2.should be_a @obj.class
+        obj2.should eq @obj
+      end
+    end
     
     describe '#to_s' do
       it 'should produce string that include link char and target pitch str' do
@@ -76,10 +91,24 @@ describe Link::Tie do
       YAML.load(@obj.to_yaml).should eq @obj
     end
   end
-  
+
+  describe '#pack' do
+    it 'should produce a Hash' do
+      @obj.pack.should be_a Hash
+    end
+  end
+
+  describe 'unpack' do
+    it 'should produce a Link object equal the original' do
+      obj2 = @obj.class.unpack @obj.pack
+      obj2.should be_a @obj.class
+      obj2.should eq @obj
+    end
+  end
+
   describe '#to_s' do
-    it "should return #{LINK_SYMBOLS[Links::TIE]}" do
-      @obj.to_s.should eq(LINK_SYMBOLS[Links::TIE])
+    it "should return #{LINK_SYMBOLS[Link::Tie]}" do
+      @obj.to_s.should eq(LINK_SYMBOLS[Link::Tie])
     end
   end
 end

data/spec/notation/model/meter_spec.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'yaml'
 
 describe Meter do
   describe '#initialize' do
@@ -47,6 +48,20 @@ describe Meter do
       YAML.load(m.to_yaml).should eq m
     end
   end
+
+  describe '#pack' do
+    it 'should produce a Hash' do
+      FOUR_FOUR.pack.should be_a Hash
+    end
+  end
+
+  describe 'unpack' do
+    it 'should produce an object equal the original' do
+      m2 = Meter.unpack FOUR_FOUR.pack
+      m2.should be_a Meter
+      m2.should eq(FOUR_FOUR)
+    end
+  end
   
   describe '#to_s' do
     context 'beat duration with 1 in denominator' do

data/spec/notation/model/note_spec.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'yaml'
 
 describe Note do
   before :all do
@@ -10,20 +11,24 @@ describe Note 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)
+    it "should assign :articulation to NORMAL if not given" do
+      Note.new(2).articulation.should eq(NORMAL)
     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
+    it 'should assign :marks to [] if not given' do
+      Note.new(2).marks.should eq([])
     end
     
-    it 'should assign :accented if given' do
-      Note.new(2, accented: true).accented.should be true
+    it 'should assign :marks if given' do
+      [
+        [], [BEGIN_SLUR, BEGIN_TRIPLET]
+      ].each do |marks|
+        Note.quarter(marks: marks).marks.should eq(marks)
+      end
     end
     
     it 'should have no pitches if not given' do
@@ -95,13 +100,10 @@ describe Note do
     end
   end
   
-  describe '#stretch' do
-    it 'should multiply note duration by ratio' do
-      note = Note::quarter.stretch(2)
+  describe '#resize' do
+    it 'should return new note object with given duration' do
+      note = Note::quarter.resize("1/2".to_r)
       note.duration.should eq(Rational(1,2))
-      
-      note = Note::quarter.stretch(Rational(1,2))
-      note.duration.should eq(Rational(1,8))
     end
   end
   
@@ -114,7 +116,7 @@ describe Note do
     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 ]
+      articulations = [NORMAL, TENUTO, MARCATO, ACCENT, PORTATO, STACCATO, STACCATISSIMO ]
       pitches_links_sets = [
         [[],{}],
         [[C2],{}],
@@ -129,8 +131,8 @@ describe Note do
           pitches,links = pitches_links_set
           if pitches.any?
             articulations.each do |art|
-              [true,false].each do |acc|
-                notes.push Note.new(d, pitches, articulation: art, links: links, accented: acc)
+              [[],[BEGIN_SLUR],[END_SLUR, BEGIN_TRIPLET]].each do |marks|
+                notes.push Note.new(d, pitches, articulation: art, links: links, marks: marks)
               end
             end
           else
@@ -163,6 +165,22 @@ describe Note do
       YAML.load(n.to_yaml).should eq n
     end
   end
+
+  describe '#pack' do
+    it 'should produce a Hash' do
+      n = Note.quarter([E2,F2,A2], articulation: STACCATO, marks: [BEGIN_SLUR], links: {E2 => Link::Tie.new, F2 => Link::Glissando.new(C3)})
+      n.pack.should be_a Hash
+    end
+  end
+
+  describe 'unpack' do
+    it 'should produce an object equal the original' do
+      n = Note.quarter([E2,F2,A2], articulation: STACCATO, marks: [BEGIN_SLUR], links: {E2 => Link::Tie.new, F2 => Link::Glissando.new(C3)})
+      n2 = Note.unpack n.pack
+      n2.should be_a Note
+      n2.should eq n
+    end
+  end
   
   describe '#valid?' do
     context 'note with positive duration' do
@@ -170,17 +188,5 @@ describe Note 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

@@ -1,4 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'yaml'
 
 describe Part do
   describe '#initialize' do
@@ -17,16 +18,66 @@ describe Part do
       p = Part.new(Dynamics::FF, notes: notes, dynamic_changes: dcs)
       p.notes.should eq notes
       p.dynamic_changes.should eq dcs
+
+      p = Part.new(Dynamics::P, settings: [ "dummy" ])
+      p.settings.should eq [ "dummy" ]
+    end
+  end
+
+  describe '#find_settings' do
+    context 'settings is empty' do
+      it 'should return nil' do
+        Part.new(Dynamics::P).find_settings(Integer).should be_nil
+      end
+    end
+
+    context 'one or more objects in settings' do
+      before :all do
+        @part = Part.new(Dynamics::MF, settings: [ 5, "boy" ])
+      end
+
+      context 'given class of object in settings' do
+        it 'should return the object' do
+          @part.find_settings(Integer).should be_a Integer
+          @part.find_settings(String).should be_a String
+        end
+      end
+
+      context 'given class not of any object in settings' do
+        it 'should return nil' do
+          @part.find_settings(Float).should be_nil
+        end
+      end
     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 '#pack' do
+    it 'should produce a Hash' do
+      notes = [Note::whole([A2]), Note::half]
+      dcs = { "1/2".to_r => Change::Immediate.new(Dynamics::P), 1 => Change::Gradual.sigmoid(Dynamics::MF,1) }
+      p = Part.new(Dynamics::FF, notes: notes, dynamic_changes: dcs, settings: [ "dummy" ])
+      p.pack.should be_a Hash
+    end
+  end
+
+  describe 'unpack' do
+    it 'should produce an object equal the original' do
+      notes = [Note::whole([A2]), Note::half]
+      dcs = { "1/2".to_r => Change::Immediate.new(Dynamics::P), 1 => Change::Gradual.sigmoid(Dynamics::MF,1) }
+      p = Part.new(Dynamics::FF, notes: notes, dynamic_changes: dcs, settings: [ "dummy" ])
+      p2 = Part.unpack p.pack
+      p2.should be_a Part
+      p2.should eq p
+    end
+  end
+
   describe '#valid?' do
     { 'negative start dynamic' => [-0.01],
       'start dynamic > 1' => [1.01],
@@ -39,8 +90,6 @@ describe Part do
       'dynamic change values outside 0..1' => [
         0.5, :notes => [ Note::whole ],
         :dynamic_changes => { 0.2 => Change::Immediate.new(-0.01), 0.3 => Change::Gradual.linear(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