facets 3.1.0 → 3.2.0

data/test/core/range/test_nudge.rb

@@ -1,32 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

data/test/core/string/test_capitalized.rb

@@ -1,36 +0,0 @@
-covers 'facets/string/capitalized'
-
-test_case String do
-
-  method :capitalized? do
-    test do
-      'Abc'.assert.capitalized?
-    end
-  end
-
-  method :downcase? do
-    test do
-      'abc'.assert.downcase?
-    end
-  end
-
-  method :upcase? do
-    test do
-      'ABC'.assert.upcase?
-    end
-  end
-
-  #method :lowercase? do
-  #  test do
-  #    'abc'.assert.lowercase?
-  #  end
-  #end
-
-  #method :uppercase? do
-  #  test do
-  #    'ABC'.assert.uppercase?
-  #  end
-  #end
-
-end
-

data/test/core/string/test_characters.rb

@@ -1,13 +0,0 @@
-covers 'facets/string/characters'
-
-test_case String do
-
-  method :characters do
-    test do
-      "abc".characters.assert == ["a","b","c"]
-      "ab\nc".characters.assert == ["a","b","\n","c"]
-    end
-  end
-
-end
-

data/test/core/string/test_cleanlines.rb

@@ -1,12 +0,0 @@
-covers 'facets/string/cleanlines'
-
-test_case String do
-
-  method :cleanlines do
-    test do
-      "a \n b \nc".cleanlines.to_a.assert == ["a","b","c"]
-    end
-  end
-
-end
-

data/test/core/string/test_cleave.rb

@@ -1,27 +0,0 @@
-covers 'facets/string/cleave'
-
-test_case String do
-
-  method :cleave do
-
-    table = [
-      [ 'no spaces short word'    , 'whole'                              , ['whole', ''] ],
-      [ 'no spaces long word'     , 'Supercalifragilisticexpialidocious' , ['Supercalifragilisticexpialidocious', ''] ],
-      [ 'exact middle two words'  , 'fancy split'                        , ['fancy', 'split'] ],
-      [ 'exact middle many words' , 'All good Rubyists know how to party', ['All good Rubyists', 'know how to party'] ],
-      [ 'closer to start'         , 'short splitter'                     , ['short', 'splitter'] ],
-      [ 'closer to start'         , 'Four score and seven years ago...'  , ['Four score and', 'seven years ago...'] ],
-      [ 'closer to start'         , 'abc def ghijklm nop'                , ['abc def', 'ghijklm nop'] ],
-      [ 'closer to end'           , 'extended split'                     , ['extended', 'split'] ],
-      [ 'closer to end'           , 'abc defghi jklm nop'                , [ 'abc defghi', 'jklm nop'] ]
-    ]
-
-    table.each do |d, s, x|
-      test d do
-        s.cleave.assert == x
-      end
-    end
-
-  end
-
-end

data/test/core/string/test_cmp.rb

@@ -1,18 +0,0 @@
-covers 'facets/string/cmp'
-
-test_case String do
-
-  method :cmp do
-
-    test 'on strings' do
-      "abc".cmp("abc").assert == 0
-      "abc".cmp("abcd").assert == -1
-      "abcd".cmp("abc").assert ==  1
-      "abc".cmp("bcd").assert == -1
-      "bcd".cmp("abc").assert ==  1
-    end
-
-  end
-
-end
-

data/test/core/string/test_compress_lines.rb

@@ -1,27 +0,0 @@
-covers 'facets/string/compress_lines'
-
-test_case String do
-
-  method :compress_lines do
-
-    test do
-      string = <<-QUERY.compress_lines
-        SELECT name
-        FROM users
-      QUERY
-
-      string.assert == "SELECT name FROM users"
-    end
-
-    test do
-      string = <<-QUERY.compress_lines(false)
-        SELECT name
-        FROM users
-      QUERY
-
-      string.assert == "SELECT nameFROM users"
-    end
-
-  end
-
-end

data/test/core/string/test_crypt.rb

@@ -1,17 +0,0 @@
-covers 'facets/string/crypt'
-
-test_case String do
-
-  method :crypt do
-    test do
-      "abc".crypt('ZZ').assert.start_with?('ZZ')
-    end
-
-    test do
-      encrypted = "abc".crypt
-      salt = encrypted[0..1]
-      "abc".crypt(salt).assert == encrypted
-    end
-  end
-end
-

data/test/core/string/test_divide.rb

@@ -1,17 +0,0 @@
-covers 'facets/string/divide'
-
-test_case String do
-
-  method :divide do
-
-    test do
-      s = "<p>This<b>is</b>a test.</p>"
-      d = s.divide( /<.*?>/ )
-      e = ["<p>This", "<b>is", "</b>a test.", "</p>"]
-      d.assert == e
-    end
-
-  end
-
-end
-