facets-glimmer 3.2.0

data/test/core/proc/test_bind_to.rb

@@ -0,0 +1,17 @@
+covers 'facets/proc/bind_to'
+
+test_case Proc do
+
+  method :bind_to do
+
+    test do
+       a = [1,2,3]
+       p1 = Proc.new{ join(' ') }
+       p2 = p1.bind_to(a)
+       p2.call.assert == '1 2 3'
+    end
+
+  end
+
+end
+

data/test/core/proc/test_compose.rb

@@ -0,0 +1,27 @@
+covers 'facets/proc/compose'
+
+test_case Proc do
+
+  method :compose do
+
+    test do
+      a = lambda { |x| x + 4 }
+      b = lambda { |y| y / 2 }
+      (a.compose(b)).call(4).assert == 6
+      (b.compose(a)).call(4).assert == 4
+    end
+
+  end
+
+  method :* do
+
+    test do
+      a = lambda { |x| x + 4 }
+      b = lambda { |y| y / 2 }
+      (a * b).call(4).assert == 6
+      (b * a).call(4).assert == 4
+    end
+
+  end
+
+end

data/test/core/proc/test_partial.rb

@@ -0,0 +1,27 @@
+covers 'facets/proc/partial'
+
+test_case Proc do
+
+  method :partial do
+
+    test "first argument" do
+      f = Proc.new{ |a,b,c| a + b + c }
+      n = f.partial(NA,2,3)
+      n[1].assert == 6
+    end
+
+    test "second argument" do
+      f = Proc.new{ |a,b,c| a + b + c }
+      n = f.partial(1,NA,3)
+      n[2].assert == 6
+    end
+
+    test "third argument" do
+      f = Proc.new{ |a,b,c| a + b + c }
+      n = f.partial(1,2,NA)
+      n[3].assert == 6
+    end
+
+  end
+
+end

data/test/core/proc/test_to_method.rb

@@ -0,0 +1,43 @@
+covers 'facets/proc/to_method'
+
+test_case Proc do
+
+  method :to_method do
+
+    test do
+      o = Object.new
+      tproc = proc { |x| x + 2 }
+
+      tmeth = tproc.to_method(o, :tryit)
+
+      tmeth.call(1).assert == 3
+      o.assert.respond_to?(:tryit)
+      o.tryit(1).assert == 3
+    end
+
+    test "with immutable object" do
+      o = :foo
+      tproc = proc{ self }
+
+      tmeth = tproc.to_method(o, :tryit)
+
+      tmeth.call.assert == :foo
+      o.assert.respond_to?(:tryit)
+      o.tryit.assert == :foo
+    end
+
+    test "ensure method is in object scope" do
+      o = Struct.new(:a).new(1)
+      tproc = proc{ a }
+
+      tmeth = tproc.to_method(o, :tryit)
+
+      tmeth.call.assert == 1
+      o.assert.respond_to?(:tryit)
+      o.tryit.assert == 1
+    end
+
+  end
+
+end
+

data/test/core/proc/test_update.rb

@@ -0,0 +1,15 @@
+covers 'facets/proc/update'
+
+test_case Proc do
+
+  method :update do
+
+    test do
+      p1 = Proc.new{ 'here' }
+      p1.update.assert == 'here'
+    end
+
+  end
+
+end
+

data/test/core/range/test_combine.rb

@@ -0,0 +1,32 @@
+covers 'facets/range/combine'
+
+test_case Range do
+
+  method :combine do
+
+    test do
+      r = 0..4
+      r = r.combine(2..6, 6..10, 13..17, 12..19)
+      x = [0..10, 12..19]
+      r.assert == x
+    end
+
+  end
+
+  class_method :combine do
+
+    test do
+      r = Range.combine(0..4, 2..6, 6..10, 13..17, 12..19)
+      x = [0..10, 12..19]
+      r.assert == x
+    end
+
+    test "arrays as intervals" do
+      r = Range.combine([0, 4], [2, 6], [6, 10], [13, 17], [12, 19])
+      x = [[0, 10], [12, 19]]
+      r.assert == x
+    end
+
+  end
+
+end

data/test/core/range/test_nudge.rb

@@ -0,0 +1,32 @@
+covers 'facets/range/nudge'
+
+test_case Range do
+  method :nudge do
+    test 'default nudge' do
+      (17..32).nudge.assert == (18..33)
+      (17..32).nudge.nudge.assert == (19..34)
+      (17...32).nudge.assert == (18...33)
+    end
+
+    test 'positive nudge' do
+      (1..9).nudge(2).assert == (3..11)
+      (1...9).nudge(2).assert == (3...11)
+    end
+
+    test 'negative nudge' do
+      (5..6).nudge(-2).assert == (3..4)
+      (5...6).nudge(-2).assert == (3...4)
+    end
+
+    test 'min nudge' do
+      (5..9).nudge(:min => 2).assert == (7..9)
+      (5...9).nudge(:min => 2).assert == (7...9)
+    end
+
+    test 'max nudge' do
+      (8..16).nudge(:max => 10).assert == (8..26)
+      (8...16).nudge(:max => 10).assert == (8...26)
+    end
+  end
+end
+

data/test/core/range/test_op_add.rb

@@ -0,0 +1,24 @@
+require 'facets/range/op_add'
+
+test_case Range do
+
+	method :+ do
+    #test { lambda{ (1..10) + 'a' }.assert raise_error }
+
+    test { ((1..10) + (11..11)).assert == [1..11] }
+    test { ((1..10) + 12).assert == [1..10, 12] }
+    test { ((1..10) + (10..12)).assert == [1..12] }
+    test { ((1..10) + (11..12)).assert == [1..12] }
+    test { ((1..10) + (9..12)).assert == [1..12] }
+    test { ((1..10) + (1..12)).assert == [1..12] }
+    test { ((1..10) + (12..20)).assert == [1..10, 12..20] }
+    test { ((1..10) + 0).assert == [0..10] }
+    test { ((1..10) + -1).assert == [-1, 1..10] }
+    test { ((1..10) + (-10..-1)).assert == [-10..-1, 1..10] }
+    test { ((1..10) + (-10..0)).assert == [-10..10] }
+    test { ((1..10) + (-10..1)).assert == [-10..10] }
+    test { ((1..10) + (-10..2)).assert == [-10..10] }
+    test { ((1..10) + (-10..20)).assert == [-10..20]}
+  end
+
+end

data/test/core/range/test_op_sub.rb

@@ -0,0 +1,34 @@
+require 'facets/range/op_sub'
+
+test_case Range do
+
+  method :- do
+    #test { lambda{ (1..10) - 'a' }.assert raise_error }
+
+    test { ((1..10) - (5..5)).assert == [1..4, 6..10] }
+		test { ((1..10) - 2).assert == [1, 3..10] }
+		test { ((1..10) - 9).assert == [1..8, 10] }
+		test { ((1..10) - 10).assert == [1..9, nil] }
+		test { ((1..10) - 1).assert == [nil, 2..10] }
+		test { ((1..10) - 11).assert == [1..10, nil] }
+		test { ((1..10) - 12).assert == [1..10, nil] }
+		test { ((1..10) - 0).assert == [nil, 1..10] }
+		test { ((1..10) - -1).assert == [nil, 1..10] }
+
+    test { ((1..10) - (4..6)).assert == [1..3, 7..10] }
+    test { ((1..10) - (2..6)).assert == [1, 7..10] }
+    test { ((1..10) - (4..9)).assert == [1..3, 10] }
+    test { ((1..10) - (2..9)).assert == [1, 10] }
+    test { ((1..10) - (2..11)).assert == [1] }
+    test { ((1..10) - (0..9)).assert == [10] }
+    test { ((1..10) - (4..10)).assert == [1..3] }
+    test { ((1..10) - (4..12)).assert == [1..3] }
+    test { ((1..10) - (1..6)).assert == [7..10] }
+    test { ((1..10) - (-2..6)).assert == [7..10] }
+    test { ((1..10) - (11..20)).assert == [1..10] }
+    test { ((1..10) - (-10..0)).assert == [1..10] }
+    test { ((1..10) - (-10..20)).assert == [] }
+	end
+	
+end
+

data/test/core/range/test_overlap.rb

@@ -0,0 +1,15 @@
+covers 'facets/range/overlap'
+
+test_case Range do
+
+  method :overlap? do
+
+    test do
+      assert( (4..5).overlap?(3..6) )
+      assert(! (7..9).overlap?(3..6) )
+    end
+
+  end
+
+end
+

data/test/core/range/test_to_rng.rb

@@ -0,0 +1,20 @@
+covers 'facets/range/to_rng'
+
+test_case Range do
+
+  method :to_rng do
+    test do
+      a = (0..10)
+      a.to_rng.assert == a
+    end
+  end
+
+  method :to_range do
+    test do
+      a = (0..10)
+      a.to_range.assert == a
+    end
+  end
+
+end
+

data/test/core/range/test_umbrella.rb

@@ -0,0 +1,32 @@
+covers 'facets/range/umbrella'
+
+test_case Range do
+
+  method :umbrella do
+
+    test do
+      (3..6).umbrella(3..6).assert == [0,0]
+      (3...6).umbrella(3...6).assert == [0,0]
+    end
+
+    test "partially aligned" do
+      (3..6).umbrella(2..6).assert == [1,0]
+      (3..6).umbrella(3..7).assert == [0,1]
+      (3..6).umbrella(4..6).assert == [-1,0]
+      (3..6).umbrella(3..5).assert == [0,-1]
+    end
+
+    test "offset" do
+      (3..6).umbrella(2..7).assert == [1,1]
+      (3..6).umbrella(4..7).assert == [-1,1]
+      (3..6).umbrella(2..5).assert == [1,-1]
+      (3..6).umbrella(4..5).assert == [-1,-1]
+    end
+
+    test "offset by exclusion" do
+      (10...20).umbrella(10..20).assert == [0,1]
+    end
+
+  end
+
+end

data/test/core/range/test_within.rb

@@ -0,0 +1,25 @@
+covers 'facets/range/within'
+
+test_case Range do
+
+  method :within? do
+
+    test "wholy within range" do
+      assert( (4..5).within?(3..6) )
+    end
+
+    test "sentinals are equal" do
+      assert( (3..6).within?(3..6) )
+    end
+
+    test "lower sentinal out of range" do
+      assert(! (2..5).within?(3..6) )
+    end
+
+    test "upper sentinal out of range" do
+      assert(! (5..7).within?(3..6) )
+    end
+
+  end
+
+end

data/test/core/regexp/test_arity.rb

@@ -0,0 +1,30 @@
+covers 'facets/regexp/arity'
+
+test_case Regexp do
+
+  method :arity do
+
+    test do
+      r = /(1)(2)(3)/
+      r.arity.assert == 3
+    end
+
+    test do
+      r = /(1)(2)(3)(4)/
+      r.arity.assert == 4
+    end
+
+    test do
+      r = /(1)(2)((a)3)/
+      r.arity.assert == 4
+    end
+
+    test do
+      r = /(?#nothing)(1)(2)(3)(?=3)/
+      r.arity.assert == 3
+    end
+
+  end
+
+end
+

data/test/core/regexp/test_multiline.rb

@@ -0,0 +1,19 @@
+covers 'facets/regexp/multiline'
+
+test_case Regexp do
+
+  method :multiline? do
+
+    test do
+      re = /x/m
+      re.assert.multiline?
+    end
+
+    test do
+      re = /x/
+      re.refute.multiline?
+    end
+
+  end
+
+end

data/test/core/regexp/test_op_add.rb

@@ -0,0 +1,15 @@
+covers 'facets/regexp/op_add'
+
+test_case Regexp do
+
+  method :+ do
+
+    test do
+      r = /a/ + /b/
+      r.assert == /(?-mix:a)(?-mix:b)/
+    end
+
+  end
+
+end
+

data/test/core/regexp/test_op_or.rb

@@ -0,0 +1,16 @@
+covers 'facets/regexp/op_or'
+
+test_case Regexp do
+
+  method :| do
+
+    test do
+      re = /a/ | /b/
+      re.assert =~ "a"
+      re.assert =~ "b"
+    end
+
+  end
+
+end
+

data/test/core/regexp/test_to_re.rb

@@ -0,0 +1,24 @@
+covers 'facets/regexp/to_re'
+
+test_case Regexp do
+
+  method :to_re do
+
+    test do
+      r = /0..10/
+      r.to_re.assert == r.to_re
+    end
+
+  end
+
+  method :to_regexp do
+
+    test do
+      r = /0..10/
+      r.to_regexp.assert == r
+    end
+
+  end
+
+end
+

data/test/core/string/test_acronym.rb

@@ -0,0 +1,14 @@
+covers 'facets/string/acronym'
+
+test_case String do
+
+  method :acronym do
+    test do
+      'abc'.acronym.assert == 'a'
+      'abc def'.acronym.assert == 'ad'
+      'abc def ghi'.acronym.assert == 'adg'
+    end
+  end
+
+end
+

data/test/core/string/test_align.rb

@@ -0,0 +1,32 @@
+covers 'facets/string/align'
+
+test_case String do
+
+  method :align do
+    test do
+      "xxx".align(:right, 9) == "      xxx"
+      "xxx".align(:left, 9).assert == "xxx      "
+      "xxx".align(:center, 9).assert == "   xxx   "
+    end
+  end
+
+  method :align_right do
+    test do
+      "xxx".align_right(9) == "      xxx"
+    end
+  end
+
+  method :align_left do
+    test do
+      "xxx".align_left(9).assert == "xxx      "
+    end
+  end
+
+  method :align_center do
+    test do
+      "xxx".align_center(9).assert == "   xxx   "
+    end
+  end
+
+end
+

data/test/core/string/test_ascii_only.rb

@@ -0,0 +1,51 @@
+covers 'facets/string/ascii_only'
+
+test_case String do
+
+  method :ascii_only do
+    test 'without any non-ascii' do
+      'abc'.ascii_only.assert == 'abc'
+    end
+
+    test 'with non-ascii' do
+     '中文123'.ascii_only.assert == '123'
+    end
+
+    test 'with non-ascii when passed alt' do
+      'abc'.ascii_only('!').assert == 'abc'
+    end
+
+    test 'with non-ascii when passed alt' do
+      '中文123'.ascii_only('!').assert == '!!123'
+    end
+  end
+
+  method :ascii_only! do
+    test 'without any non-ascii' do
+      s = 'abc'
+      s.ascii_only!
+      s.assert == 'abc'
+    end
+
+    test 'with non-ascii' do
+      s = '中文123'
+      s.ascii_only!
+      s.assert == '123'
+    end
+
+    test 'without any non-ascii' do
+      s = 'abc'
+      s.ascii_only!('!')
+      s.assert == 'abc'
+    end
+
+    test 'with non-ascii' do
+      s = '中文123'
+      s.ascii_only!('!')
+      s.assert == '!!123'
+    end
+
+  end
+
+end
+

data/test/core/string/test_bracket.rb

@@ -0,0 +1,37 @@
+covers 'facets/string/bracket'
+
+test_case String do
+
+  method :bracket do
+    test do
+      'X'.bracket('#').assert == '#X#'
+      'X'.bracket('x','!').assert == 'xX!'
+      'X'.bracket('{','}').assert == '{X}'
+      'X'.bracket('<').assert == '<X>'
+      'X'.bracket('(').assert == '(X)'
+      'X'.bracket('[').assert == '[X]'
+      'X'.bracket('{').assert == '{X}'
+    end
+  end
+
+  method :bracket! do
+    test do
+      a = 'X' ; a.bracket!('#')
+      a.assert == '#X#'
+      a = 'X' ; a.bracket!('x','!')
+      a.assert == 'xX!'
+      a = 'X' ; a.bracket!('{','}')
+      a.assert == '{X}'
+      a = 'X' ; a.bracket!('<')
+      a.assert == '<X>'
+      a = 'X' ; a.bracket!('(')
+      a.assert == '(X)'
+      a = 'X' ; a.bracket!('[')
+      a.assert == '[X]'
+      a = 'X' ; a.bracket!('{')
+      a.assert == '{X}'
+    end
+  end
+
+end
+

data/test/core/string/test_camelcase.rb

@@ -0,0 +1,59 @@
+covers 'facets/string/camelcase'
+
+test_case String do
+
+  method :camelcase do
+
+    test do
+      "Camel_case".camelcase.assert == "CamelCase"
+    end
+
+    test "converts underscore to captialized" do
+      "abc_xyz".camelcase.assert == "abcXyz"
+      "abc____xyz".camelcase.assert == "abcXyz"
+    end
+
+    test "can captialize at spaces" do
+      "abc xyz".camelcase(' ').assert == "abcXyz"
+      "abc  xyz".camelcase(' ').assert == "abcXyz"
+    end
+
+    test "can capitalize at arbitrary string" do
+      "abc;xyz".camelcase(';').assert == "abcXyz"
+      "abc//xyz".camelcase('//').assert == "abcXyz"
+    end
+
+    test "can captialize at regexp" do
+      "abc\nxyz".camelcase(/\s/).assert == "abcXyz"
+      "abc\txyz".camelcase(/\s/).assert == "abcXyz"
+    end
+
+    # this functionality is in String#modulize instead
+    test "does not convert paths to module names" do
+      'my_module/my_class'.camelcase.refute  == 'MyModule::MyClass'
+      '/my_module/my_class'.camelcase.refute == '::MyModule::MyClass'
+    end
+
+    # this functionality is in String#modulize instead
+    test "does not convert methods to module names" do
+      'My_module__my_class'.camelcase.refute   == 'MyModule::MyClass'
+      '__My_module__my_class'.camelcase.refute == '::MyModule::MyClass'
+    end
+
+  end
+
+  method :lower_camelcase do
+    test do
+      "abc_xyz".lower_camelcase.assert == "abcXyz"
+      "Abc_xyz".lower_camelcase.assert == "abcXyz"
+    end
+  end
+
+  method :upper_camelcase do
+    test do
+      "abc_xyz".upper_camelcase.assert == "AbcXyz"
+      "Abc_xyz".upper_camelcase.assert == "AbcXyz"
+    end
+  end
+
+end