musicality 0.11.1 → 0.12.0

data/spec/notation/model/change_spec.rb

@@ -3,31 +3,31 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 describe Change::Immediate do
   context '#initialize' do
     it 'should set end value to given' do
-      Change::Immediate.new(5).end_value.should eq 5
+      expect(Change::Immediate.new(5).end_value).to eq 5
     end
   end
-    
+
   describe '==' do
     it 'should return true if two immediate changes have the same end value' do
-      Change::Immediate.new(5).should eq(Change::Immediate.new(5))
+      expect(Change::Immediate.new(5)).to eq(Change::Immediate.new(5))
     end
-    
+
     it 'should return false if two immediate changes do not have the same end value' do
-      Change::Immediate.new(5).should_not eq(Change::Immediate.new(4))
+      expect(Change::Immediate.new(5)).to_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
+      expect(YAML.load(c.to_yaml)).to eq c
     end
   end
 
   describe '#pack' do
     it 'should produce a Hash' do
       h = Change::Immediate.new(2).pack
-      h.should be_a Hash
+      expect(h).to be_a Hash
     end
   end
 
@@ -35,8 +35,8 @@ describe Change::Immediate 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
+      expect(c2).to be_a Change::Immediate
+      expect(c2).to eq c1
     end
   end
 end
@@ -45,104 +45,104 @@ describe Change::Gradual do
   context '#initialize' do
     it 'should set end value and duration to given values' do
       ch = Change::Gradual.new(5,2,Change::Gradual::LINEAR)
-      ch.end_value.should eq(5)
-      ch.duration.should eq(2)
+      expect(ch.end_value).to eq(5)
+      expect(ch.duration).to eq(2)
     end
-    
+
     it 'should set start_value to nil if not given' do
-      Change::Gradual.linear(5,2).start_value.should be nil
+      expect(Change::Gradual.linear(5,2).start_value).to be nil
     end
-    
+
     it 'should set start_value if given' do
-      Change::Gradual.linear(5,2, start_value: 3).start_value.should eq(3)
+      expect(Change::Gradual.linear(5,2, start_value: 3).start_value).to eq(3)
     end
-    
+
     it 'should raise NonPositiveError if duration is <= 0' do
       expect { Change::Gradual.new(11,0,Change::Gradual::LINEAR) }.to raise_error(NonPositiveError)
       expect { Change::Gradual.new(11,-1,Change::Gradual::LINEAR) }.to raise_error(NonPositiveError)
     end
   end
-  
+
   describe '#relative?' do
     context 'start_value is nil' do
       it 'should return true' do
-        Change::Gradual.linear(25,3).relative?.should be true
+        expect(Change::Gradual.linear(25,3).relative?).to be true
       end
     end
-    
+
     context 'start_value is not nil' do
       it 'should return false' do
-        Change::Gradual.linear(25,3, start_value: 10).relative?.should be false
+        expect(Change::Gradual.linear(25,3, start_value: 10).relative?).to be false
       end
     end
   end
-  
+
   context '.linear' do
     before(:all){ @change = Change::Gradual.linear(55,20, start_value: 25) }
-    
+
     it 'should assign end_value, duration, and start_value as normal' do
-      @change.end_value.should eq(55)
-      @change.duration.should eq(20)
-      @change.start_value.should eq(25)
+      expect(@change.end_value).to eq(55)
+      expect(@change.duration).to eq(20)
+      expect(@change.start_value).to eq(25)
     end
-    
+
     it 'should set transition to linear' do
-      @change.transition.should eq(Change::Gradual::LINEAR)
+      expect(@change.transition).to eq(Change::Gradual::LINEAR)
     end
   end
 
   context '.sigmoid' do
     before(:all){ @change = Change::Gradual.sigmoid(55,20, start_value: 25) }
-    
+
     it 'should assign end_value, duration, and start_value as normal' do
-      @change.end_value.should eq(55)
-      @change.duration.should eq(20)
-      @change.start_value.should eq(25)
+      expect(@change.end_value).to eq(55)
+      expect(@change.duration).to eq(20)
+      expect(@change.start_value).to eq(25)
     end
-    
+
     it 'should set transition to SIGMOID' do
-      @change.transition.should eq(Change::Gradual::SIGMOID)
+      expect(@change.transition).to eq(Change::Gradual::SIGMOID)
     end
   end
-  
+
   describe '==' do
     context 'two gradual changes have the same end value, duration, and start value' do
       it 'should return true' do
-        Change::Gradual.linear(5,2).should eq(Change::Gradual.linear(5,2))
-        Change::Gradual.linear(5,2,start_value:0).should eq(Change::Gradual.linear(5,2,start_value:0))
+        expect(Change::Gradual.linear(5,2)).to eq(Change::Gradual.linear(5,2))
+        expect(Change::Gradual.linear(5,2,start_value:0)).to eq(Change::Gradual.linear(5,2,start_value:0))
       end
     end
-    
+
     context 'two gradual changes do not have the same end value' do
       it 'should return false' do
-        Change::Gradual.linear(5,2).should_not eq(Change::Gradual.linear(4,2))
+        expect(Change::Gradual.linear(5,2)).to_not eq(Change::Gradual.linear(4,2))
       end
     end
-    
+
     context 'two gradual changes do not have the same duration' do
       it 'should return false' do
-        Change::Gradual.linear(5,2).should_not eq(Change::Gradual.linear(5,1))
+        expect(Change::Gradual.linear(5,2)).to_not eq(Change::Gradual.linear(5,1))
       end
     end
-    
+
     context 'two gradual changes do not have the start value' do
       it 'should return false' do
-        Change::Gradual.linear(5,2, start_value: 3).should_not eq(Change::Gradual.linear(5,1))
+        expect(Change::Gradual.linear(5,2, start_value: 3)).to_not eq(Change::Gradual.linear(5,1))
       end
     end
   end
-  
+
   describe '#to_yaml' do
     it 'should produce YAML that can be loaded' do
       c = Change::Gradual.linear(4,2)
-      YAML.load(c.to_yaml).should eq c
+      expect(YAML.load(c.to_yaml)).to 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
+      expect(h).to be_a Hash
     end
   end
 
@@ -150,47 +150,47 @@ describe Change::Gradual 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
+      expect(c2).to be_a Change::Gradual
+      expect(c2).to eq c1
     end
   end
 end
 
 describe Change::Gradual::Trimmed do
   it 'should be a Change::Gradual' do
-    Change::Gradual::Trimmed.new(35,1,Change::Gradual::LINEAR,preceding: 0, remaining: 0.5).should be_a Change::Gradual
+    expect(Change::Gradual::Trimmed.new(35,1,Change::Gradual::LINEAR,preceding: 0, remaining: 0.5)).to be_a Change::Gradual
   end
-  
+
   describe '.linear' do
     before(:all){ @change = Change::Gradual::Trimmed.linear(55,20,preceding:5,remaining:6) }
-    
+
     it 'should assign end_value, duration, preceding, and remaining as normal' do
-      @change.end_value.should eq(55)
-      @change.duration.should eq(20)
-      @change.preceding.should eq(5)
-      @change.remaining.should eq(6)
+      expect(@change.end_value).to eq(55)
+      expect(@change.duration).to eq(20)
+      expect(@change.preceding).to eq(5)
+      expect(@change.remaining).to eq(6)
     end
-    
+
     it 'should set transition to linear' do
-      @change.transition.should eq(Change::Gradual::LINEAR)
+      expect(@change.transition).to eq(Change::Gradual::LINEAR)
     end
   end
-  
+
   describe '.sigmoid' do
     before(:all){ @change = Change::Gradual::Trimmed.sigmoid(55,20,preceding:5,remaining:6) }
-    
+
     it 'should assign end_value, duration, preceding, and remaining as normal' do
-      @change.end_value.should eq(55)
-      @change.duration.should eq(20)
-      @change.preceding.should eq(5)
-      @change.remaining.should eq(6)
+      expect(@change.end_value).to eq(55)
+      expect(@change.duration).to eq(20)
+      expect(@change.preceding).to eq(5)
+      expect(@change.remaining).to eq(6)
     end
-    
+
     it 'should set transition to SIGMOID' do
-      @change.transition.should eq(Change::Gradual::SIGMOID)
+      expect(@change.transition).to eq(Change::Gradual::SIGMOID)
     end
   end
-  
+
   it 'should raise NegativeError if preceding is < 0' do
     expect { Change::Gradual::Trimmed.linear(11,1,preceding: -1,remaining: 0.5) }.to raise_error(NegativeError)
   end
@@ -199,41 +199,41 @@ describe Change::Gradual::Trimmed do
     expect { Change::Gradual::Trimmed.linear(11,3,preceding: 1,remaining: 0) }.to raise_error(NonPositiveError)
     expect { Change::Gradual::Trimmed.linear(11,3,preceding: 1,remaining: -1) }.to raise_error(NonPositiveError)
   end
-  
+
   describe '#untrim' do
     before :all do
       @trimmed = Change::Gradual.linear(51,12).trim(2,2)
       @untrimmed = @trimmed.untrim
     end
-    
+
     it 'should return a Change::Gradual' do
-      @untrimmed.should be_a Change::Gradual
+      expect(@untrimmed).to be_a Change::Gradual
     end
-    
+
     it 'should keep end_value, duration, and transition' do
-      @untrimmed.end_value.should eq(@trimmed.end_value)
-      @untrimmed.duration.should eq(@trimmed.duration)
-      @untrimmed.transition.should eq(@trimmed.transition)
+      expect(@untrimmed.end_value).to eq(@trimmed.end_value)
+      expect(@untrimmed.duration).to eq(@trimmed.duration)
+      expect(@untrimmed.transition).to eq(@trimmed.transition)
     end
   end
-  
+
   describe '#trailing' do
     it 'should return the amount of transition unused at the end' do
-      Change::Gradual.linear(41,19).trim(4,9).trailing.should eq(9)
+      expect(Change::Gradual.linear(41,19).trim(4,9).trailing).to 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
+      expect(YAML.load(c.to_yaml)).to 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
+      expect(h).to be_a Hash
     end
   end
 
@@ -241,8 +241,8 @@ describe Change::Gradual::Trimmed 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
+      expect(c2).to be_a Change::Gradual::Trimmed
+      expect(c2).to eq c1
     end
   end
-end
+end

data/spec/notation/model/key_spec.rb

@@ -1,44 +1,28 @@
 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)
+  describe '.major' do
+    it 'should set triad to MAJOR' do
+      k = Key.major(PitchClasses::C)
+      expect(k.triad_type).to eq(Key::MAJOR)
+      expect(k.accidental_type).to eq(Key::NONE)
     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)
+  describe '.minor' do
+    it 'should set triad to MINOR' do
+      k = Key.minor(PitchClasses::A)
+      expect(k.triad_type).to eq(Key::MINOR)
+      expect(k.accidental_type).to eq(Key::NONE)
     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 
+        { 12 => 0, 13 => 1, -1 => 11, 24 => 0, 18 => 6
         }.each do |t1,t2|
-          Key.major_flat(t1).tonic_pc.should eq(t2)
+          expect(Key.major(t1).tonic_pc).to eq(t2)
         end
       end
     end
@@ -46,33 +30,33 @@ describe Key do
     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)
+          expect(Key.major(pc).tonic_pc).to 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
+
+    context 'given accidental type is FLAT' do
       it 'should return true' do
-        Key.major_flat(0).flat?.should be true
+        expect(Key.major(PitchClasses::F).flat?).to be true
       end
     end
-    context 'given accidental_pref is SHARP' do
+    context 'given accidental type is SHARP' do
+      it 'should return false' do
+        expect(Key.major(PitchClasses::D).flat?).to be false
+      end
+    end
+    context 'given accidental type is NONE' do
       it 'should return false' do
-        Key.major_sharp(0).flat?.should be false
+        expect(Key.major(PitchClasses::C).flat?).to be false
       end
     end
   end
@@ -80,12 +64,17 @@ describe Key do
   describe '#sharp?' do
     context 'given accidental_pref is FLAT' do
       it 'should return false' do
-        Key.major_flat(0).sharp?.should be false
+        expect(Key.major(PitchClasses::F).sharp?).to be false
       end
     end
     context 'given accidental_pref is SHARP' do
       it 'should return true' do
-        Key.major_sharp(0).sharp?.should be true
+        expect(Key.major(PitchClasses::D).sharp?).to be true
+      end
+    end
+    context 'given accidental type is NONE' do
+      it 'should return false' do
+        expect(Key.major(PitchClasses::C).sharp?).to be false
       end
     end
   end
@@ -93,12 +82,12 @@ describe Key do
   describe '#major?' do
     context 'given triad is MAJOR' do
       it 'should return true' do
-        Key.major_flat(0).major?.should be true
+        expect(Key.major(0).major?).to be true
       end
     end
     context 'given triad is MINOR' do
       it 'should return false' do
-        Key.minor_flat(0).major?.should be false
+        expect(Key.minor(0).major?).to be false
       end
     end
   end
@@ -106,66 +95,143 @@ describe Key do
   describe '#minor?' do
     context 'given triad is MAJOR' do
       it 'should return false' do
-        Key.major_flat(0).minor?.should be false
+        expect(Key.major(0).minor?).to be false
       end
     end
     context 'given triad is MINOR' do
       it 'should return true' do
-        Key.minor_flat(0).minor?.should be true
+        expect(Key.minor(0).minor?).to 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))
+        expect(Key.major(0)).to_not eq(Key.major(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))
+        expect(Key.major(0)).to_not eq(Key.minor(0))
       end
     end
-    
-    context 'objects with same tonic_pc, triad, and accidental_type' do
+
+    context 'objects with same tonic_pc and triad type' do
       it 'should return true' do
-        Key.major_flat(0).should eq(Key.major_flat(0))
+        expect(Key.major(0)).to eq(Key.major(0))
       end
     end
   end
-  
+
   describe '#clone' do
     it 'should return a different, equal object' do
-      k1 = Key.major_flat(0)
+      k1 = Key.major(0)
       k2 = k1.clone
-      k1.should_not be k2
-      k1.should eq k2
+      expect(k1).to_not be k2
+      expect(k1).to eq k2
     end
   end
-  
+
   describe '#accidentals' do
+    context 'C major or A minor' do
+      it 'should have no accidentals' do
+        expect(Keys::C_MAJOR.accidentals).to be_empty
+        expect(Keys::A_MINOR.accidentals).to be_empty
+      end
+    end
+
+    context 'F major or D minor' do
+      it 'should have one flat' do
+        expect(Keys::F_MAJOR.accidentals).to eq(Key::ACCIDENTALS[Key::FLAT].take(1))
+        expect(Keys::D_MINOR.accidentals).to eq(Key::ACCIDENTALS[Key::FLAT].take(1))
+      end
+    end
+
+    context 'Bb major or G minor' do
+      it 'should have two flats' do
+        expect(Keys::Bb_MAJOR.accidentals).to eq(Key::ACCIDENTALS[Key::FLAT].take(2))
+        expect(Keys::G_MINOR.accidentals).to eq(Key::ACCIDENTALS[Key::FLAT].take(2))
+      end
+    end
+
+    context 'Eb major or C minor' do
+      it 'should have three flats' do
+        expect(Keys::Eb_MAJOR.accidentals).to eq(Key::ACCIDENTALS[Key::FLAT].take(3))
+        expect(Keys::C_MINOR.accidentals).to eq(Key::ACCIDENTALS[Key::FLAT].take(3))
+      end
+    end
+
+    context 'Ab major or F minor' do
+      it 'should have four flats' do
+        expect(Keys::Ab_MAJOR.accidentals).to eq(Key::ACCIDENTALS[Key::FLAT].take(4))
+        expect(Keys::F_MINOR.accidentals).to eq(Key::ACCIDENTALS[Key::FLAT].take(4))
+      end
+    end
+
+    context 'Db major or Bb minor' do
+      it 'should have five flats' do
+        expect(Keys::Db_MAJOR.accidentals).to eq(Key::ACCIDENTALS[Key::FLAT].take(5))
+        expect(Keys::Bb_MINOR.accidentals).to eq(Key::ACCIDENTALS[Key::FLAT].take(5))
+      end
+    end
+
+    context 'Gb major or Eb minor' do
+      it 'should have six flats' do
+        expect(Keys::Gb_MAJOR.accidentals).to eq(Key::ACCIDENTALS[Key::FLAT].take(6))
+        expect(Keys::Eb_MINOR.accidentals).to eq(Key::ACCIDENTALS[Key::FLAT].take(6))
+      end
+    end
+
+    context 'G major or E minor' do
+      it 'should have one sharp' do
+        expect(Keys::G_MAJOR.accidentals).to eq(Key::ACCIDENTALS[Key::SHARP].take(1))
+        expect(Keys::E_MINOR.accidentals).to eq(Key::ACCIDENTALS[Key::SHARP].take(1))
+      end
+    end
+
+    context 'D major or B minor' do
+      it 'should have two sharps' do
+        expect(Keys::D_MAJOR.accidentals).to eq(Key::ACCIDENTALS[Key::SHARP].take(2))
+        expect(Keys::B_MINOR.accidentals).to eq(Key::ACCIDENTALS[Key::SHARP].take(2))
+      end
+    end
+
+    context 'A major or F# minor' do
+      it 'should have three sharps' do
+        expect(Keys::A_MAJOR.accidentals).to eq(Key::ACCIDENTALS[Key::SHARP].take(3))
+        expect(Keys::Fs_MINOR.accidentals).to eq(Key::ACCIDENTALS[Key::SHARP].take(3))
+      end
+    end
+
+    context 'E major or C# minor' do
+      it 'should have four sharps' do
+        expect(Keys::E_MAJOR.accidentals).to eq(Key::ACCIDENTALS[Key::SHARP].take(4))
+        expect(Keys::Cs_MINOR.accidentals).to eq(Key::ACCIDENTALS[Key::SHARP].take(4))
+      end
+    end
+
+    context 'B major or G# minor' do
+      it 'should have five sharps' do
+        expect(Keys::B_MAJOR.accidentals).to eq(Key::ACCIDENTALS[Key::SHARP].take(5))
+        expect(Keys::Gs_MINOR.accidentals).to eq(Key::ACCIDENTALS[Key::SHARP].take(5))
+      end
+    end
   end
 
   describe '#pack' do
     it 'should return a Hash' do
-      Key.major_sharp(1).pack.should be_a Hash
+      expect(Key.major(1).pack).to be_a Hash
     end
   end
 
   describe '.unpack' do
     it 'should return a Key object equal to the original' do
-      k1 = Key.major_sharp(1)
+      k1 = Key.major(1)
       k2 = Key.unpack k1.pack
-      k2.should be_a Key
-      k2.should eq(k1)
+      expect(k2).to be_a Key
+      expect(k2).to eq(k1)
     end
   end
 end