motion_blender-support 0.2.7

data/spec/motion-support/core_ext/object/duplicable_spec.rb

@@ -0,0 +1,31 @@
+describe "duplicable?" do
+  before do
+    @raise_dup = [nil, false, true, :symbol, 1, 2.3, 5.seconds, BigDecimal.new('4.56')]
+    @yes = ['1', Object.new, /foo/, [], {}, Time.now, Class.new, Module.new]
+    @no = []
+  end
+  
+  it "should return false for non-duplicable objects" do
+    (@raise_dup + @no).each do |v|
+      v.should.not.be.duplicable
+    end
+  end
+  
+  it "should return true for duplicable objects" do
+    @yes.each do |v|
+      v.should.be.duplicable
+    end
+  end
+  
+  it "should not raise when dupping duplicable objects" do
+    (@yes + @no).each do |v|
+      lambda { v.dup }.should.not.raise
+    end
+  end
+  
+  it "should raise when dupping non-duplicable objects" do
+    @raise_dup.each do |v|
+      lambda { v.dup }.should.raise TypeError
+    end
+  end
+end

data/spec/motion-support/core_ext/object/inclusion_spec.rb

@@ -0,0 +1,34 @@
+class LifeUniverseAndEverything
+  def include?(obj)
+    obj == 42
+  end
+end
+
+
+describe 'array' do
+  describe "in?" do
+    it "should support arrays" do
+      1.in?([1,2,3]).should == true
+      0.in?([1,2,3]).should == false
+    end
+
+    it "should support hashes" do
+      :a.in?({a:1,b:2,c:3}).should == true
+      1.in?({a:1,b:2,c:3}).should == false
+    end
+
+    it "should support ranges" do
+      1.in?(1..3).should == true
+      0.in?(1..3).should == false
+    end
+
+    it "should support strings" do
+      'a'.in?("apple").should == true
+    end
+
+    it "should support anything that implements `include?`" do
+      42.in?(LifeUniverseAndEverything.new).should == true
+      0.in?(LifeUniverseAndEverything.new).should == false
+    end
+  end
+end

data/spec/motion-support/core_ext/object/instance_variable_spec.rb

@@ -0,0 +1,19 @@
+describe "Object" do
+  before do
+    @source = Object.new
+    @source.instance_variable_set(:@bar, 'bar')
+    @source.instance_variable_set(:@baz, 'baz')
+  end
+  
+  describe "instance_variable_names" do
+    it "should return all instance variable names" do
+      @source.instance_variable_names.sort.should == %w(@bar @baz)
+    end
+  end
+  
+  describe "instance_values" do
+    it "should return the values of all instance variables as a hash" do
+      @source.instance_values.should == {'bar' => 'bar', 'baz' => 'baz'}
+    end
+  end
+end

data/spec/motion-support/core_ext/object/to_param_spec.rb

@@ -0,0 +1,75 @@
+class ArrayToParam < String
+  def to_param
+    "#{self}1"
+  end
+end
+
+class HashToParam < String
+  def to_param
+    "#{self}-1"
+  end
+end
+
+describe "to_param" do
+  describe "object" do
+    it "should delegate to to_s" do
+      foo = Object.new
+      def foo.to_s; 'foo' end
+      foo.to_param.should == 'foo'
+    end
+  end
+
+  describe "nil" do
+    it "should return self" do
+      nil.to_param.should == nil
+    end
+  end
+
+  describe "true, false" do
+    it "should return self" do
+      true.to_param.should == true
+      false.to_param.should == false
+    end
+  end
+  
+  describe "array" do
+    it "should convert string array" do
+      %w().to_param.should == ''
+      %w(hello world).to_param.should == 'hello/world'
+      %w(hello 10).to_param.should == 'hello/10'
+    end
+
+    it "should convert number array" do
+      [10, 20].to_param.should == '10/20'
+    end
+
+    it "should convert custom object array" do
+      [ArrayToParam.new('custom'), ArrayToParam.new('param')].to_param.should == 'custom1/param1'
+    end
+  end
+
+  describe "hash" do
+    it "should convert a string hash" do
+      {}.to_param.should == ''
+      { :hello => "world" }.to_param.should == 'hello=world'
+      { "hello" => 10 }.to_param.should == 'hello=10'
+      {:hello => "world", "say_bye" => true}.to_param.should == 'hello=world&say_bye=true'
+    end
+
+    it "should convert a number hash" do
+      {10 => 20, 30 => 40, 50 => 60}.to_param.should == '10=20&30=40&50=60'
+    end
+
+    it "should convert an object hash" do
+      {HashToParam.new('custom') => HashToParam.new('param'), HashToParam.new('custom2') => HashToParam.new('param2')}.to_param.should == 'custom-1=param-1&custom2-1=param2-1'
+    end
+
+    it "should escape keys and values" do
+      { 'param 1' => 'A string with / characters & that should be ? escaped' }.to_param.should == 'param+1=A+string+with+%2F+characters+%26+that+should+be+%3F+escaped'
+    end
+
+    it "should order keys in ascending order" do
+      Hash[*%w(b 1 c 0 a 2)].to_param.should == 'a=2&b=1&c=0'
+    end
+  end
+end

data/spec/motion-support/core_ext/object/to_query_spec.rb

@@ -0,0 +1,37 @@
+class Should
+  def equal_query(query)
+    @object.to_query.split('&').should == query.split('&')
+  end
+end
+
+describe "to_query" do
+  it "should do a simple converion" do
+    { :a => 10 }.should.equal_query 'a=10'
+  end
+
+  it "should escape for CGI" do
+    { 'a:b' => 'c d' }.should.equal_query 'a%3Ab=c+d'
+  end
+  
+  it "should work with nil parameter value" do
+    empty = Object.new
+    def empty.to_param; nil end
+    { 'a' => empty }.should.equal_query 'a='
+  end
+  
+  it "should do a nested conversion" do
+    { :person => Hash[:login, 'seckar', :name, 'Nicholas'] }.should.equal_query 'person%5Blogin%5D=seckar&person%5Bname%5D=Nicholas'
+  end
+  
+  it "should do a multiply nested query" do
+    Hash[:account, {:person => {:id => 20}}, :person, {:id => 10}].should.equal_query 'account%5Bperson%5D%5Bid%5D=20&person%5Bid%5D=10'
+  end
+  
+  it "should work with array values" do
+    { :person => {:id => [10, 20]} }.should.equal_query 'person%5Bid%5D%5B%5D=10&person%5Bid%5D%5B%5D=20'
+  end
+  
+  it "should not sort array values" do
+    { :person => {:id => [20, 10]} }.should.equal_query 'person%5Bid%5D%5B%5D=20&person%5Bid%5D%5B%5D=10'
+  end
+end

data/spec/motion-support/core_ext/object/try_spec.rb

@@ -0,0 +1,92 @@
+describe "Object" do
+  before do
+    @string = "Hello"
+  end
+
+  describe "try" do
+    it "should return nil for nonexisting method" do
+      method = :undefined_method
+      @string.should.not.respond_to method
+      @string.try(method).should.be.nil
+    end
+
+    it "should return nil for nonexisting method with arguments" do
+      method = :undefined_method
+      @string.should.not.respond_to method
+      @string.try(method, 'llo', 'y').should.be.nil
+    end
+
+    it "should delegate to existing method" do
+      @string.try(:size).should == 5
+    end
+
+    it "should forward arguments to existing method" do
+      @string.try(:sub, 'llo', 'y').should == 'Hey'
+    end
+
+    it "should forward block to existing method" do
+      @string.try(:sub, 'llo') { |match| 'y' }.should == 'Hey'
+    end
+
+    it "should return nil when called on nil even if method is defined on nil" do
+      nil.try(:to_s).should.be.nil
+      nil.try(:to_i).should.be.nil
+    end
+
+    it "should work as expected on false" do
+      false.try(:to_s).should == 'false'
+    end
+
+    it "should pass existing receiver to block" do
+      @string.try { |s| s.reverse }.should == @string.reverse
+    end
+
+    it "should not pass nil to block" do
+      ran = false
+      nil.try { ran = true }
+      ran.should == false
+    end
+
+    it "should not call private method" do
+      klass = Class.new do
+        private
+
+        def private_method
+          'private method'
+        end
+      end
+
+      klass.new.try(:private_method).should == nil
+    end
+  end
+
+  describe "try!" do
+    it "should raise error for nonexisting method" do
+      method = :undefined_method
+      @string.should.not.respond_to method
+      lambda { @string.try!(method) }.should.raise NoMethodError
+    end
+
+    it "should raise error for nonexisting method with arguments" do
+      method = :undefined_method
+      @string.should.not.respond_to method
+      lambda { @string.try!(method, 'llo', 'y') }.should.raise NoMethodError
+    end
+
+    it "should pass existing receiver to block" do
+      @string.try! { |s| s.reverse }.should == @string.reverse
+    end
+
+    it "should raise error when calling private method" do
+      klass = Class.new do
+        private
+
+        def private_method
+          'private method'
+        end
+      end
+
+      lambda { klass.new.try!(:private_method) }.should.raise NoMethodError
+    end
+  end
+end

data/spec/motion-support/core_ext/range/include_range_spec.rb

@@ -0,0 +1,31 @@
+describe "Range" do
+  describe "include?" do
+    it "should should include identical inclusive" do
+      (1..10).should.include(1..10)
+    end
+
+    it "should should include identical exclusive" do
+      (1...10).should.include(1...10)
+    end
+
+    it "should should include other with exlusive end" do
+      (1..10).should.include(1...10)
+    end
+
+    it "should exclusive end should not include identical with inclusive end" do
+      (1...10).should.not.include(1..10)
+    end
+
+    it "should should not include overlapping first" do
+      (2..8).should.not.include(1..3)
+    end
+
+    it "should should not include overlapping last" do
+      (2..8).should.not.include(5..9)
+    end
+
+    it "should should include identical exclusive with floats" do
+      (1.0...10.0).should.include(1.0...10.0)
+    end
+  end
+end

data/spec/motion-support/core_ext/range/overlap_spec.rb

@@ -0,0 +1,43 @@
+describe "Range" do
+  describe "overlaps?" do
+    it "should overlaps last inclusive" do
+      (1..5).overlaps?(5..10).should.be.true
+    end
+
+    it "should overlaps last exclusive" do
+      (1...5).overlaps?(5..10).should.be.false
+    end
+
+    it "should overlaps first inclusive" do
+      (5..10).overlaps?(1..5).should.be.true
+    end
+
+    it "should overlaps first exclusive" do
+      (5..10).overlaps?(1...5).should.be.false
+    end
+
+    it "should should compare identical inclusive" do
+      ((1..10) === (1..10)).should.be.true
+    end
+
+    it "should should compare identical exclusive" do
+      ((1...10) === (1...10)).should.be.true
+    end
+
+    it "should should compare other with exlusive end" do
+      ((1..10) === (1...10)).should.be.true
+    end
+
+    it "should overlaps on time" do
+      time_range_1 = Time.utc(2005, 12, 10, 15, 30)..Time.utc(2005, 12, 10, 17, 30)
+      time_range_2 = Time.utc(2005, 12, 10, 17, 00)..Time.utc(2005, 12, 10, 18, 00)
+      time_range_1.overlaps?(time_range_2).should.be.true
+    end
+
+    it "should no overlaps on time" do
+      time_range_1 = Time.utc(2005, 12, 10, 15, 30)..Time.utc(2005, 12, 10, 17, 30)
+      time_range_2 = Time.utc(2005, 12, 10, 17, 31)..Time.utc(2005, 12, 10, 18, 00)
+      time_range_1.overlaps?(time_range_2).should.be.false
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+describe "Regexp" do
+  it "should find out if regexp is multiline" do
+    //m.multiline?.should.be.true
+    //.multiline?.should.be.false
+    /(?m:)/.multiline?.should.be.false
+  end
+end

data/spec/motion-support/core_ext/string/access_spec.rb

@@ -0,0 +1,53 @@
+describe "String" do
+  describe "access" do
+    it "should access" do
+      s = "hello"
+      s.at(0).should == "h"
+
+      s.from(2).should == "llo"
+      s.to(2).should == "hel"
+
+      s.first.should == "h"
+      s.first(2).should == "he"
+      s.first(0).should == ""
+
+      s.last.should == "o"
+      s.last(3).should == "llo"
+      s.last(10).should == "hello"
+      s.last(0).should == ""
+
+      'x'.first.should == 'x'
+      'x'.first(4).should == 'x'
+
+      'x'.last.should == 'x'
+      'x'.last(4).should == 'x'
+    end
+
+    it "should access returns a real string" do
+      hash = {}
+      hash["h"] = true
+      hash["hello123".at(0)] = true
+      hash.keys.should == %w(h)
+
+      hash = {}
+      hash["llo"] = true
+      hash["hello".from(2)] = true
+      hash.keys.should == %w(llo)
+
+      hash = {}
+      hash["hel"] = true
+      hash["hello".to(2)] = true
+      hash.keys.should == %w(hel)
+
+      hash = {}
+      hash["hello"] = true
+      hash["123hello".last(5)] = true
+      hash.keys.should == %w(hello)
+
+      hash = {}
+      hash["hello"] = true
+      hash["hello123".first(5)] = true
+      hash.keys.should == %w(hello)
+    end
+  end
+end

data/spec/motion-support/core_ext/string/behavior_spec.rb

@@ -0,0 +1,7 @@
+describe "String" do
+  describe "behavior" do
+    it "should acts like string" do
+      'Bambi'.acts_like_string?.should == true
+    end
+  end
+end

data/spec/motion-support/core_ext/string/exclude_spec.rb

@@ -0,0 +1,8 @@
+describe "String" do
+  describe "exclude?" do
+    it "should be the inverse of #include" do
+      'foo'.exclude?('o').should.be.false
+      'foo'.exclude?('p').should.be.true
+    end
+  end
+end

data/spec/motion-support/core_ext/string/filter_spec.rb

@@ -0,0 +1,49 @@
+describe "String" do
+  describe "filters" do
+    describe "squish" do
+      before do
+        @original = %{\u180E\u180E A string surrounded by unicode mongolian vowel separators,
+          with tabs(\t\t), newlines(\n\n), unicode nextlines(\u0085\u0085) and many spaces(  ). \u180E\u180E}
+        @original.gsub!(/\u180E/, '') # mongolian vowel separators does not match [[:space:]]
+
+        @expected = "A string surrounded by unicode mongolian vowel separators, " +
+          "with tabs( ), newlines( ), unicode nextlines( ) and many spaces( )."
+      end
+      
+      it "should squish string" do
+        @original.squish.should == @expected
+        @original.should.not == @expected
+      end
+
+      it "should squish! string" do
+        @original.squish!.should == @expected
+        @original.should == @expected
+      end
+    end
+    
+    describe "truncate" do
+      it "should truncate string" do
+        "Hello World!".truncate(12).should == "Hello World!"
+        "Hello World!!".truncate(12).should == "Hello Wor..."
+      end
+      
+      it "should truncate with omission and seperator" do
+        "Hello World!".truncate(10, :omission => "[...]").should == "Hello[...]"
+        "Hello Big World!".truncate(13, :omission => "[...]", :separator => ' ').should == "Hello[...]"
+        "Hello Big World!".truncate(14, :omission => "[...]", :separator => ' ').should == "Hello Big[...]"
+        "Hello Big World!".truncate(15, :omission => "[...]", :separator => ' ').should == "Hello Big[...]"
+      end
+      
+      it "should truncate with omission and regexp seperator" do
+        "Hello Big World!".truncate(13, :omission => "[...]", :separator => /\s/).should == "Hello[...]"
+        "Hello Big World!".truncate(14, :omission => "[...]", :separator => /\s/).should == "Hello Big[...]"
+        "Hello Big World!".truncate(15, :omission => "[...]", :separator => /\s/).should == "Hello Big[...]"
+      end
+      
+      it "should truncate multibyte" do
+        "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 \354\225\204\353\235\274\353\246\254\354\230\244".force_encoding(Encoding::UTF_8).truncate(10).should ==
+          "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 ...".force_encoding(Encoding::UTF_8)
+      end
+    end
+  end
+end

data/spec/motion-support/core_ext/string/indent_spec.rb

@@ -0,0 +1,56 @@
+describe "String" do
+  describe "indent" do
+    it "should not indent strings that only contain newlines (edge cases)" do
+      ['', "\n", "\n" * 7].each do |str|
+        str.indent!(8).should.be.nil
+        str.indent(8).should == str
+        str.indent(1, "\t").should == str
+      end
+    end
+
+    it "should indent by default with spaces if the existing indentation uses them" do
+      "foo\n  bar".indent(4).should == "    foo\n      bar"
+    end
+
+    it "should indent by default with tabs if the existing indentation uses them" do
+      "foo\n\t\bar".indent(1).should == "\tfoo\n\t\t\bar"
+    end
+
+    it "should indent by default with spaces as a fallback if there is no indentation" do
+      "foo\nbar\nbaz".indent(3).should == "   foo\n   bar\n   baz"
+    end
+
+    # Nothing is said about existing indentation that mixes spaces and tabs, so
+    # there is nothing to test.
+
+    it "should use the indent char if passed" do
+      <<ACTUAL.indent(4, '.').should == <<EXPECTED
+  def some_method(x, y)
+    some_code
+  end
+ACTUAL
+....  def some_method(x, y)
+....    some_code
+....  end
+EXPECTED
+
+      <<ACTUAL.indent(2, '&nbsp;').should == <<EXPECTED
+&nbsp;&nbsp;def some_method(x, y)
+&nbsp;&nbsp;&nbsp;&nbsp;some_code
+&nbsp;&nbsp;end
+ACTUAL
+&nbsp;&nbsp;&nbsp;&nbsp;def some_method(x, y)
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;some_code
+&nbsp;&nbsp;&nbsp;&nbsp;end
+EXPECTED
+    end
+
+    it "should not indent blank lines by default" do
+      "foo\n\nbar".indent(1).should == " foo\n\n bar"
+    end
+
+    it "should indent blank lines if told so" do
+      "foo\n\nbar".indent(1, nil, true).should == " foo\n \n bar"
+    end
+  end
+end