motion-support 0.1.0 → 0.2.0

data/spec/motion-support/core_ext/enumerable_spec.rb

@@ -0,0 +1,130 @@
+describe "enumerable" do
+  describe "collect_with_index" do
+    describe "on Array" do
+      it "should return an empty array on an empty array" do
+        [].collect_with_index { |x, i| x }.should == []
+      end
+    
+      it "should yield an index for each element" do
+        [1, 2, 3].collect_with_index { |x, i| [i, x] }.should == [[0, 1], [1, 2], [2, 3]]
+      end
+      
+      it "should apply the block to each element" do
+        [1, 2, 3].collect_with_index { |x, i| x * i }.should == [0, 2, 6]
+      end
+    end
+    
+    describe "on Hash" do
+      it "should return an empty array on an empty hash" do
+        {}.collect_with_index { |x, i| x }.should == []
+      end
+      
+      it "should apply the block to each element" do
+        result = {:foo => 1, :bar => 2, :baz => 3}.collect_with_index { |p, i| [p.first, p.last, i] }
+        result.should == [[:foo, 1, 0], [:bar, 2, 1], [:baz, 3, 2]]
+      end
+    end
+  end
+  
+  describe "sum" do
+    it "should return the sum of an integer array" do
+      [5, 15, 10].sum.should == 30
+    end
+    
+    it "should concatenate strings in a string array" do
+      ['foo', 'bar'].sum.should == "foobar"
+    end
+    
+    it "should concatenate arrays" do
+      [[1, 2], [3, 1, 5]].sum.should == [1, 2, 3, 1, 5]
+    end
+    
+    it "should yield a block to each element before summing if given" do
+      [1, 2, 3].sum { |p| p * 2 }.should == 12
+    end
+    
+    it "should allow a custom result for an empty list" do
+      [].sum("empty") { |i| i.amount }.should == "empty"
+    end
+  end
+  
+  describe "index_by" do
+    class Person < Struct.new(:first_name, :last_name)
+    end
+    
+    before do
+      @peter = Person.new('Peter', 'Griffin')
+      @homer = Person.new('Homer', 'Simpson')
+    end
+    
+    it "should create hash with keys given by block result" do
+      [@peter, @homer].index_by { |x| x.first_name }.should == { 'Peter' => @peter, 'Homer' => @homer }
+    end
+    
+    it "should create enumerator if no block is given" do
+      [@peter, @homer].index_by.should.is_a Enumerator
+    end
+  end
+  
+  describe "many?" do
+    it "should return false for an empty enumerable" do
+      [].many?.should == false
+      {}.many?.should == false
+    end
+    
+    it "should return false for an enumerable with only one element" do
+      [1].many?.should == false
+      {:foo => :bar}.many?.should == false
+    end
+    
+    it "should return true for an enumerable with more than one element" do
+      [1, 2].many?.should == true
+      [1, 2, 3].many?.should == true
+      {:foo => :bar, :baz => :bingo}.many?.should == true
+      {:a => :b, :c => :d, :e => :f}.many?.should == true
+    end
+    
+    it "should return false if there are less than two elements satisfying the block if given" do
+      [1].many? { |x| x * 10 > 100 }.should == false
+      [1, 2, 3, 4, 5].many? { |x| x >= 5 }.should == false
+    end
+    
+    it "should return true if there is more than one element satisfying the block if given" do
+      [1, 2, 3, 4, 5].many? { |x| x < 4 }.should == true
+    end
+  end
+  
+  describe "exclude?" do
+    it "should return true if the element is not in the array" do
+      [1, 2, 3].exclude?(4).should == true
+    end
+    
+    it "should return false if the element is in the array" do
+      [1, 2, 3].exclude?(2).should == false
+    end
+    
+    it "should always return true for an empty array" do
+      [].exclude?(rand).should == true
+    end
+  end
+end
+
+describe "Range" do
+  describe "sum" do
+    it "should return the sum of integers in an inclusive range" do
+      (3..5).sum.should == 12
+    end
+    
+    it "should return the sum of integers in an exclusive range" do
+      (3...5).sum.should == 7
+    end
+    
+    it "should return zero for an empty range" do
+      (1...1).sum.should == 0
+    end
+    
+    it "should return custom identity for an empty range if given" do
+      (1...1).sum("empty").should == "empty"
+    end
+  end
+end

data/spec/motion-support/core_ext/hash/deep_merge_spec.rb

@@ -0,0 +1,32 @@
+describe "hash" do
+  before do
+    @hash_1 = { :a => "a", :b => "b", :c => { :c1 => "c1", :c2 => "c2", :c3 => { :d1 => "d1" } } }
+    @hash_2 = { :a => 1, :c => { :c1 => 2, :c3 => { :d2 => "d2" } } }
+  end
+  
+  describe "deep_merge" do
+    it "should deep merge" do
+      expected = { :a => 1, :b => "b", :c => { :c1 => 2, :c2 => "c2", :c3 => { :d1 => "d1", :d2 => "d2" } } }
+      @hash_1.deep_merge(@hash_2).should == expected
+    end
+    
+    it "should deep merge with block" do
+      expected = { :a => [:a, "a", 1], :b => "b", :c => { :c1 => [:c1, "c1", 2], :c2 => "c2", :c3 => { :d1 => "d1", :d2 => "d2" } } }
+      (@hash_1.deep_merge(@hash_2) { |k,o,n| [k, o, n] }).should == expected
+    end
+  end
+  
+  describe "deep_merge!" do
+    it "should deep merge" do
+      expected = { :a => 1, :b => "b", :c => { :c1 => 2, :c2 => "c2", :c3 => { :d1 => "d1", :d2 => "d2" } } }
+      @hash_1.deep_merge!(@hash_2)
+      @hash_1.should == expected
+    end
+    
+    it "should deep merge with block" do
+      expected = { :a => [:a, "a", 1], :b => "b", :c => { :c1 => [:c1, "c1", 2], :c2 => "c2", :c3 => { :d1 => "d1", :d2 => "d2" } } }
+      @hash_1.deep_merge!(@hash_2) { |k,o,n| [k, o, n] }
+      @hash_1.should == expected
+    end
+  end
+end

data/spec/motion-support/core_ext/hash/except_spec.rb

@@ -0,0 +1,43 @@
+describe "hash" do
+  describe "except" do
+    it "should remove key" do
+      original = { :a => 'x', :b => 'y', :c => 10 }
+      expected = { :a => 'x', :b => 'y' }
+
+      original.except(:c).should == expected
+      original.should.not == expected
+    end
+    
+    it "should remove more than one key" do
+      original = { :a => 'x', :b => 'y', :c => 10 }
+      expected = { :a => 'x' }
+      original.except(:b, :c).should == expected
+    end
+    
+    it "should work on frozen hash" do
+      original = { :a => 'x', :b => 'y' }
+      original.freeze
+      lambda { original.except(:a) }.should.not.raise
+    end
+  end
+  
+  describe "except!" do
+    it "should remove key in place" do
+      original = { :a => 'x', :b => 'y', :c => 10 }
+      expected = { :a => 'x', :b => 'y' }
+
+      original.should.not == expected
+      original.except!(:c).should == expected
+      original.should == expected
+    end
+    
+    it "should remove more than one key in place" do
+      original = { :a => 'x', :b => 'y', :c => 10 }
+      expected = { :a => 'x' }
+
+      original.should.not == expected
+      original.except!(:b, :c).should == expected
+      original.should == expected
+    end
+  end
+end

data/spec/motion-support/core_ext/hash/key_spec.rb

@@ -0,0 +1,230 @@
+describe "Hash" do
+  describe "keys" do
+    before do
+      @strings = { 'a' => 1, 'b' => 2 }
+      @nested_strings = { 'a' => { 'b' => { 'c' => 3 } } }
+      @symbols = { :a  => 1, :b  => 2 }
+      @nested_symbols = { :a => { :b => { :c => 3 } } }
+      @mixed   = { :a  => 1, 'b' => 2 }
+      @nested_mixed   = { 'a' => { :b => { 'c' => 3 } } }
+      @fixnums = {  0  => 1,  1  => 2 }
+      @nested_fixnums = {  0  => { 1  => { 2 => 3} } }
+      @illegal_symbols = { [] => 3 }
+      @nested_illegal_symbols = { [] => { [] => 3} }
+      @upcase_strings = { 'A' => 1, 'B' => 2 }
+      @nested_upcase_strings = { 'A' => { 'B' => { 'C' => 3 } } }
+    end
+    
+    it "should have all key methods defined on literal hash" do
+      h = {}
+      h.should.respond_to :transform_keys
+      h.should.respond_to :transform_keys!
+      h.should.respond_to :deep_transform_keys
+      h.should.respond_to :deep_transform_keys!
+      h.should.respond_to :symbolize_keys
+      h.should.respond_to :symbolize_keys!
+      h.should.respond_to :deep_symbolize_keys
+      h.should.respond_to :deep_symbolize_keys!
+      h.should.respond_to :stringify_keys
+      h.should.respond_to :stringify_keys!
+      h.should.respond_to :deep_stringify_keys
+      h.should.respond_to :deep_stringify_keys!
+      h.should.respond_to :to_options
+      h.should.respond_to :to_options!
+    end
+    
+    describe "transform_keys" do
+      it "should transform keys" do
+        @strings.transform_keys{ |key| key.to_s.upcase }.should == @upcase_strings
+        @symbols.transform_keys{ |key| key.to_s.upcase }.should == @upcase_strings
+        @mixed.transform_keys{ |key| key.to_s.upcase }.should == @upcase_strings
+      end
+      
+      it "should not mutate" do
+        transformed_hash = @mixed.dup
+        transformed_hash.transform_keys{ |key| key.to_s.upcase }
+        transformed_hash.should == @mixed
+      end
+    end
+    
+    describe "deep_transform_keys" do
+      it "should deep transform keys" do
+        @nested_symbols.deep_transform_keys{ |key| key.to_s.upcase }.should == @nested_upcase_strings
+        @nested_strings.deep_transform_keys{ |key| key.to_s.upcase }.should == @nested_upcase_strings
+        @nested_mixed.deep_transform_keys{ |key| key.to_s.upcase }.should == @nested_upcase_strings
+      end
+      
+      it "should not mutate" do
+        transformed_hash = @nested_mixed.deep_dup
+        transformed_hash.deep_transform_keys{ |key| key.to_s.upcase }
+        transformed_hash.should == @nested_mixed
+      end
+    end
+    
+    describe "transform_keys!" do
+      it "should transform keys" do
+        @symbols.dup.transform_keys!{ |key| key.to_s.upcase }.should == @upcase_strings
+        @strings.dup.transform_keys!{ |key| key.to_s.upcase }.should == @upcase_strings
+        @mixed.dup.transform_keys!{ |key| key.to_s.upcase }.should == @upcase_strings
+      end
+      
+      it "should mutate" do
+        transformed_hash = @mixed.dup
+        transformed_hash.transform_keys!{ |key| key.to_s.upcase }
+        transformed_hash.should == @upcase_strings
+        { :a => 1, "b" => 2 }.should == @mixed
+      end
+    end
+    
+    describe "deep_transform_keys!" do
+      it "should deep transform keys" do
+        @nested_symbols.deep_dup.deep_transform_keys!{ |key| key.to_s.upcase }.should == @nested_upcase_strings
+        @nested_strings.deep_dup.deep_transform_keys!{ |key| key.to_s.upcase }.should == @nested_upcase_strings
+        @nested_mixed.deep_dup.deep_transform_keys!{ |key| key.to_s.upcase }.should == @nested_upcase_strings
+      end
+      
+      it "should mutate" do
+        transformed_hash = @nested_mixed.deep_dup
+        transformed_hash.deep_transform_keys!{ |key| key.to_s.upcase }
+        transformed_hash.should == @nested_upcase_strings
+        { 'a' => { :b => { 'c' => 3 } } }.should == @nested_mixed
+      end
+    end
+    
+    describe "symbolize_keys" do
+      it "should symbolize keys" do
+        @symbols.symbolize_keys.should == @symbols
+        @strings.symbolize_keys.should == @symbols
+        @mixed.symbolize_keys.should == @symbols
+      end
+      
+      it "should not mutate" do
+        transformed_hash = @mixed.dup
+        transformed_hash.symbolize_keys
+        transformed_hash.should == @mixed
+      end
+      
+      it "should preserve keys that can't be symbolized" do
+        @illegal_symbols.symbolize_keys.should == @illegal_symbols
+        @illegal_symbols.dup.symbolize_keys!.should == @illegal_symbols
+      end
+      
+      it "should preserve fixnum keys" do
+        @fixnums.symbolize_keys.should == @fixnums
+        @fixnums.dup.symbolize_keys!.should == @fixnums
+      end
+    end
+    
+    describe "deep_symbolize_keys" do
+      it "should deep symbolize keys" do
+        @nested_symbols.deep_symbolize_keys.should == @nested_symbols
+        @nested_strings.deep_symbolize_keys.should == @nested_symbols
+        @nested_mixed.deep_symbolize_keys.should == @nested_symbols
+      end
+      
+      it "should not mutate" do
+        transformed_hash = @nested_mixed.deep_dup
+        transformed_hash.deep_symbolize_keys
+        transformed_hash.should == @nested_mixed
+      end
+      
+      it "should preserve keys that can't be symbolized" do
+        @nested_illegal_symbols.deep_symbolize_keys.should == @nested_illegal_symbols
+        @nested_illegal_symbols.deep_dup.deep_symbolize_keys!.should == @nested_illegal_symbols
+      end
+      
+      it "should preserve fixnum keys" do
+        @nested_fixnums.deep_symbolize_keys.should == @nested_fixnums
+        @nested_fixnums.deep_dup.deep_symbolize_keys!.should == @nested_fixnums
+      end
+    end
+    
+    describe "symbolize_keys!" do
+      it "should symbolize keys" do
+        @symbols.dup.symbolize_keys!.should == @symbols
+        @strings.dup.symbolize_keys!.should == @symbols
+        @mixed.dup.symbolize_keys!.should == @symbols
+      end
+      
+      it "should mutate" do
+        transformed_hash = @mixed.dup
+        transformed_hash.deep_symbolize_keys!
+        transformed_hash.should == @symbols
+        { :a => 1, "b" => 2 }.should == @mixed
+      end
+    end
+    
+    describe "deep_symbolize_keys!" do
+      it "should deep symbolize keys" do
+        @nested_symbols.deep_dup.deep_symbolize_keys!.should == @nested_symbols
+        @nested_strings.deep_dup.deep_symbolize_keys!.should == @nested_symbols
+        @nested_mixed.deep_dup.deep_symbolize_keys!.should == @nested_symbols
+      end
+      
+      it "should mutate" do
+        transformed_hash = @nested_mixed.deep_dup
+        transformed_hash.deep_symbolize_keys!
+        transformed_hash.should == @nested_symbols
+        { 'a' => { :b => { 'c' => 3 } } }.should == @nested_mixed
+      end
+    end
+
+    describe "stringify_keys" do
+      it "should stringify keys" do
+        @symbols.stringify_keys.should == @strings
+        @strings.stringify_keys.should == @strings
+        @mixed.stringify_keys.should == @strings
+      end
+      
+      it "should not mutate" do
+        transformed_hash = @mixed.dup
+        transformed_hash.stringify_keys
+        transformed_hash.should == @mixed
+      end
+    end
+    
+    describe "deep stringify_keys" do
+      it "should deep stringify keys" do
+        @nested_symbols.deep_stringify_keys.should == @nested_strings
+        @nested_strings.deep_stringify_keys.should == @nested_strings
+        @nested_mixed.deep_stringify_keys.should == @nested_strings
+      end
+      
+      it "should not mutate" do
+        transformed_hash = @nested_mixed.deep_dup
+        transformed_hash.deep_stringify_keys
+        transformed_hash.should == @nested_mixed
+      end
+    end
+    
+    describe "stringify_keys!" do
+      it "should stringify keys" do
+        @symbols.dup.stringify_keys!.should == @strings
+        @strings.dup.stringify_keys!.should == @strings
+        @mixed.dup.stringify_keys!.should == @strings
+      end
+      
+      it "should mutate" do
+        transformed_hash = @mixed.dup
+        transformed_hash.stringify_keys!
+        transformed_hash.should == @strings
+        { :a => 1, "b" => 2 }.should == @mixed
+      end
+    end
+    
+    describe "deep_stringify_keys!" do
+      it "should deep stringify keys" do
+        @nested_symbols.deep_dup.deep_stringify_keys!.should == @nested_strings
+        @nested_strings.deep_dup.deep_stringify_keys!.should == @nested_strings
+        @nested_mixed.deep_dup.deep_stringify_keys!.should == @nested_strings
+      end
+      
+      it "should mutate" do
+        transformed_hash = @nested_mixed.deep_dup
+        transformed_hash.deep_stringify_keys!
+        transformed_hash.should == @nested_strings
+        { 'a' => { :b => { 'c' => 3 } } }.should == @nested_mixed
+      end
+    end
+  end
+end

data/spec/motion-support/core_ext/hash/reverse_merge_spec.rb

@@ -0,0 +1,26 @@
+describe "hash" do
+  describe "reverse_merge" do
+    before do
+      @defaults = { :a => "x", :b => "y", :c => 10 }.freeze
+      @options  = { :a => 1, :b => 2 }
+      @expected = { :a => 1, :b => 2, :c => 10 }
+    end
+
+    it "should merge defaults into options, creating a new hash" do
+      @options.reverse_merge(@defaults).should == @expected
+      @options.should.not == @expected
+    end
+
+    it "should merge! defaults into options, replacing options" do
+      merged = @options.dup
+      merged.reverse_merge!(@defaults).should == @expected
+      merged.should == @expected
+    end
+
+    it "should be an alias for reverse_merge!" do
+      merged = @options.dup
+      merged.reverse_update(@defaults).should == @expected
+      merged.should == @expected
+    end
+  end
+end

data/spec/motion-support/core_ext/hash/slice_spec.rb

@@ -0,0 +1,61 @@
+describe "hash" do
+  describe "slice" do
+    it "should return a new hash with only the given keys" do
+      original = { :a => 'x', :b => 'y', :c => 10 }
+      expected = { :a => 'x', :b => 'y' }
+
+      original.slice(:a, :b).should == expected
+      original.should.not == expected
+    end
+    
+    it "should replace the hash with only the given keys" do
+      original = { :a => 'x', :b => 'y', :c => 10 }
+      expected = { :c => 10 }
+
+      original.slice!(:a, :b).should == expected
+    end
+    
+    it "should return a new hash with only the given keys when given an array key" do
+      original = { :a => 'x', :b => 'y', :c => 10, [:a, :b] => "an array key" }
+      expected = { [:a, :b] => "an array key", :c => 10 }
+
+      original.slice([:a, :b], :c).should == expected
+      original.should.not == expected
+    end
+
+    it "should replace the hash with only the given keys when given an array key" do
+      original = { :a => 'x', :b => 'y', :c => 10, [:a, :b] => "an array key" }
+      expected = { :a => 'x', :b => 'y' }
+
+      original.slice!([:a, :b], :c).should == expected
+    end
+
+    it "should grab each of the splatted keys" do
+      original = { :a => 'x', :b => 'y', :c => 10, [:a, :b] => "an array key" }
+      expected = { :a => 'x', :b => "y" }
+
+      original.slice(*[:a, :b]).should == expected
+    end
+  end
+  
+  describe "extract!" do
+    it "should extract subhash" do
+      original = {:a => 1, :b => 2, :c => 3, :d => 4}
+      expected = {:a => 1, :b => 2}
+      remaining = {:c => 3, :d => 4}
+
+      original.extract!(:a, :b, :x).should == expected
+      original.should == remaining
+    end
+
+    it "should extract nils" do
+      original = {:a => nil, :b => nil}
+      expected = {:a => nil}
+      extracted = original.extract!(:a, :x)
+
+      extracted.should == expected
+      extracted[:a].should == nil
+      extracted[:x].should == nil
+    end
+  end
+end

data/spec/motion-support/core_ext/integer/inflection_spec.rb

@@ -0,0 +1,23 @@
+# These tests are mostly just to ensure that the ordinalize method exists.
+# Its results are tested comprehensively in the inflector test cases.
+describe "Integer" do
+  describe "ordinalize" do
+    it "should ordinalize 1" do
+      1.ordinalize.should == '1st'
+    end
+    
+    it "should ordinalize 8" do
+      8.ordinalize.should == '8th'
+    end
+  end
+
+  describe "ordinal" do
+    it "should get ordinal of 1" do
+      1.ordinal.should == 'st'
+    end
+    
+    it "should get ordinal of 8" do
+      8.ordinal.should == 'th'
+    end
+  end
+end

data/spec/motion-support/core_ext/integer/multiple_spec.rb

@@ -0,0 +1,19 @@
+PRIME = 22953686867719691230002707821868552601124472329079
+
+describe "Integer" do
+  describe "multiple_of" do
+    it "should determine if an integer is a multiple of another" do
+      [ -7, 0, 7, 14 ].each { |i| i.should.be.multiple_of 7 }
+      [ -7, 7, 14 ].each { |i| i.should.not.be.multiple_of 6 }
+    end
+    
+    it "should work with edge cases" do
+      0.should.be.multiple_of 0
+      5.should.not.be.multiple_of 0
+    end
+
+    it "should work with a prime" do
+      [2, 3, 5, 7].each { |i| PRIME.should.not.be.multiple_of i }
+    end
+  end
+end