facets 2.6.0 → 2.7.0

data/lib/core/facets/unboundmethod/name.rb

@@ -1,27 +1,24 @@
-if RUBY_VERSION < '1.9'
+class UnboundMethod
 
-  class UnboundMethod
+  # Return the name of the method.
+  #
+  # Be aware that in ruby 1.9 UnboundMethod#name is defined already,
+  # but it returns a Symbol not a String.
+  #
+  #   class X
+  #     def foo; end
+  #   end
+  #
+  #   meth = X.instance_method(:foo)
+  #
+  #   meth.name  #=> "foo"
+  #
+  # CREDIT: Trans
 
-    # Return the name of the method.
-    #
-    # Be aware that in ruby 1.9 UnboundMethod#name is defined already,
-    # but it returns a Symbol not a String.
-    #
-    #   class X
-    #     def foo; end
-    #   end
-    #
-    #   meth = X.instance_method(:foo)
-    #
-    #   meth.name  #=> "foo"
-    #
-    # CREDIT: Trans
-
-    def name
-      i = to_s.rindex('#')
-      to_s.slice(i+1...-1)
-    end
-
-  end
+  def name
+    i = to_s.rindex('#')
+    to_s.slice(i+1...-1)
+  end unless method_defined?(:name) # 1.8.7+
 
 end
+

data/lib/more/facets/ansicode.rb

@@ -1,7 +1,7 @@
 # = ANSICode
 #
 # Module which makes it very easy to use ANSI codes.
-# These are esspecially nice for beautifying shell output.
+# These are especially nice for beautifying shell output.
 #
 #   include ANSICode
 #
@@ -78,15 +78,6 @@
 # == Copying
 #
 # Copyright (c) 2004 Florian Frank, Thomas Sawyer
-#
-# Ruby License
-#
-# This module is free software. You may use, modify, and/or redistribute this
-# software under the same terms as Ruby.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE.
 
 
 # = ANSICode

data/lib/more/facets/autoarray.rb

@@ -1,34 +1,6 @@
-# = AutoArray
-#
-# An Array that automatically expands dimensions as needed.
-#
-#   a  = Autoarray.new
-#   a[1][2][3] = 12
-#   a             #=> [nil, [nil, nil, [nil, nil, nil, 12]]]
-#   a[2][3][4]    #=> []
-#   a             #=> [nil, [nil, nil, [nil, nil, nil, 12]]]
-#   a[1][-2][1] = "Negative"
-#   a             #=> [nil, [nil, [nil, "Negative"], [nil, nil, nil, 12]]]
-#
-# == Authors
-#
-# * Brian Schröder
-#
-# == License
-#
-#   Copyright (c) 2005 Brian Schröder
-#
-#   Ruby License
-#
-#   This module is free software. You may use, modify, and/or redistribute this
-#   software under the same terms as Ruby.
-#
-#   This program is distributed in the hope that it will be useful, but WITHOUT
-#   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-#   FOR A PARTICULAR PURPOSE.
+# AutoArray
+# Copyright (c) 2005 Brian Schröder
 
-# = AutoArray
-#
 # An Array that automatically expands dimensions as needed.
 #
 #   a  = Autoarray.new
@@ -39,7 +11,7 @@
 #   a[1][-2][1] = "Negative"
 #   a             #=> [nil, [nil, [nil, "Negative"], [nil, nil, nil, 12]]]
 #
-class Autoarray < Array
+class AutoArray < Array
 
   def initialize(size=0, default=nil, update = nil, update_index = nil)
     super(size, default)

data/lib/more/facets/basicobject.rb

@@ -0,0 +1,73 @@
+# Facets' BasicObject is an implementation of Jim Weirich's BlankSlate.
+#
+# BlankSlate
+# Copyright 2004 by Jim Weirich (jim@weirichhouse.org).
+# All rights reserved.
+#
+# Since Ruby 1.9 has a BasicObject class this will of course be 
+# deprecated as 1.9 goes mainstream.
+
+unless defined? BasicObject  # just in case it already exists!
+
+  # BasicObject provides an abstract base class with no predefined
+  # methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
+  # BlankSlate is useful as a base class when writing classes that
+  # depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
+  class BasicObject
+    class << self
+
+      # Hide the method named +name+ in the BlankSlate class.  Don't
+      # hide +instance_eval+ or any method beginning with "__".
+      def hide(name)
+        undef_method name if
+        instance_methods.include?(name.to_s) and
+        name !~ /^(__|instance_eval)/
+      end
+    end
+
+    instance_methods.each { |m| hide(m) }
+  end
+
+
+  # Since Ruby is very dynamic, methods added to the ancestors of
+  # BlankSlate <em>after BlankSlate is defined</em> will show up in the
+  # list of available BlankSlate methods.  We handle this by defining a
+  # hook in the Object and Kernel classes that will hide any defined
+  module Kernel #:nodoc:
+    class << self
+      alias_method :blank_slate_method_added, :method_added
+
+      # Detect method additions to Kernel and remove them in the
+      # BlankSlate class.
+      def method_added(name)
+        blank_slate_method_added(name)
+        return if self != Kernel
+        BlankSlate.hide(name)
+      end
+    end
+  end
+
+  class Object #:nodoc:
+    class << self
+      alias_method :blank_slate_method_added, :method_added
+
+      # Detect method additions to Object and remove them in the
+      # BlankSlate class.
+      def method_added(name)
+        blank_slate_method_added(name)
+        return if self != Object
+        BlankSlate.hide(name)
+      end
+    end
+  end
+
+end
+
+unless defined? BlankSlate
+
+  # ActiveSupport compatiable version of BasicObject
+  # if not Ruby 1.9+ uses Jim Weirich's BlankSlate.
+  BlankSlate = BasicObject
+
+end
+

data/lib/more/facets/blankslate.rb

@@ -1,66 +1,2 @@
-#!/usr/bin/env ruby
-#--
-# Copyright 2004 by Jim Weirich (jim@weirichhouse.org).
-# All rights reserved.
-
-# Permission is granted for use, copying, modification, distribution,
-# and distribution of modified versions of this work as long as the
-# above copyright notice is included.
-#++
-
-unless defined? BlankSlate
-
-  # BlankSlate provides an abstract base class with no predefined
-  # methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
-  # BlankSlate is useful as a base class when writing classes that
-  # depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
-  class BlankSlate
-    class << self
-
-      # Hide the method named +name+ in the BlankSlate class.  Don't
-      # hide +instance_eval+ or any method beginning with "__".
-      def hide(name)
-        undef_method name if
-        instance_methods.include?(name.to_s) and
-        name !~ /^(__|instance_eval)/
-      end
-    end
-
-    instance_methods.each { |m| hide(m) }
-  end
-
-
-  # Since Ruby is very dynamic, methods added to the ancestors of
-  # BlankSlate <em>after BlankSlate is defined</em> will show up in the
-  # list of available BlankSlate methods.  We handle this by defining a
-  # hook in the Object and Kernel classes that will hide any defined
-  module Kernel #:nodoc:
-    class << self
-      alias_method :blank_slate_method_added, :method_added
-
-      # Detect method additions to Kernel and remove them in the
-      # BlankSlate class.
-      def method_added(name)
-        blank_slate_method_added(name)
-        return if self != Kernel
-        BlankSlate.hide(name)
-      end
-    end
-  end
-
-  class Object #:nodoc:
-    class << self
-      alias_method :blank_slate_method_added, :method_added
-
-      # Detect method additions to Object and remove them in the
-      # BlankSlate class.
-      def method_added(name)
-        blank_slate_method_added(name)
-        return if self != Object
-        BlankSlate.hide(name)
-      end
-    end
-  end
-
-end
-
+warn "Use BasicObject instead of BlankSlate for future versions."
+require 'facets/basicobject'

data/lib/more/facets/class_extend.rb

@@ -0,0 +1 @@
+require 'facets/module/class_extend'

data/lib/{lore → more}/facets/date.rb

@@ -48,7 +48,7 @@ class Date
   # on conversions. In this case, it simply returns +self+.
   def to_date
     self
-  end if RUBY_VERSION < '1.9'
+  end unless method_defined?(:to_date) # 1.9+ ?
 
   # Converts a Date instance to a DateTime, where the time is set to the beginning of the day
   # and UTC offset is set to 0.
@@ -59,7 +59,7 @@ class Date
   #   date.to_datetime               # => Sat, 10 Nov 2007 00:00:00 0000
   def to_datetime
     ::DateTime.civil(year, month, day, 0, 0, 0, 0)
-  end if RUBY_VERSION < '1.9'
+  end unless method_defined?(:to_datetime) # 1.9+ ?
 
   # Converts a Date instance to a Time, where the time is set to the beginning of the day.
   # The timezone can be either :local or :utc (default :local).
@@ -327,7 +327,7 @@ class DateTime
   # Converts datetime to an appropriate format for use in XML
   def xmlschema
     strftime("%Y-%m-%dT%H:%M:%S%Z")
-  end if RUBY_VERSION < '1.9'
+  end unless method_defined?(:xmlschema) # 1.9+ ?
 
   # Converts self to a floating-point number of seconds since the Unix epoch 
   def to_f

data/lib/more/facets/enumargs.rb

@@ -0,0 +1,192 @@
+# Enumerable::Arguments
+#
+# Copyright (c) 2004 Thomas Sawyer
+#
+# LGPL(3) License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+
+require 'facets/enumerator'
+
+# This is a simple reimplementation of the core Enumerable module
+# to allow the methods to take and pass-on arbitrary arguments to the
+# underlying #each call. This library uses Enumerator and scans
+# Enumerable so it can alwasy stay in sync.
+#
+# NOTE Any Enumerable method with a negative arity cannot do pass arguments
+# due to ambiguity in the argument count. So the methods #inject and #zip
+# do NOT work this way, but simply work as they do in Enumerable.
+# The method #find (and #detect) though has been made to work by removing
+# its rarely used optional parameter and providing instead an optional
+# keyword parameter (:ifnone => ...). Please keep these difference in mind.
+#
+#   require 'enumargs'
+#
+#   class T
+#     include Enumerable::Arguments
+#     def initialize(arr)
+#       @arr = arr
+#     end
+#     def each(n)
+#       arr.each{ |e| yield(e+n) }
+#     end
+#   end
+#
+#   t = T.new([1,2,3])
+#   t.collect(4)
+#   #=> [5,6,7]
+#
+module Enumerable
+module Arguments
+
+  def self.wrap_enumerable_method( methodname )
+
+    m = methodname
+    meth = Enumerable.instance_method(m)
+    arity = meth.arity
+
+    case arity <=> 0
+    when 0
+      class_eval %{
+        def #{m}( *args, &yld )
+          enum_for(:each, *args).#{m}( &yld )
+        end
+      }
+    when 1
+      class_eval %{
+        def #{m}( *args, &yld )
+          args, each_args = args[0...#{arity}], args[#{arity}..-1]
+          enum_for(:each, *each_args).#{m}( *args, &yld )
+        end
+      }
+    else
+      class_eval %{
+        def #{m}( *args, &yld )
+          enum_for(:each).#{m}( *args, &yld )
+        end
+      }
+    end
+  end
+
+  Enumerable.instance_methods(false).each do |m|
+    wrap_enumerable_method( m )
+  end
+
+  #
+  def to_a(*args)
+    map(*args){ |x| x }
+  end
+
+  # Make exception for #find (a negative arity method) to accept
+  # keyword argument.
+  #
+  #   ObjectSpace.find(Class, :ifnone=>lambda{1}) { |e| ... }
+  #   ObjectSpace.find(Class, :ifnone=>lambda{1}) { |e| ... }
+  #
+  def find(*args, &yld)  # future use **keys ?
+    if Hash === args.last and args.last.key?(:ifnone)
+      ifnone = args.last.delete(:ifnone)
+      args.pop if args.last.empty?
+      enum_for(:each, *args).find( ifnone, &yld )
+    else
+      enum_for(:each, *args).find( &yld )
+    end
+  end
+  alias_method :detect, :find
+
+end
+end
+
+
+=begin  OLD CODE
+module EnumerableArgs
+
+  def collect(*args)  # :yield:
+    a = []
+    each(*args){ |n| a << yield(n) }
+    a
+  end
+  alias_method( :map, :collect )
+
+  def detect(*args)  # :yield:
+    each(*args){ |n| return n if yield(n) }
+    nil
+  end
+  alias_method( :find, :detect )
+
+  def each_with_index(*args)
+    i=0
+    each(*args){ |*n| n << i; yield(*n); i+=1 }
+    self
+  end
+
+  def to_a(*args)
+    a = []
+    each(*args){ |n| a << n }
+    a
+  end
+  alias_method( :entries, :to_a )
+
+  # An additional method not part of standard Enumerable.
+  # The regular version of this method can be found in Facets,
+  # but it is a bit more advanced then this one.
+  # At some point they need to be put into sync.
+  def each_slice(*args, &yld)
+    a = []; s = []
+    ar = yld.arity.abs
+    each(*args){ |n|
+      s << n
+      if s.length >= ar
+        yld.call(*s)
+        s = []
+      end
+    }
+    a
+  end
+  alias_method( :each_by, :each_slice )
+
+  def select(*args)  # :yield:
+    a = []
+    each(*args){ |n| a << n if yield(n) }
+    a
+  end
+  alias_method( :find_all, :select )
+
+  def grep(pattern, *args)
+    a = []
+    each(*args){ |n| a << (block_given? ? yield(n) : n) if pattern === n }
+    a
+  end
+
+  def include?(anObj, *args)
+    each(*args){ |n| return true if anObj == n }
+    false
+  end
+  alias_method( :member?, :include? )
+
+  def max(*args)
+    to_a(*args).max
+  end
+
+  def min(*args)
+    to_a(*args).min
+  end
+
+  def reject(*args)
+    a = []
+    each(*args){ |n| a << n if ! yield(n) }
+    a
+  end
+
+  def sort(*args)
+    # TODO
+  end
+
+end
+=end
+