facets 2.7.0 → 2.8.0

data/lib/more/facets/succ.rb

@@ -1,4 +1,4 @@
-class Integer
+class Fixnum
 
   # Allows #succ to take _n_ increments.
   #

data/meta/repository

@@ -0,0 +1 @@
+git@github.com:rubyworks/facets.git

data/meta/suite

@@ -0,0 +1 @@
+rubyworks

data/meta/version

@@ -1 +1 @@
-2.7.0
+2.8.0

data/script/conflicts

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+require 'enumerator'
+
+$: << 'lib'
+#$: << 'lib'
+
+libs = ARGV #(ENV['LIBS'] || "").split(/[;:]/)
+
+# We add time b/c both that's built-in but not loaded by Ruby.
+original = `script/methods time.rb yaml.rb`.split(/\s/)
+facets   = `script/methods lib/facets`.split(/\s/)
+other    = `script/methods #{libs.join(' ')}`.split(/\s/)
+
+facets = facets - original
+other  = other  - original
+clash  = facets & other
+
+puts clash.sort.join("\n")
+puts "  #{clash.size} Clashes"
+
+
+=begin
+
+# Return a hash for each defined class containing a array class and method.
+def methods_by_class
+  Module.
+    constants.
+    map{|klass| eval(klass)}.
+    select{|klass| klass.is_a? Class}.
+    inject({}){|h,klass|
+        h[klass] = [
+            klass.methods-klass.superclass.methods,
+            klass.instance_methods-(klass.superclass ? klass.superclass.instance_methods : [])
+          ]
+        h
+      }
+end
+
+before = methods_by_class
+
+ARGV.each{|a| require a }
+
+after = methods_by_class
+
+delta = after - before
+
+puts delta.join("\n")
+
+exit
+
+# Print the difference between the before and after method lists:
+before.keys.sort_by{|k| k.to_s}.each{|k|
+    class_diff = after[k][0]-before[k][0]
+    instance_diff = after[k][1]-before[k][1]
+    next if class_diff.empty? && instance_diff.empty?
+    puts((class_diff.sort.map{|c| "#{k}."+c} +
+          instance_diff.sort.map{|c| "#{k}#"+c}
+         )*"\n")
+  }
+
+=end
+

data/script/methods

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+require 'enumerator'
+
+def method_list
+  list = []
+
+  ObjectSpace.each_object(Module) do |klass|
+    insta_methods = klass.public_instance_methods(true) +
+                    klass.private_instance_methods(true) +
+                    klass.protected_instance_methods(true)
+
+    class_methods = klass.public_methods(true) + 
+                    klass.private_methods(true) +
+                    klass.protected_methods(true)
+
+    klass.ancestors[1..-1].each do |ancestor|
+      #next unless ancestor.is_a?(Module)
+
+      if ancestor.is_a?(Class)
+        insta_methods -= ancestor.public_instance_methods(true) +
+                         ancestor.private_instance_methods(true) +
+                         ancestor.protected_instance_methods(true)
+
+        class_methods -= ancestor.public_methods(true) +
+                         ancestor.private_methods(true) +
+                         ancestor.protected_methods(true)
+      end
+    end
+
+    class_methods -= Kernel.public_methods(true) +
+                     Kernel.private_methods(true) +
+                     Kernel.protected_methods(true)
+
+    class_methods.map!{|c| "#{klass}." + c}
+    insta_methods.map!{|c| "#{klass}#" + c}
+
+    list.concat(class_methods)
+    list.concat(insta_methods)
+  end
+
+  return list
+end
+
+ARGV.each{ |lib| require lib }
+
+puts method_list.sort.join("\n")
+
+

data/test/core/binding/test_caller.rb

@@ -33,12 +33,19 @@ class TestBindingCallStack < Test::Unit::TestCase
     assert_nothing_raised{ @bind.caller }
   end
 
-  def test_callee
-    assert_equal( :setup, @bind.__callee__ )
+  # These only work for certain versions, which is okay.
+
+  unless RUBY_VERSION < "1.9"
+    def test_callee
+      assert_equal(:setup, @bind.__callee__)
+    end
   end
 
-  def test_method
-    assert_equal( 'setup', @bind.__method__ )
+  unless RUBY_VERSION < "1.8.7"
+    def test_method
+      assert_equal(:setup, @bind.__method__)
+    end
   end
 
 end
+

data/test/core/enumerable/test_count.rb

@@ -3,20 +3,29 @@ require 'test/unit'
 
 class TC_Enumerable_Count < Test::Unit::TestCase
 
-  def test_count_01
-    e = [ 'a', '1', 'a' ]
-    assert_equal( 1, e.count('1') )
-    assert_equal( 2, e.count('a') )
+  def test_count_strings
+    e = ['a','1','a']
+    r = e.count('1')
+    assert_equal(1, r)
   end
 
-  def test_count_02
-    e = [ ['a',2], ['a',2], ['a',2], ['b',1] ]
-    assert_equal( 3, e.count(['a',2]) )
+  def test_count_strings_again
+    e = ['a','1','a']
+    r = e.count('a')
+    assert_equal(2, r)
   end
 
-  def test_count_03
-    e = { 'a' => 2, 'a' => 2, 'b' => 1 }
-    assert_equal(1, e.count(['a',2]))
+  def test_count_array_elements
+    e = [['a',2],['a',2],['a',2],['b',1]]
+    r = e.count(['a',2])
+    assert_equal(3, r)
+  end
+
+  def test_count_hash
+    e = { :a=>2, 'b'=>1, :c=>2 }
+    r = e.count(2)
+    assert_equal(2, r)
   end
 
 end
+

data/test/core/enumerable/test_map_detect.rb

@@ -0,0 +1,75 @@
+require 'facets/enumerable/map_detect'
+require 'test/unit'
+
+class TestEnumerable < Test::Unit::TestCase
+  
+  def test_map_detects_a_value
+    assert_equal true, [true].map_detect { |value| value }
+  end
+
+  def test_map_detect_detects_correct_value
+    assert_equal 1, [1].map_detect { |value| value }
+  end
+
+  def test_map_detect_returns_value_of_block
+    assert_equal 4, [1].map_detect { |v| v + 3 }
+  end
+
+  def test_map_detect_detects_first_truthy_value
+    assert_equal 1, [false, false, 1].map_detect { |value| value }
+  end
+
+  def test_map_detect_returns_value_when_block_is_true
+    assert_equal true, [false].map_detect { |value| true }
+  end
+
+  def test_map_detect_returns_early_when_block_is_true
+    val1 = lambda { :something }
+    val2 = lambda { raise "This shouldn't be called" }
+
+    assert_equal :something, [val1, val2].map_detect { |obj| obj.call }
+  end
+
+  def test_map_detect_returns_nil_when_block_returns_false_for_all_elements
+    assert_equal nil, [1,2,3,4].map_detect { |value| false }
+  end
+
+  def test_map_detect_returns_nil_when_no_elements_in_collection
+    assert_equal nil, [].map_detect { |v| }
+  end
+
+  def test_map_detect_can_have_return_value_specified_when_block_isnt_true
+    assert_equal :a_value, [1,2,3].map_detect(:a_value) { |value| false }
+  end
+
+  def test_map_detect_documentation_correct
+    obj1, obj2 = Object.new, Object.new
+
+    class << obj1
+      def foo?
+        false
+      end
+
+      def foo
+        raise
+      end
+    end
+
+    class << obj2
+      def foo?
+        true
+      end
+
+      def foo
+        "a value"
+      end
+    end
+
+    assert_equal false, obj1.foo?
+    assert_equal true, obj2.foo?
+    assert_equal "a value", obj2.foo
+
+    result = [obj1, obj2].map_detect { |obj| obj.foo if obj.foo? }
+    assert_equal result, "a value"
+  end
+end

data/test/core/enumerable/test_take.rb

@@ -1,7 +1,7 @@
 require 'facets/enumerable/take'
 require 'test/unit'
 
-class TC_Enumerable_Defer < Test::Unit::TestCase
+class TC_Enumerable_Take < Test::Unit::TestCase
 
   SOURCE = (1..1/0.0)   # infinite Enumerable object
 

data/test/core/kernel/test_object_hexid.rb

@@ -5,7 +5,8 @@ class TCKernel < Test::Unit::TestCase
 
   def test_object_hexid
     o = Object.new
-    assert( o.inspect.index(o.object_hexid) )
+    assert_equal(o.inspect, "#<Object:#{o.object_hexid}>")
+    #assert(o.inspect.index(o.object_hexid))
   end
 
 end

data/test/core/proc/test_to_method.rb

@@ -19,7 +19,7 @@ class TestProc < Test::Unit::TestCase
 
     assert_equal(:foo, tmeth.call)
     assert_respond_to( :foo, :tryit )
-    assert_equal( :foo, :foo.tryit(1) )
+    assert_equal( :foo, :foo.tryit )
   end
 
 end

data/test/core/string/test_cleanlines.rb

@@ -0,0 +1,11 @@
+require 'facets/string/cleanlines'
+require 'test/unit'
+
+class TC_String_CleanLines < Test::Unit::TestCase
+
+  def test_cleanlines
+    assert_equal( ["a","b","c"], "a \n b \nc".cleanlines.to_a )
+  end
+
+end
+

data/test/core/string/test_indent.rb

@@ -3,11 +3,73 @@ require 'test/unit'
 
 class TC_String_Indent < Test::Unit::TestCase
 
-  def test_indent
-    a = "xyz".indent(4)
-    assert_equal( '    ', a[0..3] )
-    # Need to expand on this
+  def test_positive_indent
+    assert_equal '    xyz', "xyz".  indent(4)
+    assert_equal '    xyz', "  xyz".indent(2)
   end
 
+  def test_multi_line_positive_indent
+    assert_equal  "  abc\n" +
+                  "  xyz"   , 
+                 ("abc\n"   +
+                  "xyz"     ).indent(2)
+  end
+
+  def test_0_indent
+    assert_equal 'xyz', 'xyz'.indent(0)
+  end
+
+  def test_negative_indent
+    assert_equal '  xyz', '    xyz'.indent(-2)
+    assert_equal 'xyz',   '  xyz'.  indent(-2)
+  end
+
+  def test_multi_line_negative_indent
+    assert_equal  "  abc\n" +
+                  "  xyz"   , 
+                 ("    abc\n"   +
+                  "    xyz"     ).indent(-2)
+  end
+
+  def test_outdent_is_alias_for_negative_indent
+    assert_equal 'xyz', '  xyz'.outdent(2)
+  end
+
+  def test_negative_indent_more_than_is_possible
+    assert_equal 'xyz', '  xyz'.indent(-3)
+  end
+
+  #-----------------------------------
+  # Using a character other than space
+
+  def test_nonspace_positive__indent
+    assert_equal '----xyz', "xyz".indent(4, '-')
+  end
+
+  def test_nonspace_0_indent
+    assert_equal 'xyz', 'xyz'.indent(0, '-')
+  end
+
+  def test_nonspace_negative_indent_nonmatching_character
+    assert_equal '    xyz', '    xyz'.indent(-2, '-')
+    assert_equal '  xyz',   '  xyz'.  indent(-2, '-')
+  end
+
+  def test_nonspace_negative_indent
+    assert_equal '--xyz', '----xyz'.indent(-2, '-')
+    assert_equal 'xyz',   '--xyz'.indent(-2, '-')
+  end
+
+  def test_special_regexp_characters_are_escaped
+    # make sure . is treated as a literal '.' and not an "any character" wildcard
+    assert_equal '  xyz', '  xyz'.indent(-2, '.')
+    assert_equal 'xyz',   '..xyz'.indent(-2, '.')
+
+    assert_equal '  xyz', '  xyz'.indent(-2, '^')
+    assert_equal 'xyz',   '^^xyz'.indent(-2, '^')
+
+    assert_equal '  xyz', '  xyz'.indent(-2, '*')
+    assert_equal 'xyz',   '**xyz'.indent(-2, '*')
+  end
 end
 

data/test/core/string/test_lines.rb

@@ -3,8 +3,9 @@ require 'test/unit'
 
 class TC_String_Lines < Test::Unit::TestCase
 
+  # Ruby 1.9 defined #lines to keep the newline character. Yuk!
   def test_lines
-    assert_equal( ["a","b",'c'], "a\nb\nc".lines.to_a )
+    assert_equal( ["a\n","b\n","c"], "a\nb\nc".lines.to_a )
   end
 
 end

data/test/core/string/test_newlines.rb

@@ -0,0 +1,13 @@
+require 'facets/string/newlines'
+require 'test/unit'
+
+class TC_String_NewLines < Test::Unit::TestCase
+
+  # Since Ruby 1.9 defined #lines to keep the newline character,
+  # we have defined #newlines to leave them out.
+  def test_newlines
+    assert_equal( ["a","b","c"], "a\nb\nc".newlines.to_a )
+  end
+
+end
+

data/test/core/time/test_change.rb

@@ -5,7 +5,7 @@ require 'time'
 class TC_Time_Change < Test::Unit::TestCase
 
   def test_change
-    t = Time.parse('4/20/2006 15:37')
+    t = Time.parse('2006-04-20 15:37')
     n = Time.now
     n = n.change( :month=>4, :day=>20, :hour=>15, :min=>37, :year=>2006 )
     assert_equal( t, n )

data/test/core/time/test_stamp.rb

@@ -4,11 +4,7 @@ require 'time'
 
 class TC_Time_Stamp < Test::Unit::TestCase
 
-  def setup
-
-  end
-
-  # TODO Problem with TIMEZONE.
+  # TODO: Problem with TIMEZONE.
 
   #def test_stamp_01
   #  t = Time.parse('4/20/2005 15:37')
@@ -16,13 +12,14 @@ class TC_Time_Stamp < Test::Unit::TestCase
   #end
 
   def test_stamp_02
-    t = Time.parse('4/20/2005 15:37')
+    t = Time.parse('2005-04-20 15:37')
     assert_equal( "April 20, 2005 15:37", t.stamp(:long) )
   end
 
   def test_stamp_03
-    t = Time.parse('4/20/2005 15:37')
+    t = Time.parse('2005-04-20 15:37')
     assert_equal( "20 Apr 15:37", t.stamp(:short) )
   end
 
 end
+