mtk 0.0.2 → 0.0.3

data/spec/mtk/{helper → helpers}/collection_spec.rb

@@ -1,16 +1,16 @@
 require 'spec_helper'
 
-describe MTK::Helper::Collection do
+describe MTK::Helpers::Collection do
 
   class MockCollection
-    include MTK::Helper::Collection
+    include MTK::Helpers::Collection
     attr_reader :elements
     def initialize(elements); @elements = elements end
     def self.from_a(elements); new(elements) end
   end
 
   class MockCollectionWithOptions
-    include MTK::Helper::Collection
+    include MTK::Helpers::Collection
     attr_reader :elements, :options
     def initialize(elements, options={})
       @elements = elements
@@ -73,6 +73,16 @@ describe MTK::Helper::Collection do
     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]
@@ -252,6 +262,69 @@ describe MTK::Helper::Collection do
     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)
@@ -288,4 +361,14 @@ describe MTK::Helper::Collection do
     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/{helper → helpers}/pseudo_constants_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe MTK::Helper::PseudoConstants do
+describe MTK::Helpers::PseudoConstants do
 
   module MockConstants
-    extend MTK::Helper::PseudoConstants
+    extend MTK::Helpers::PseudoConstants
     define_constant 'constant', :value
   end
 

data/spec/mtk/intensity_spec.rb

@@ -0,0 +1,289 @@
+require 'spec_helper'
+
+describe MTK::Intensity do
+
+  let(:half_intensity)  { Intensity[0.5] }
+
+
+  describe 'NAMES' do
+    it "is the list of base intensity names available" do
+      Intensity::NAMES.should =~ %w( ppp pp p mp mf o ff fff )
+    end
+
+    it "is immutable" do
+      lambda{ Intensity::NAMES << 'z' }.should raise_error
+    end
+  end
+
+
+  describe 'VALUES_BY_NAME' do
+    it 'maps names to values' do
+      Intensity::VALUES_BY_NAME.each do |name,value|
+        Intensity.from_s(name).value.should == value
+      end
+    end
+
+    it 'is immutable' do
+      lambda{ Intensity::VALUES_BY_NAME << 'z' }.should raise_error
+    end
+  end
+
+
+  describe '.new' do
+    it "constructs a Intensity with whatever value is given" do
+      float = 0.5
+      value = Intensity.new(float).value
+      value.should be_equal float
+    end
+  end
+
+
+  describe '.[]' do
+    it "constructs and caches a intensity from a Numeric" do
+      Intensity[1].should be_equal Intensity[1]
+    end
+
+    it "retains the new() method's ability to construct uncached objects" do
+      Intensity.new(1).should_not be_equal Intensity[1]
+    end
+
+    it "converts the value to floating point" do
+      value = Intensity[Rational(1,2)].value
+      value.should be_a Float
+      value.should == 0.5
+    end
+
+  end
+
+
+  describe '.from_i' do
+    it "acts like .[]" do
+      Intensity.from_i(0).value.should == 0.0
+      Intensity.from_i(4).value.should == 4.0
+    end
+  end
+
+  describe '.from_f' do
+    it "acts like .[]" do
+      value = Intensity.from_f(Rational(1,2)).value
+      value.should be_a Float
+      value.should == 0.5
+    end
+  end
+
+  describe '.from_s' do
+    it "converts any of the intensity NAMES into a Intensity with the value from the VALUES_BY_NAME mapping" do
+      for name in Intensity::NAMES
+        Intensity.from_s(name).value.should == Intensity::VALUES_BY_NAME[name]
+      end
+    end
+
+    it "adds 1.0/24 when the name ends with '+', except for 'fff+' which is 1.0 like 'fff'" do
+      for name in Intensity::NAMES
+        if name == 'fff'
+          Intensity.from_s("#{name}+").should == Intensity[1.0]
+        else
+          Intensity.from_s("#{name}+").should == Intensity[ Intensity::VALUES_BY_NAME[name] +1.0/24 ]
+        end
+      end
+    end
+
+    it "subtracts 1.0/24 when the name ends with '-'" do
+      for name in Intensity::NAMES
+        Intensity.from_s("#{name}-").should == Intensity[ Intensity::VALUES_BY_NAME[name] - 1.0/24 ]
+      end
+    end
+  end
+
+  describe '.from_name' do
+    it "acts like .from_s" do
+      for name in Intensity::NAMES
+        Intensity.from_name(name).value.should == Intensity::VALUES_BY_NAME[name]
+      end
+    end
+  end
+
+
+  describe '#value' do
+    it "is the value used to construct the Intensity" do
+      Intensity.new(1.111).value.should == 1.111
+    end
+  end
+
+
+  describe '#to_f' do
+    it "is the value as a floating point number" do
+      f = Intensity.new(Rational(1,2)).to_f
+      f.should be_a Float
+      f.should == 0.5
+    end
+  end
+
+  describe '#to_i' do
+    it "is the value rounded to the nearest integer" do
+      i = Intensity.new(0.5).to_i
+      i.should be_a Fixnum
+      i.should == 1
+      Intensity.new(0.49).to_i.should == 0
+    end
+  end
+
+  describe '#to_percentage' do
+    it 'is the value*100 rounded to the nearest integer' do
+      Intensity.new(0).to_percent.should == 0
+      Intensity.new(0.5).to_percent.should == 50
+      Intensity.new(1).to_percent.should == 100
+      Intensity.new(2).to_percent.should == 200
+    end
+  end
+
+  describe '#to_s' do
+    it "is to_percentage suffixed with '% intensity'" do
+      Intensity.new(0).to_s.should == '0% intensity'
+      Intensity.new(0.5).to_s.should == '50% intensity'
+      Intensity.new(1).to_s.should == '100% intensity'
+      Intensity.new(2).to_s.should == '200% intensity'
+    end
+  end
+
+  describe '#inspect' do
+    it 'is "#<MTK::Intensity:{object_id} @value={value}>"' do
+      for value in [0, 60, 60.5, 127]
+        intensity = Intensity.new(value)
+        intensity.inspect.should == "#<MTK::Intensity:#{intensity.object_id} @value=#{value}>"
+      end
+    end
+  end
+
+  describe '#==' do
+    it "compares two intensity values for equality" do
+      Intensity.new(Rational(1,2)).should == Intensity.new(0.5)
+      Intensity.new(4).should == Intensity.new(4)
+      Intensity.new(1.1).should_not == Intensity.new(1)
+    end
+  end
+
+  describe "#<=>" do
+    it "orders intensitys based on their underlying value" do
+      ( Intensity.new(1) <=> Intensity.new(1.1) ).should < 0
+      ( Intensity.new(2) <=> Intensity.new(1) ).should > 0
+      ( Intensity.new(1.0) <=> Intensity.new(1) ).should == 0
+    end
+  end
+
+
+
+  describe '#+' do
+    it 'adds #value to the Numeric argument' do
+      (half_intensity + 0.25).should == Intensity[0.75]
+    end
+
+    it 'works with an Intensity argument' do
+      (half_intensity + Intensity[0.25]).should == Intensity[0.75]
+    end
+
+    it 'returns a new intensity (Intensity is immutable)' do
+      original = half_intensity
+      modified = half_intensity + 0.25
+      original.should_not == modified
+      original.should == Intensity[0.5]
+    end
+  end
+
+  describe '#-' do
+    it 'subtract the Numeric argument from #value' do
+      (half_intensity - 0.25).should == Intensity[0.25]
+    end
+
+    it 'works with a Intensity argument' do
+      (half_intensity - Intensity[0.25]).should == Intensity[0.25]
+    end
+
+    it 'returns a new intensity (Intensity is immutable)' do
+      original = half_intensity
+      modified = half_intensity - 0.25
+      original.should_not == modified
+      original.should == Intensity[0.5]
+    end
+  end
+
+
+  describe '#*' do
+    it 'multiplies #value to the Numeric argument' do
+      (half_intensity * 0.1).should == Intensity[0.05]
+    end
+
+    it 'works with a Intensity argument' do
+      (half_intensity * Intensity[0.1]).should == Intensity[0.05]
+    end
+
+    it 'returns a new intensity (Intensity is immutable)' do
+      original = half_intensity
+      modified = half_intensity * 2
+      original.should_not == modified
+      original.should == Intensity[0.5]
+    end
+  end
+
+  describe '#/' do
+    it 'divides #value by the Numeric argument' do
+      (half_intensity / 2).should == Intensity[0.25]
+    end
+
+    it 'works with a Intensity argument' do
+      (half_intensity / Intensity[0.5]).should == Intensity[1]
+    end
+
+    it 'returns a new intensity (Intensity is immutable)' do
+      original = half_intensity
+      modified = half_intensity / 2
+      original.should_not == modified
+      original.should == Intensity[0.5]
+    end
+  end
+
+  describe '#coerce' do
+    it 'allows a Intensity to be added to a Numeric' do
+      (0.25 + half_intensity).should == Intensity[0.75]
+    end
+
+    it 'allows a Intensity to be subtracted from a Numeric' do
+      (0.9 - half_intensity).should == Intensity[0.4]
+    end
+
+    it 'allows a Intensity to be multiplied to a Numeric' do
+      (0.5 * half_intensity).should == Intensity[0.25]
+    end
+
+    it 'allows a Numeric to be divided by a Intensity' do
+      (0.1 / half_intensity).should == Intensity[0.2]
+    end
+  end
+
+end
+
+describe MTK do
+
+  describe '#Intensity' do
+    it "acts like .from_s if the argument is a String" do
+      Intensity('ppp').should == Intensity.from_s('ppp')
+    end
+
+    it "acts like .from_s if the argument is a Symbol" do
+      Intensity(:ppp).should == Intensity.from_s('ppp')
+    end
+
+    it "acts like .[] if the argument is a Numeric" do
+      Intensity(0.5).should be_equal Intensity[0.5]
+    end
+
+    it "returns the argument if it's already a Intensity" do
+      Intensity(Intensity[1]).should be_equal Intensity[1]
+    end
+
+    it "raises an error for types it doesn't understand" do
+      lambda{ Intensity({:not => :compatible}) }.should raise_error
+    end
+  end
+
+end

data/spec/mtk/interval_spec.rb

@@ -0,0 +1,265 @@
+require 'spec_helper'
+
+describe MTK::Interval do
+
+  let(:minor_second)  { Interval[1] }
+
+
+  describe 'NAMES' do
+    it "is the list of base interval names available" do
+      Interval::NAMES.should =~ %w( P1 m2 M2 m3 M3 P4 TT P5 m6 M6 m7 M7 P8 )
+    end
+
+    it "is immutable" do
+      lambda{ Interval::NAMES << 'z' }.should raise_error
+    end
+  end
+
+
+  describe 'VALUES_BY_NAME' do
+    it 'maps names to values' do
+      Interval::VALUES_BY_NAME.each do |name,value|
+        Interval.from_s(name).value.should == value
+      end
+    end
+
+    it 'is immutable' do
+      lambda{ Interval::VALUES_BY_NAME << 'z' }.should raise_error
+    end
+  end
+
+
+  describe 'ALL_NAMES' do
+    it 'contains all NAMES' do
+      Interval::NAMES.each{|name| Interval::ALL_NAMES.should include name }
+    end
+  end
+
+
+  describe '.new' do
+    it "constructs a Interval with whatever value is given" do
+      float = 0.5
+      value = Interval.new(float).value
+      value.should be_equal float
+    end
+  end
+
+
+  describe '.[]' do
+    it "constructs and caches a interval from a Numeric" do
+      Interval[1].should be_equal Interval[1]
+    end
+
+    it "retains the new() method's ability to construct uncached objects" do
+      Interval.new(1).should_not be_equal Interval[1]
+    end
+
+    it "converts the value to floating point" do
+      value = Interval[Rational(1,2)].value
+      value.should be_a Float
+      value.should == 0.5
+    end
+
+  end
+
+
+  describe '.from_i' do
+    it "acts like .[]" do
+      Interval.from_i(0).value.should == 0.0
+      Interval.from_i(4).value.should == 4.0
+    end
+  end
+
+  describe '.from_f' do
+    it "acts like .[]" do
+      value = Interval.from_f(Rational(1,2)).value
+      value.should be_a Float
+      value.should == 0.5
+    end
+  end
+
+  describe '.from_s' do
+    it "converts any of the interval NAMES into a Interval with the value from the VALUES_BY_NAME mapping" do
+      for name in Interval::ALL_NAMES
+        Interval.from_s(name).value.should == Interval::VALUES_BY_NAME[name]
+      end
+    end
+  end
+
+  describe '.from_name' do
+    it "acts like .from_s" do
+      for name in Interval::NAMES
+        Interval.from_name(name).value.should == Interval::VALUES_BY_NAME[name]
+      end
+    end
+  end
+
+
+  describe '#value' do
+    it "is the value used to construct the Interval" do
+      Interval.new(1.111).value.should == 1.111
+    end
+  end
+
+
+  describe '#to_f' do
+    it "is the value as a floating point number" do
+      f = Interval.new(Rational(1,2)).to_f
+      f.should be_a Float
+      f.should == 0.5
+    end
+  end
+
+  describe '#to_i' do
+    it "is the value rounded to the nearest integer" do
+      i = Interval.new(0.5).to_i
+      i.should be_a Fixnum
+      i.should == 1
+      Interval.new(0.49).to_i.should == 0
+    end
+  end
+
+  describe '#to_s' do
+    it "should be value.to_s" do
+      for value in [1, Rational(1,2), 0.25]
+        Interval.new(value).to_s.should == value.to_s
+      end
+    end
+  end
+
+  describe '#==' do
+    it "compares two interval values for equality" do
+      Interval.new(Rational(1,2)).should == Interval.new(0.5)
+      Interval.new(4).should == Interval.new(4)
+      Interval.new(1.1).should_not == Interval.new(1)
+    end
+  end
+
+  describe "#<=>" do
+    it "orders intervals based on their underlying value" do
+      ( Interval.new(1) <=> Interval.new(1.1) ).should < 0
+      ( Interval.new(2) <=> Interval.new(1) ).should > 0
+      ( Interval.new(1.0) <=> Interval.new(1) ).should == 0
+    end
+  end
+
+
+
+  describe '#+' do
+    it 'adds #value to the Numeric argument' do
+      (minor_second + 0.25).should == Interval[1.25]
+    end
+
+    it 'works with an Interval argument' do
+      (minor_second + Interval[0.25]).should == Interval[1.25]
+    end
+
+    it 'returns a new interval (Interval is immutable)' do
+      original = minor_second
+      modified = minor_second + 0.25
+      original.should_not == modified
+      original.should == Interval[1]
+    end
+  end
+
+  describe '#-' do
+    it 'subtract the Numeric argument from #value' do
+      (minor_second - 0.25).should == Interval[0.75]
+    end
+
+    it 'works with a Interval argument' do
+      (minor_second - Interval[0.25]).should == Interval[0.75]
+    end
+
+    it 'returns a new interval (Interval is immutable)' do
+      original = minor_second
+      modified = minor_second - 0.25
+      original.should_not == modified
+      original.should == Interval[1]
+    end
+  end
+
+
+  describe '#*' do
+    it 'multiplies #value to the Numeric argument' do
+      (minor_second * 3).should == Interval[3]
+    end
+
+    it 'works with a Interval argument' do
+      (minor_second * Interval[3]).should == Interval[3]
+    end
+
+    it 'returns a new interval (Interval is immutable)' do
+      original = minor_second
+      modified = minor_second * 2
+      original.should_not == modified
+      original.should == Interval[1]
+    end
+  end
+
+  describe '#/' do
+    it 'divides #value by the Numeric argument' do
+      (minor_second / 2).should == Interval[0.5]
+    end
+
+    it 'works with a Interval argument' do
+      (minor_second / Interval[2]).should == Interval[0.5]
+    end
+
+    it 'returns a new interval (Interval is immutable)' do
+      original = minor_second
+      modified = minor_second / 2
+      original.should_not == modified
+      original.should == Interval[1]
+    end
+  end
+
+  describe '#coerce' do
+    it 'allows a Interval to be added to a Numeric' do
+      (0.25 + minor_second).should == Interval[1.25]
+    end
+
+    it 'allows a Interval to be subtracted from a Numeric' do
+      (3 - minor_second).should == Interval[2]
+    end
+
+    it 'allows a Interval to be multiplied to a Numeric' do
+      (3 * minor_second).should == Interval[3]
+    end
+
+    it 'allows a Numeric to be divided by a Interval' do
+      (4 / minor_second).should == Interval[4]
+    end
+  end
+
+end
+
+describe MTK do
+
+  describe '#Interval' do
+    it "acts like .from_s if the argument is a String" do
+      for name in Interval::ALL_NAMES
+        Interval(name).should == Interval.from_s(name)
+      end
+    end
+
+    it "acts like .from_s if the argument is a Symbol" do
+      for name in Interval::ALL_NAMES
+        Interval(name.to_sym).should == Interval.from_s(name)
+      end
+    end
+
+    it "acts like .[] if the argument is a Numeric" do
+      Interval(0.5).should be_equal Interval[0.5]
+    end
+
+    it "returns the argument if it's already a Interval" do
+      Interval(Interval[1]).should be_equal Interval[1]
+    end
+
+    it "raises an error for types it doesn't understand" do
+      lambda{ Interval({:not => :compatible}) }.should raise_error
+    end
+  end
+
+end