motion_blender-support 0.2.7

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,236 @@
+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 } } }
+      @nested_array_symbols = { :a => [ { :a => 1 }, { :b => 2 } ] }
+      @nested_array_strings = { 'a' => [ { 'a' => 1 }, { 'b' => 2 } ] }
+    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
+        @nested_array_strings.deep_symbolize_keys.should == @nested_array_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
+        @nested_array_strings.deep_symbolize_keys!.should == @nested_array_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
+        @nested_array_symbols.deep_stringify_keys.should == @nested_array_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
+        @nested_array_symbols.deep_stringify_keys!.should == @nested_array_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

data/spec/motion-support/core_ext/kernel/singleton_class_spec.rb

@@ -0,0 +1,9 @@
+describe "Kernel" do
+  describe "class_eval" do
+    it "should delegate to singleton class" do
+      o = Object.new
+      class << o; @x = 1; end
+      o.class_eval { @x }.should == 1
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+describe "metaclass" do
+  it "should return the metaclass for a class" do
+    String.metaclass.is_a?(Class).should == true
+  end
+  
+  it "should return the metaclass for an object" do
+    "string".metaclass.is_a?(Class).should == true
+  end
+end

data/spec/motion-support/core_ext/module/aliasing_spec.rb

@@ -0,0 +1,143 @@
+module Aliasing
+  class File
+  public
+    def open(file)
+    end
+    def open_with_internet(url)
+      open_without_internet(url)
+    end
+    alias_method_chain :open, :internet
+  
+  protected
+    def exist?(file)
+    end
+    def exist_with_internet?(url)
+      exist_without_internet?(url)
+    end
+    alias_method_chain :exist?, :internet
+  
+  private
+    def remove!(file)
+    end
+    def remove_with_internet!(url)
+      remove_without_internet!(url)
+    end
+    alias_method_chain :remove!, :internet
+  end
+  
+  class Content
+    attr_accessor :title, :Data
+
+    def initialize
+      @title, @Data = nil, nil
+    end
+
+    def title?
+      !title.nil?
+    end
+
+    def Data?
+      !self.Data.nil?
+    end
+  end
+
+  class Email < Content
+    alias_attribute :subject, :title
+    alias_attribute :body, :Data
+  end
+end
+
+describe "module" do
+  describe "alias_method_chain" do
+    it "should define 'without' method" do
+      Aliasing::File.new.should.respond_to :open_without_internet
+    end
+    
+    it "should respond to original method" do
+      Aliasing::File.new.should.respond_to :open
+    end
+    
+    it "should respond to 'with' method" do
+      Aliasing::File.new.should.respond_to :open_with_internet
+    end
+    
+    it "should preserve question punctuation" do
+      Aliasing::File.new.should.respond_to :exist_without_internet?
+    end
+    
+    it "should preserve bang punctuation" do
+      # Ruby objects don't respond to private methods
+      Aliasing::File.new.should.not.respond_to :remove_without_internet!
+    end
+    
+    it "should keep public methods public" do
+      Aliasing::File.new.public_methods.should.include :"open_without_internet:"
+    end
+    
+    it "should keep protected methods protected" do
+      Aliasing::File.new.protected_methods.should.include :"exist_without_internet?:"
+    end
+    
+    it "should keep private methods private" do
+      Aliasing::File.new.private_methods.should.include :"remove_without_internet!:"
+    end
+  end
+  
+  describe "alias_attribute" do
+    before do
+      @email = Aliasing::Email.new
+    end
+    
+    describe "getter" do
+      it "should exist" do
+        lambda { @email.subject }.should.not.raise
+      end
+      
+      it "should read" do
+        @email.title = "hello"
+        @email.subject.should == "hello"
+      end
+      
+      it "should read from uppercase method" do
+        @email.body = "world"
+        @email.Data.should == "world"
+      end
+    end
+    
+    describe "setter" do
+      it "should exist" do
+        lambda { @email.subject = "hello" }.should.not.raise
+      end
+      
+      it "should write" do
+        @email.subject = "hello"
+        @email.title.should == "hello"
+      end
+      
+      it "should write to uppercase method" do
+        @email.Data = "world"
+        @email.body.should == "world"
+      end
+    end
+    
+    describe "question method" do
+      it "should exist" do
+        lambda { @email.subject? }.should.not.raise
+      end
+      
+      it "should return false for nil attribute" do
+        @email.subject?.should == false
+      end
+      
+      it "should return true for non-nil attribute" do
+        @email.title = "hello"
+        @email.subject?.should == true
+      end
+      
+      it "should return true for non-nil uppercase attribute" do
+        @email.body = "hello"
+        @email.Data?.should == true
+      end
+    end
+  end
+end

data/spec/motion-support/core_ext/module/anonymous_spec.rb

@@ -0,0 +1,29 @@
+describe "module" do
+  describe "anonymous?" do
+    it "should return true for an anonymous module" do
+      Module.new.anonymous?.should == true
+    end
+    
+    it "should return true for an anonymous class" do
+      Class.new.anonymous?.should == true
+    end
+    
+    it "should return false for a named module" do
+      Kernel.anonymous?.should == false
+    end
+    
+    it "should return false for a named class" do
+      Object.anonymous?.should == false
+    end
+    
+    it "should return false for module that acquired a name" do
+      NamedModule = Module.new
+      NamedModule.anonymous?.should == false
+    end
+    
+    it "should return false for module that acquired a name" do
+      NamedClass = Class.new
+      NamedClass.anonymous?.should == false
+    end
+  end
+end