extensions 0.4.0 → 0.5.0

data/lib/extensions/object.rb

@@ -1,164 +1,164 @@
-#!/usr/local/bin/ruby -w
-
-#
-# == extensions/object.rb
-#
-# Adds methods to the builtin Object class.
-#
-
-require 'extensions/_base'
-
-
-#
-# Object#singleton_class
-#
-ExtensionsProject.implement(Object, :singleton_class) do
-  class Object
-    #
-    # Returns the singleton class associated with this object.  How useful this
-    # is I don't know, but it's an idiom that has appeared on ruby-talk several
-    # times.
-    #
-    def singleton_class
-      class << self
-        self
-      end
-    end
-  end
-end
-
-
-#
-# * Object.in?
-# This has special treatment: it's included here and in enumerable.rb, so we don't
-# want a warning if it's already defined.
-#
-unless Object.method_defined?(:in?)
-  ExtensionsProject.implement(Object, :in?) do
-    class Object
-      #
-      # Test this object for inclusion in a given collection.
-      #
-      #   45.in? (1...100)             => true
-      #
-      # This method is contained in <tt>object.rb</tt> and
-      # <tt>enumerable.rb</tt>, because it logically belongs in both.
-      #
-      def in?(enumerable)
-        enumerable.include?(self)
-      end
-    end
-  end
-end
-
-
-#
-# * Object.not_nil?
-#
-ExtensionsProject.implement(Object, :not_nil?) do
-  class Object
-    #
-    # The opposite of <tt>#nil?</tt>.
-    #
-    #   "hello".not_nil?      # -> true
-    #   nil.not_nil?          # -> false 
-    #
-    def not_nil?
-      not self.nil?
-    end
-  end
-end
-
-
-#
-# * Object.non_nil?
-#
-ExtensionsProject.implement(Object, :non_nil?) do
-  class Object
-    #
-    # The opposite of <tt>#nil?</tt>.
-    #
-    #   "hello".non_nil?      # -> true
-    #   nil.non_nil?          # -> false 
-    #
-    def non_nil?
-      not self.nil?
-    end
-  end
-end
-
-
-#
-# Object#pp_s
-#
-ExtensionsProject.implement(Object, :pp_s) do
-  require 'pp'
-  require 'stringio'
-  class Object
-    #
-    # Returns a pretty-printed string of the object.  Requires libraries +pp+ and
-    # +stringio+ from the Ruby standard library.
-    #
-    # The following code pretty-prints an object (much like +p+ plain-prints an
-    # object):
-    #
-    #   pp object
-    #
-    # The following code captures the pretty-printing in +str+ instead of
-    # sending it to +STDOUT+.
-    #
-    #   str = object.pp_s 
-    #
-    def pp_s
-      pps = StringIO.new
-      PP.pp(self, pps)
-      pps.string
-    end
-  end
-end
-
-#
-# Object#pp_s
-#
-ExtensionsProject.implement(Object, :define_method) do
-  class Object
-    #
-    # Defines a singleton method on the object.  For example, the following are
-    # equivalent (assume <tt>o = Object.new</tt>):
-    #
-    #   def o.add(x, y)
-    #     x + y
-    #   end
-    #
-    #   o.define_method(:add) do |x, y|
-    #     x + y
-    #   end
-    #
-    # The difference is that with <tt>define_method</tt>, you can use variables
-    # local to the _current_ scope.
-    #
-    #   x = 5 
-    #   o.define_method(:add_x) do |n|
-    #     x + n
-    #   end
-    #   o.add_x(11)          # -> 16
-    #
-    # You can't define such a method as <tt>add_x</tt> above with <tt>def
-    # o.add_x; x + n; end</tt>, as +def+ introduces a new scope.
-    #
-    # There are three ways to provide the body of the method: with a block (as
-    # in both examples above), or with a +Proc+ or +Method+ object.  See the
-    # built-in method <tt>Module#define_method</tt> for details.
-    #
-    # (This method is exactly equivalent to calling <tt>Module#define_method</tt>
-    # in the scope of the singleton class of the object.) 
-    #
-    def define_method(*args, &block)
-      singleton_class = class << self; self; end
-      singleton_class.module_eval do
-        define_method(*args, &block)
-      end
-    end
-  end
-end
-
+#!/usr/local/bin/ruby -w
+
+#
+# == extensions/object.rb
+#
+# Adds methods to the builtin Object class.
+#
+
+require 'extensions/_base'
+
+
+#
+# Object#singleton_class
+#
+ExtensionsProject.implement(Object, :singleton_class) do
+  class Object
+    #
+    # Returns the singleton class associated with this object.  How useful this
+    # is I don't know, but it's an idiom that has appeared on ruby-talk several
+    # times.
+    #
+    def singleton_class
+      class << self
+        self
+      end
+    end
+  end
+end
+
+
+#
+# * Object.in?
+# This has special treatment: it's included here and in enumerable.rb, so we don't
+# want a warning if it's already defined.
+#
+unless Object.method_defined?(:in?)
+  ExtensionsProject.implement(Object, :in?) do
+    class Object
+      #
+      # Test this object for inclusion in a given collection.
+      #
+      #   45.in? (1...100)             => true
+      #
+      # This method is contained in <tt>object.rb</tt> and
+      # <tt>enumerable.rb</tt>, because it logically belongs in both.
+      #
+      def in?(enumerable)
+        enumerable.include?(self)
+      end
+    end
+  end
+end
+
+
+#
+# * Object.not_nil?
+#
+ExtensionsProject.implement(Object, :not_nil?) do
+  class Object
+    #
+    # The opposite of <tt>#nil?</tt>.
+    #
+    #   "hello".not_nil?      # -> true
+    #   nil.not_nil?          # -> false 
+    #
+    def not_nil?
+      not self.nil?
+    end
+  end
+end
+
+
+#
+# * Object.non_nil?
+#
+ExtensionsProject.implement(Object, :non_nil?) do
+  class Object
+    #
+    # The opposite of <tt>#nil?</tt>.
+    #
+    #   "hello".non_nil?      # -> true
+    #   nil.non_nil?          # -> false 
+    #
+    def non_nil?
+      not self.nil?
+    end
+  end
+end
+
+
+#
+# Object#pp_s
+#
+ExtensionsProject.implement(Object, :pp_s) do
+  require 'pp'
+  require 'stringio'
+  class Object
+    #
+    # Returns a pretty-printed string of the object.  Requires libraries +pp+ and
+    # +stringio+ from the Ruby standard library.
+    #
+    # The following code pretty-prints an object (much like +p+ plain-prints an
+    # object):
+    #
+    #   pp object
+    #
+    # The following code captures the pretty-printing in +str+ instead of
+    # sending it to +STDOUT+.
+    #
+    #   str = object.pp_s 
+    #
+    def pp_s
+      pps = StringIO.new
+      PP.pp(self, pps)
+      pps.string
+    end
+  end
+end
+
+#
+# Object#pp_s
+#
+ExtensionsProject.implement(Object, :define_method) do
+  class Object
+    #
+    # Defines a singleton method on the object.  For example, the following are
+    # equivalent (assume <tt>o = Object.new</tt>):
+    #
+    #   def o.add(x, y)
+    #     x + y
+    #   end
+    #
+    #   o.define_method(:add) do |x, y|
+    #     x + y
+    #   end
+    #
+    # The difference is that with <tt>define_method</tt>, you can use variables
+    # local to the _current_ scope.
+    #
+    #   x = 5 
+    #   o.define_method(:add_x) do |n|
+    #     x + n
+    #   end
+    #   o.add_x(11)          # -> 16
+    #
+    # You can't define such a method as <tt>add_x</tt> above with <tt>def
+    # o.add_x; x + n; end</tt>, as +def+ introduces a new scope.
+    #
+    # There are three ways to provide the body of the method: with a block (as
+    # in both examples above), or with a +Proc+ or +Method+ object.  See the
+    # built-in method <tt>Module#define_method</tt> for details.
+    #
+    # (This method is exactly equivalent to calling <tt>Module#define_method</tt>
+    # in the scope of the singleton class of the object.) 
+    #
+    def define_method(*args, &block)
+      singleton_class = class << self; self; end
+      singleton_class.module_eval do
+        define_method(*args, &block)
+      end
+    end
+  end
+end
+