jmtk 0.0.3.3-java

data/spec/mtk/groups/collection_spec.rb

@@ -0,0 +1,374 @@
+require 'spec_helper'
+
+describe MTK::Groups::Collection do
+
+  class MockCollection
+    include MTK::Groups::Collection
+    attr_reader :elements
+    def initialize(elements); @elements = elements end
+    def self.from_a(elements); new(elements) end
+  end
+
+  class MockCollectionWithOptions
+    include MTK::Groups::Collection
+    attr_reader :elements, :options
+    def initialize(elements, options={})
+      @elements = elements
+      @options = options
+    end
+    def self.from_a(elements, options={})
+      new(elements, options)
+    end
+  end
+
+  let(:elements) { [1,2,3,4,5] }
+  let(:collection) { MockCollection.new elements }
+
+  let(:options) { {:opt1 => :val1, :opt2 => :val2} }
+  let(:collection_with_options) { MockCollectionWithOptions.new(elements, options) }
+
+  it "is Enumerable" do
+    collection.should be_a Enumerable
+  end
+
+  describe "#to_a" do
+    it "is the the Array of elements in the collection" do
+      collection.to_a.should == elements
+    end
+  end
+
+  describe "#size" do
+    it "is the length of the elements" do
+      collection.size.should == elements.length
+    end
+  end
+
+  describe "#length" do
+    it "acts like #size" do
+      collection.length.should == collection.size
+    end
+  end
+
+  describe "#empty?" do
+    it "is true when elements is nil" do
+      MockCollection.new(nil).empty?.should be_true
+    end
+
+    it "is true when elements is empty" do
+      MockCollection.new([]).empty?.should be_true
+    end
+
+    it "is false when elements is not empty" do
+      MockCollection.new([1]).empty?.should be_false
+    end
+  end
+
+  describe "#each" do
+    it "yields each element" do
+      yielded = []
+      collection.each do |element|
+        yielded << element
+      end
+      yielded.should == elements
+    end
+  end
+
+  describe "#map" do
+    it "returns a Collection with each item replaced with the results of the block" do
+      collection.map{|item| item + 10}.should == [11, 12, 13, 14, 15]
+    end
+
+    it "maintains the options from the original collection" do
+      collection_with_options.map{|item| item + 10}.options.should == options
+    end
+  end
+
+  describe "#first" do
+    it "is #[0] when no argument is given" do
+      collection.first.should == collection[0]
+    end
+
+    it "is the first n elements, for an argument n" do
+      collection.first(3).should == elements[0..2]
+    end
+
+    it "is the elements when n is bigger than elements.length, for an argument n" do
+      collection.first(elements.length * 2).should == elements
+    end
+  end
+
+  describe "#last when no argument is given" do
+    it "is #[-1]" do
+      collection.last.should == collection[-1]
+    end
+
+    it "is the last n elements, for an argument n" do
+      collection.last(3).should == elements[-3..-1]
+    end
+
+    it "is the elements when n is bigger than elements.length, for an argument n" do
+      collection.last(elements.length * 2).should == elements
+    end
+  end
+
+  describe "#[]" do
+    it "accesses an element by index" do
+      collection[3].should == elements[3]
+    end
+
+    it "supports negative indexes" do
+      collection[-1].should == elements[-1]
+    end
+
+    it "accesses ranges of elements" do
+      collection[0..3].should == elements[0..3]
+    end
+  end
+
+  describe "#repeat" do
+    it "repeats the elements the number of times given by the argument" do
+      collection.repeat(3).should == [1,2,3,4,5,1,2,3,4,5,1,2,3,4,5]
+    end
+
+    it "repeats the elements twice if no argument is given" do
+      collection.repeat.should == [1,2,3,4,5,1,2,3,4,5]
+    end
+
+    it "handles fractional repetitions" do
+      collection.repeat(1.6).should == [1,2,3,4,5,1,2,3]
+    end
+
+    it "returns an instance of the same type" do
+      collection.repeat.should be_a collection.class
+    end
+
+    it "does not modify the original collection" do
+      collection.repeat.should_not equal collection
+    end
+
+    it "maintains the options from the original collection" do
+      collection_with_options.repeat.options.should == options
+    end
+  end
+
+  describe "#permute" do
+    it "randomly rearranges the order of elements" do
+      elements = (0..1000).to_a
+      permuted = MockCollection.new(elements).permute
+      permuted.should_not == elements
+      permuted.sort.should == elements
+    end
+
+    it "returns an instance of the same type" do
+      collection.permute.should be_a collection.class
+    end
+
+    it "does not modify the original collection" do
+      collection.permute.should_not equal collection
+    end
+
+    it "maintains the options from the original collection" do
+      collection_with_options.permute.options.should == options
+    end
+  end
+
+  describe "#shuffle" do
+    it "behaves like #permute" do
+      elements = (0..1000).to_a
+      shuffled = MockCollection.new(elements).shuffle
+      shuffled.should_not == elements
+      shuffled.sort.should == elements
+    end
+
+    it "returns an instance of the same type" do
+      collection.shuffle.should be_a collection.class
+    end
+
+    it "does not modify the original collection" do
+      collection.shuffle.should_not equal collection
+    end
+
+    it "maintains the options from the original collection" do
+      collection_with_options.shuffle.options.should == options
+    end
+  end
+
+  describe "#rotate" do
+    it "produces a Collection that is rotated right by the given positive offset" do
+      collection.rotate(2).should == [3,4,5,1,2]
+    end
+
+    it "produces a Collection that is rotated left by the given negative offset" do
+      collection.rotate(-2).should == [4,5,1,2,3]
+    end
+
+    it "rotates by 1 if no argument is given" do
+      collection.rotate.should == [2,3,4,5,1]
+    end
+
+    it "returns an instance of the same type" do
+      collection.rotate.should be_a collection.class
+    end
+
+    it "does not modify the original collection" do
+      collection.rotate.should_not equal collection
+    end
+
+    it "maintains the options from the original collection" do
+      collection_with_options.rotate.options.should == options
+    end
+  end
+
+  describe "#concat" do
+    it "appends the argument to the elements" do
+      collection.concat([6,7]).should == [1,2,3,4,5,6,7]
+    end
+
+    it "returns an instance of the same type" do
+      collection.concat([6,7]).should be_a collection.class
+    end
+
+    it "does not modify the original collection" do
+      collection.concat([6,7]).should_not equal collection
+    end
+
+    it "maintains the options from the original (receiver) collection" do
+      collection_with_options.concat([6,7]).options.should == options
+    end
+
+    it "ignored any options from the argument collection" do
+      # I considered merging the options, but it seems potentially too confusing, so
+      # we'll go with this simpler behavior until a use-case appears where this is inappropriate.
+      arg = MockCollectionWithOptions.new(elements, :opt1 => :another_val, :opt3 => :val3)
+      collection_with_options.concat(arg).options.should == options
+    end
+  end
+
+  describe "#reverse" do
+    it "reverses the elements" do
+      collection.reverse.should == elements.reverse
+    end
+
+    it "returns an instance of the same type" do
+      collection.reverse.should be_a collection.class
+    end
+
+    it "does not modify the original collection" do
+      collection.reverse.should_not equal collection
+    end
+
+    it "maintains the options from the original collection" do
+      collection_with_options.reverse.options.should == options
+    end
+  end
+
+  describe "#partition" do
+    # TODO: better descriptions! (and document the method too!)
+
+    context "Numeric argument" do
+      it "partitions the elements into groups of the size, plus whatever's left over as the last element" do
+        collection.partition(2).should == [
+          MockCollection.new([1,2]),
+          MockCollection.new([3,4]),
+          MockCollection.new([5])
+        ]
+      end
+    end
+
+    context "Array argument" do
+      it "partitions the elements into groups of the size of the argument elements" do
+        collection.partition([1,2,2]).should == [
+          MockCollection.new([1]),
+          MockCollection.new([2,3]),
+          MockCollection.new([4,5])
+        ]
+      end
+
+      it "does not include leftover elements" do
+        collection.partition([1,3]).should == [
+          MockCollection.new([1]),
+          MockCollection.new([2,3,4])
+        ]
+      end
+
+      it "does not include extra elements" do
+        collection.partition([1,5]).should == [
+          MockCollection.new([1]),
+          MockCollection.new([2,3,4,5])
+        ]
+      end
+    end
+
+    context "no argument, block given" do
+      it "partitions the elements into groups with the same block return value" do
+        collection.partition{|item| item % 3 }.should =~ [
+          MockCollection.new([1,4]),
+          MockCollection.new([2,5]),
+          MockCollection.new([3])
+        ]
+      end
+
+      it "optionally passes the item index into the block" do
+        collection.partition{|item,index| (item*index) % 3 }.should =~ [
+          # 1*0, 2*1, 3*2, 4*3, 5*4 => (0, 2, 6, 12, 20) % 3 => 0, 2, 0, 0, 2
+          MockCollection.new([1,3,4]),
+          MockCollection.new([2,5]),
+        ]
+      end
+    end
+
+    context "incompatible / missing argument, no block given" do
+      it "returns self" do
+        collection.partition.should == collection
+      end
+    end
+
+  end
+
+  describe "#==" do
+    it "is true when the elements in 2 Collections are equal" do
+      collection.should == MockCollection.new(elements)
+    end
+
+    it "is true when the elements equal the argument" do
+      collection.should == elements
+    end
+
+    it "is false when the elements in 2 Collections are not equal" do
+      collection.should_not == MockCollection.new(elements + [1,2])
+    end
+
+    it "is false when the elements do not equal the argument" do
+      collection.should_not == (elements + [1,2])
+    end
+
+    it "is false when the options are not equal" do
+      collection.should_not == collection_with_options
+    end
+  end
+
+  describe "#clone" do
+    it "creates an equal collection" do
+      collection.clone.should == collection
+    end
+
+    it "creates a new collection" do
+      collection.clone.should_not equal collection
+    end
+
+    it "maintains the options from the original collection" do
+      collection_with_options.clone.options.should == options
+    end
+  end
+
+end
+
+
+describe "Array" do
+  describe "#rotate" do
+    # test the Ruby 1.8 backport of Array#rotate
+    it "should rotate the Array, as in Ruby 1.9's API" do
+      [1,2,3].rotate(1).should == [2,3,1]
+    end
+  end
+end

data/spec/mtk/groups/melody_spec.rb

@@ -0,0 +1,225 @@
+require 'spec_helper'
+
+describe MTK::Groups::Melody do
+
+  MELODY = MTK::Groups::Melody
+
+  let(:pitches) { [C4, D4, E4, D4] }
+  let(:melody) { MTK::Groups::Melody.new(pitches) }
+
+  it "is Enumerable" do
+    melody.should be_a Enumerable
+  end
+
+  describe ".new" do
+    it "maintains the pitches collection exactly (preserves order and keeps duplicates)" do
+      MELODY.new([C4, E4, G4, E4, B3, C4]).pitches.should == [C4, E4, G4, E4, B3, C4]
+    end
+  end
+  
+  describe ".from_pitch_classes" do
+    it "creates a pitch sequence from a list of pitch classes and starting point, selecting the nearest pitch to each pitch class" do
+      MELODY.from_pitch_classes([C,G,B,Eb,D,C], D3).should == [C3,G2,B2,Eb3,D3,C3]
+    end
+
+    it "defaults to a starting point of C4 (middle C)" do
+      MELODY.from_pitch_classes([C]).should == [C4]
+    end
+
+    it "doesn't travel within an octave above or below the starting point by default" do
+      MELODY.from_pitch_classes([C,F,Bb,D,A,E,B]).should == [C4,F4,Bb4,D4,A3,E3,B3]
+    end
+
+    it "allows max distance above or below the starting point to be set via the third argument" do
+      MELODY.from_pitch_classes([C,F,Bb,D,A,E,B], C4, 6).should == [C4,F4,Bb3,D4,A3,E4,B3]
+    end
+  end
+
+  describe '#pitches' do
+    it 'is the list of pitches used to construct the scale' do
+      melody.pitches.should == pitches
+    end
+
+    it "is immutable" do
+      lambda { melody.pitches << Db4 }.should raise_error
+    end
+
+    it "does not affect the immutabilty of the pitch list used to construct it" do
+      list = melody # force construction with the pitches array
+      expect { pitches << Db4 }.to change(pitches, :length).by(1)
+    end
+
+    it "is not affected by changes to the pitch list used to construct it" do
+      melody # force construction before we modify the pitches array
+      expect { pitches << Db4 }.to_not change(melody.pitches, :length)
+    end
+
+  end
+
+  describe "#to_a" do
+    it "is equal to #pitches" do
+      melody.to_a.should == melody.pitches
+    end
+
+    it "is mutable" do
+      (melody.to_a << Bb3).should == [C4, D4, E4, D4, Bb3]
+    end
+  end
+
+  describe "#each" do
+    it "yields each pitch" do
+      ps = []
+      melody.each{|p| ps << p }
+      ps.should == pitches
+    end
+  end
+
+  describe "#map" do
+    it "returns a MELODY with each Pitch replaced with the results of the block" do
+      melody.map{|p| p + 2}.should == [D4, E4, Gb4, E4]
+    end
+  end
+
+  describe "#to_pitch_class_set" do
+    it "is a PitchClassSet" do
+      melody.to_pitch_class_set.should be_a MTK::Groups::PitchClassSet
+    end
+
+    it "contains all the distinct pitch_classes in this MELODY by default" do
+      melody.to_pitch_class_set.pitch_classes.should == melody.pitch_classes.uniq
+    end
+
+    it "contains all the pitch_classes (including duplicates) when the argument is false" do
+      melody.to_pitch_class_set(false).pitch_classes.should == melody.pitch_classes
+    end
+  end
+
+
+  describe '#pitch_classes' do
+    it 'is the list of pitch classes for the pitches in this list' do
+      melody.pitch_classes.should == pitches.map { |p| p.pitch_class }
+    end
+  end
+
+  describe '#transpose' do
+    it 'transposes upward by the given semitones' do
+      melody.transpose(12).should == MELODY.new([C5, D5, E5, D5])
+    end
+  end
+
+  describe '#invert' do
+    it 'inverts all pitches around the given center pitch' do
+      (melody.invert Gb4).should == MELODY.new([C5, Bb4, Ab4, Bb4])
+    end
+
+    it 'inverts all pitches around the first pitch, when no center pitch is given' do
+      melody.invert.should == MELODY.new([C4, Bb3, Ab3, Bb3])
+    end
+  end
+
+  describe '#include?' do
+    it 'returns true if the Pitch is in the MELODY' do
+      (melody.include? C4).should be_true
+    end
+
+    it 'returns false if the Pitch is not in the MELODY' do
+      (melody.include? Db4).should be_false
+    end
+  end
+
+  describe '#==' do
+    it "is true when all the pitches are equal" do
+      MELODY.new([C4, E4, G4]).should == MELODY.new([Pitch.from_i(60), Pitch.from_i(64), Pitch.from_i(67)])
+    end
+
+    it "is false when not all the pitches are equal" do
+      MELODY.new([C4, E4, G4]).should_not == MELODY.new([Pitch.from_i(60), Pitch.from_i(65), Pitch.from_i(67)])
+    end
+
+    it "is false when if otherwise equal Melodies don't contain the same number of duplicates" do
+      MELODY.new([C4, E4, G4]).should_not == MELODY.new([C4, C4, E4, G4])
+    end
+
+    it "is false when if otherwise equal Melodies aren't in the same order" do
+      MELODY.new([C4, E4, G4]).should_not == MELODY.new([C4, G4, E4])
+    end
+
+    it "is false when the argument is not compatible" do
+      MELODY.new([C4, E4, G4]).should_not == :invalid
+    end
+
+    it "can be compared directly to Arrays" do
+      MELODY.new([C4, E4, G4]).should == [C4, E4, G4]
+    end
+  end
+
+  describe "#=~" do
+    it "is true when all the pitches are equal" do
+      MELODY.new([C4, E4, G4]).should =~ MELODY.new([C4, E4, G4])
+    end
+
+    it "is true when all the pitches are equal, even with different numbers of duplicates" do
+      MELODY.new([C4, E4, G4]).should =~ MELODY.new([C4, C4, E4, G4])
+    end
+
+    it "is true when all the pitches are equal, even in a different order" do
+      MELODY.new([C4, E4, G4]).should =~ MELODY.new([C4, G4, E4])
+    end
+
+    it "is false when one MELODY contains a Pitch not in the other" do
+      MELODY.new([C4, E4, G4]).should_not =~ MELODY.new([C4, E4])
+    end
+
+    it "can be compared directly to Arrays" do
+      MELODY.new([C4, E4, G4]).should =~ [C4, E4, G4]
+    end
+  end
+
+  describe "#to_s" do
+    it "looks like an array of pitches" do
+      melody.to_s.should == "[C4, D4, E4, D4]"
+    end
+  end
+
+end
+
+describe MTK do
+
+  describe '#Melody' do
+
+    it "acts like new for a single Array argument" do
+      Melody([C4,D4]).should == MTK::Groups::Melody.new([C4,D4])
+    end
+
+    it "acts like new for multiple arguments, by treating them like an Array (splat)" do
+      Melody(C4,D4).should == MTK::Groups::Melody.new([C4,D4])
+    end
+
+    it "handles an Array with elements that can be converted to Pitches" do
+      Melody(['C4','D4']).should == MTK::Groups::Melody.new([C4,D4])
+    end
+
+    it "handles multiple arguments that can be converted to a Pitch" do
+      Melody(:C4,:D4).should == MTK::Groups::Melody.new([C4,D4])
+    end
+
+    it "handles a single Pitch" do
+      Melody(C4).should == MTK::Groups::Melody.new([C4])
+    end
+
+    it "handles single elements that can be converted to a Pitch" do
+      Melody('C4').should == MTK::Groups::Melody.new([C4])
+    end
+
+    it "handles a Melody" do
+      melody = MTK::Groups::Melody.new([C4,D4])
+      Melody(melody).should == [C4,D4]
+    end
+
+    it "raises an error for types it doesn't understand" do
+      lambda{ Melody({:not => :compatible}) }.should raise_error
+    end
+
+  end
+
+end