mtk 0.0.2 → 0.0.3

data/spec/mtk/pitch_class_set_spec.rb

@@ -26,6 +26,12 @@ describe MTK::PitchClassSet do
     end
   end
 
+  describe ".new" do
+    it "maintains the pitch class collection exactly (preserves order and keeps duplicates)" do
+      PitchClassSet.new([C, E, G, E, B, C]).pitch_classes.should == [C, E, G, E, B, C]
+    end
+  end
+
   describe "#pitch_classes" do
     it "is the list of pitch_classes contained in this set" do
       pitch_class_set.pitch_classes.should == pitch_classes
@@ -45,10 +51,6 @@ describe MTK::PitchClassSet do
       pitch_classes << D
       pitch_class_set.pitch_classes.length.should == 3
     end
-
-    it "does not include duplicates" do
-      PitchClassSet.new([C, E, G, C]).pitch_classes.should == [C, E, G]
-    end
   end
 
   describe "#to_a" do
@@ -113,7 +115,7 @@ describe MTK::PitchClassSet do
 
   describe '#transpose' do
     it 'transposes by the given semitones' do
-      (pitch_class_set.transpose 4.semitones).should == PitchClassSet(E, Ab, B)
+      (pitch_class_set.transpose 4).should == PitchClassSet(E, Ab, B)
     end
   end
 
@@ -169,12 +171,6 @@ describe MTK::PitchClassSet do
     end
   end
 
-  describe "#repeat" do
-    it "does nothing to PitchClassSets, since duplicates are removed from Sets" do
-      pitch_class_set.repeat.should == pitch_class_set
-    end
-  end
-
   describe "#rotate" do
     it "produces a PitchClassSet that is rotated by the given offset" do
       pitch_class_set.rotate(2).should == PitchClassSet(G,C,E)
@@ -205,8 +201,8 @@ describe MTK::PitchClassSet do
   end
 
   describe "#concat" do
-    it "appends the non-duplicate pitch classes from the other set" do
-      pitch_class_set.concat(PitchClassSet(D,E,F)).should == PitchClassSet(C,E,G,D,F)
+    it "appends the pitch classes from the other set" do
+      pitch_class_set.concat(PitchClassSet(D,E,F)).should == PitchClassSet(C,E,G,D,E,F)
     end
   end
 
@@ -249,6 +245,10 @@ describe MTK::PitchClassSet do
       pitch_class_set.should_not == PitchClassSet(C,G,E)
     end
 
+    it "is false when if otherwise equal pitch class sets don't contain the same number of duplicates" do
+      PitchClassSet.new([C, E, G]).should_not == PitchClassSet.new([C, C, E, G])
+    end
+
     it "is false if two pitch class sets do not contain the same pitch classes" do
       pitch_class_set.should_not == PitchClassSet(C,E)
     end
@@ -263,6 +263,10 @@ describe MTK::PitchClassSet do
       pitch_class_set.should =~ PitchClassSet(C,E,G)
     end
 
+    it "is true when all the pitch classes are equal, even with different numbers of duplicates" do
+      Melody.new([C, E, G]).should =~ Melody.new([C, C, E, G])
+    end
+
     it "is true if two pitch class sets are not in the same order" do
       pitch_class_set.should =~ PitchClassSet(C,G,E)
     end
@@ -286,18 +290,16 @@ describe MTK::PitchClassSet do
     end
   end
 
-  describe ".span_for" do
-    it "measure the distance between the first and last pitch classes" do
-      PitchClassSet.span_for([C,D,E,F,G]).should == 7
-    end
-  end
-
 end
 
 describe MTK do
 
   describe '#PitchClassSet' do
 
+    it "constructs a PitchClassSet" do
+      PitchClassSet(C,D).should be_a PitchClassSet
+    end
+
     it "acts like new for a single Array argument" do
       PitchClassSet([C,D]).should == PitchClassSet.new([C,D])
     end
@@ -322,9 +324,9 @@ describe MTK do
       PitchClassSet('C').should == PitchClassSet.new([C])
     end
 
-    it "returns the argument if it's already a PitchClassSet" do
+    it "handles a a PitchClassSet" do
       pitch_set = PitchClassSet.new([C,D])
-      PitchClassSet(pitch_set).should be_equal pitch_set
+      PitchClassSet(pitch_set).should == PitchClassSet([C,D])
     end
 
     it "raises an error for types it doesn't understand" do

data/spec/mtk/pitch_class_spec.rb

@@ -2,26 +2,29 @@ require 'spec_helper'
 
 describe MTK::PitchClass do
 
-  let(:names) {
+  let(:enharmonic_spellings_grouped_by_value) {
+    # not sure how to test this without re-coding these names here
     [
-        ['B#', 'C', 'Dbb'],
-        ['B##', 'C#', 'Db'],
-        ['C##', 'D', 'Ebb'],
-        ['D#', 'Eb', 'Fbb'],
-        ['D##', 'E', 'Fb'],
-        ['E#', 'F', 'Gbb'],
-        ['E##', 'F#', 'Gb'],
-        ['F##', 'G', 'Abb'],
-        ['G#', 'Ab'],
-        ['G##', 'A', 'Bbb'],
-        ['A#', 'Bb', 'Cbb'],
-        ['A##', 'B', 'Cb']
-    ].flatten
+      %w( B#  C  Dbb ),
+      %w( B## C# Db  ),
+      %w( C## D  Ebb ),
+      %w( D#  Eb Fbb ),
+      %w( D## E  Fb  ),
+      %w( E#  F  Gbb ),
+      %w( E## F# Gb  ),
+      %w( F## G  Abb ),
+      %w( G#     Ab  ),
+      %w( G## A  Bbb ),
+      %w( A#  Bb Cbb ),
+      %w( A## B  Cb  )
+    ]
   }
+  let(:enharmonic_spellings) { enharmonic_spellings_grouped_by_value.flatten }
 
+  
   describe 'NAMES' do
     it "is the 12 note names in western chromatic scale" do
-      PitchClass::NAMES =~ ['C', 'Db', 'D', 'Eb', 'E', 'F', 'Gb', 'G', 'Ab', 'A', 'Bb', 'B']
+      PitchClass::NAMES.should =~ %w( C Db D Eb E F Gb G Ab A Bb B )
     end
 
     it "is immutable" do
@@ -29,60 +32,111 @@ describe MTK::PitchClass do
     end
   end
 
+  
+  describe 'VALID_NAMES_BY_VALUE' do
+    it 'contains enharmonic spellings of NAMES' do
+      PitchClass::VALID_NAMES_BY_VALUE.should =~ enharmonic_spellings_grouped_by_value
+    end
+
+    it 'organized such that the index of each equivalent spelling matches the index in NAMES' do
+      PitchClass::NAMES.each.with_index do |name,index|
+        PitchClass::VALID_NAMES_BY_VALUE[index].should include(name)
+      end
+    end
+
+    it 'is immutable' do
+      lambda{ PitchClass::VALID_NAMES_BY_VALUE << 'H' }.should raise_error
+    end
+  end
+
+  
   describe 'VALID_NAMES' do
-    it "is all enharmonic spellings of NAMES including sharps, flats, double-sharps, and double-flats" do
-      PitchClass::VALID_NAMES =~ names
+    it 'is all enharmonic spellings of NAMES including sharps, flats, double-sharps, and double-flats' do
+      PitchClass::VALID_NAMES.should =~ enharmonic_spellings.flatten
     end
 
-    it "is immutable" do
+    it 'is immutable' do
       lambda{ PitchClass::VALID_NAMES << 'H' }.should raise_error
     end
   end
 
+  
+  describe 'PITCH_CLASSES' do
+    it 'is the 12 pitch classes in the chromatic scale, indexed by value' do
+      for pc in PitchClass::PITCH_CLASSES
+        pc.should == PitchClass::PITCH_CLASSES[pc.value]
+      end
+    end
+
+    it 'is immutable' do
+      lambda{ PitchClass::PITCH_CLASSES << C }.should raise_error
+    end
+  end
+
+  
   describe '.new' do
     it "is private" do
       lambda{ PitchClass.new('C',0) }.should raise_error
     end
   end
 
-  describe '.from_s' do
+  
+  describe '.[]' do
     context "the argument is a valid name" do
       it "returns a PitchClass" do
-        names.each { |name| PitchClass[name].should be_a PitchClass }
+        enharmonic_spellings.each { |name| PitchClass[name].should be_a PitchClass }
       end
       it "returns an object with that name" do
-        names.each { |name| PitchClass[name].name.should == name }
+        enharmonic_spellings.each { |name| PitchClass[name].name.should == name }
       end
       it "ignores case" do
-        for name in names
+        for name in enharmonic_spellings
           PitchClass[name.upcase].name.should == name
           PitchClass[name.downcase].name.should == name
         end
       end
     end
     context "the argument is not a valid name" do
-      it "returns nil, if the name doesn't exist" do
-        PitchClass['z'].should be_nil
+      it "raises a NameError if the name doesn't exist" do
+        lambda{ PitchClass['z'] }.should raise_error ArgumentError
       end
     end
   end
 
+  
   describe '.from_s' do
-    it "acts like .[]" do
-      for name in ['C', 'bbb', 'z']
-        PitchClass.from_s(name).should == PitchClass[name]
+    it "returns a PitchClass for any valid name" do
+      for name in enharmonic_spellings
+        pc = PitchClass.from_s(name)
+        pc.should be_a PitchClass
+        pc.name.should == name
+      end
+    end
+
+    it "does case-insensitive matching" do
+      for name in enharmonic_spellings
+        pc = PitchClass.from_s(name.downcase)
+        pc.should be_a PitchClass
+        pc.name.should == name
       end
     end
+
+    it "raises a ArgumentError for invalid arguments" do
+      lambda{ PitchClass.from_s('H') }.should raise_error ArgumentError
+    end
   end
 
+
   describe '.from_name' do
-    it "acts like .[]" do
-      for name in ['C', 'bbb', 'z']
-        PitchClass.from_name(name).should == PitchClass[name]
+    it "acts like .from_s" do
+      for name in enharmonic_spellings
+        PitchClass.from_name(name).should == PitchClass.from_s(name)
       end
+      lambda{ PitchClass.from_name('H') }.should raise_error ArgumentError
     end
   end
 
+
   describe '.from_i' do
     it "returns the PitchClass with that value" do
       PitchClass.from_i(2).should == D
@@ -94,29 +148,59 @@ describe MTK::PitchClass do
     end
   end
 
+
+  describe '.from_value' do
+    it 'acts like .from_i' do
+      (0..11).each{|v| PitchClass.from_value(v).should == PitchClass.from_i(v) }
+    end
+  end
+
   describe '#name' do
     it "is the name of the pitch class" do
       C.name.should == 'C'
     end
   end
 
+
+  describe '#value' do
+    it "is the value of the pitch class" do
+      PitchClass::NAMES.each.with_index do |name,value|
+        PitchClass[name].value.should == value
+      end
+    end
+  end
+
+
   describe '#to_i' do
     it "is the integer value of the pitch class" do
-      C.to_i.should == 0
-      D.to_i.should == 2
-      E.to_i.should == 4
+      PitchClass::NAMES.each.with_index do |name,value|
+        PitchClass[name].to_i.should == value
+        PitchClass[name].to_i.should be_an Integer
+      end
+    end
+  end
+
+
+  describe '#to_f' do
+    it "is the floating point value of the pitch class" do
+      PitchClass::NAMES.each.with_index do |name,value|
+        PitchClass[name].to_f.should == value
+        PitchClass[name].to_f.should be_a Float
+      end
     end
   end
 
+
   describe '#to_s' do
     it "returns the name" do
       C.to_s.should == C.name
-      for name in names
+      for name in enharmonic_spellings
         PitchClass.from_s(name).to_s.should == name
       end
     end
   end
 
+
   describe '#==' do
     it "checks for equality" do
       C.should == C
@@ -128,6 +212,7 @@ describe MTK::PitchClass do
     end
   end
 
+
   describe "#<=>" do
     it "compares the underlying int value" do
       (C <=> D).should < 0
@@ -135,32 +220,46 @@ describe MTK::PitchClass do
     end
   end
 
+
   describe '#+' do
-    it "adds the integer value of the argument and #to_i" do
+    it "adds an integer argument to the pitch class's value" do
       (C + 4).should == E
     end
 
     it "'wraps around' the range 0-11" do
       (D + 10).should == C
     end
+
+    it "adds a floating point argument to the pitch class's value, and rounds to the nearest pitch class" do
+      (C + 0.49).should == C
+      (C + 0.50).should == Db
+    end
   end
 
+
   describe "#transpose" do
     it "behaves like #+" do
-      C.transpose(2.semitones).should == C + 2
+      C.transpose(2).should == C + 2
     end
   end
 
+
   describe '#-' do
-    it "subtracts the integer value of the argument from #to_i" do
+    it "subtracts an integer argument from the pitch class's value" do
       (E - 2).should == D
     end
 
     it "'wraps around' the range 0-11" do
       (C - 8).should == E
     end
+
+    it "subtracts a floating point argument from the pitch class's value, and rounds to the nearest pitch class'" do
+      (E - 0.50).should == E
+      (E - 0.51).should == Eb
+    end
   end
 
+
   describe "#invert" do
     it 'inverts the pitch class around the given center pitch class' do
       E.invert(D).should == C
@@ -173,8 +272,13 @@ describe MTK::PitchClass do
     it "returns the pitch class when the argument is the same pitch class" do
       E.invert(E).should == E
     end
+
+    it 'can invert pitch classes around the halfway point between 2 pitch classes' do
+      C.invert(0.5).should == Db
+    end
   end
 
+
   describe "#distance_to" do
     it "is the distance in semitones between 2 PitchClass objects" do
       C.distance_to(D).should == 2
@@ -215,7 +319,7 @@ describe MTK do
       PitchClass(:D).should == PitchClass.from_s('D')
     end
 
-    it "acts like from_i if the argument is a Numberic" do
+    it "acts like from_i if the argument is a Numeric" do
       PitchClass(3).should == PitchClass.from_i(3)
     end
 
@@ -223,8 +327,16 @@ describe MTK do
       PitchClass(C).should be_equal C
     end
 
+    it "raises an error for Strings it doesn't understand" do
+      lambda{ PitchClass('H') }.should raise_error ArgumentError
+    end
+
+    it "raises an error for Symbols it doesn't understand" do
+      lambda{ PitchClass(:H) }.should raise_error ArgumentError
+    end
+
     it "raises an error for types it doesn't understand" do
-      lambda{ PitchClass({:not => :compatible}) }.should raise_error
+      lambda{ PitchClass({:not => :compatible}) }.should raise_error ArgumentError
     end
   end
 

data/spec/mtk/pitch_spec.rb

@@ -69,6 +69,10 @@ describe MTK::Pitch do
     it("converts 'B#4' to middle c") { Pitch.from_s('B#4').should == middle_c }
     it("converts 'C-1' to a low c, 5 octaves below middle C") { Pitch.from_s('C-1').should == middle_c - 60 }
     it("converts 'C4+50.0cents' to middle C and 50 cents") { Pitch.from_s('C4+50.0cents').should == middle_c_and_50_cents }
+
+    it "raises an ArgumentError for invalid arguments" do
+      lambda{ Pitch.from_s('H4') }.should raise_error ArgumentError
+    end
   end
 
   describe '.from_name' do
@@ -137,6 +141,15 @@ describe MTK::Pitch do
     end
   end
 
+  describe '#inspect' do
+    it 'is "#<MTK::Pitch:{object_id} @value={value}>"' do
+      for value in [0, 60, 60.5, 127]
+        pitch = Pitch.from_f(value)
+        pitch.inspect.should == "#<MTK::Pitch:#{pitch.object_id} @value=#{value}>"
+      end
+    end
+  end
+
   describe '#+' do
     it 'adds the integer value of the argument and #to_i' do
       (middle_c + 2).should == Pitch.from_i(62)
@@ -156,7 +169,7 @@ describe MTK::Pitch do
 
   describe "#transpose" do
     it "behaves like #+" do
-      middle_c.transpose(2.semitones).should == middle_c + 2
+      middle_c.transpose(2).should == middle_c + 2
     end
   end
 
@@ -268,6 +281,14 @@ describe MTK do
       Pitch(C, 4, 0.5).should == Pitch.new(C, 4, 0.5)
     end
 
+    it "raises an error for Strings it doesn't understand" do
+      lambda{ Pitch('H4') }.should raise_error
+    end
+
+    it "raises an error for Symbols it doesn't understand" do
+      lambda{ Pitch(:H4) }.should raise_error
+    end
+
     it "raises an error for types it doesn't understand" do
       lambda{ Pitch({:not => :compatible}) }.should raise_error
     end