og 0.7.0 → 0.8.0

data/vendor/extensions/enumerable.rb

@@ -0,0 +1,250 @@
+#
+# == extensions/enumerable.rb
+#
+# Adds methods to the builtin Enumerable module. 
+#
+
+require "extensions/_base"
+
+#
+# * Enumerable#build_hash
+#
+ExtensionsProject.implement(Enumerable, :build_hash) do
+  module Enumerable
+    #
+    # Like <tt>#map</tt>/<tt>#collect</tt>, but it generates a Hash.  The block
+    # is expected to return two values: the key and the value for the new hash.
+    #   numbers  = (1..3)
+    #   squares  = numbers.build_hash { |n| [n, n*n] }   # 1=>1, 2=>4, 3=>9
+    #   sq_roots = numbers.build_hash { |n| [n*n, n] }   # 1=>1, 4=>2, 9=>3
+    #
+    def build_hash
+      result = {}
+      self.each do |elt|
+        key, value = yield elt
+        result[key] = value
+      end
+      result
+    end
+  end
+
+  # There was a bug in Hash which causes the above code to issue a warning when
+  # used with a Hash.  That was fixed on 2003-10-24.
+  if RUBY_RELEASE_DATE < "2003-10-25"
+    class Hash #:nodoc:
+      def build_hash
+        result = {}
+        self.each_pair do |k, v|
+          key, value = yield(k, v)
+          result[key] = value
+        end
+        result
+      end
+    end
+  end
+end
+
+
+#
+# Enumerable#mapf
+#
+ExtensionsProject.implement(Enumerable, :mapf) do
+  module Enumerable
+    #
+    # "map function"
+    #   enum.mapf(:x)
+    # is short for
+    #   enum.map { |elt| elt.x }
+    #
+    def mapf(message)
+      self.map { |elt| elt.send(message) }
+    end
+  end
+end
+
+
+#
+# Enumerable#collectf
+#
+ExtensionsProject.implement(Enumerable, :collectf) do
+  module Enumerable
+    alias collectf mapf
+  end
+end
+
+
+#
+# * Enumerable#includes?
+#
+ExtensionsProject.implement(Enumerable, :includes?) do
+  module Enumerable
+    alias includes? include?
+  end
+end
+
+
+#
+# * Enumerable#contains?
+#
+ExtensionsProject.implement(Enumerable, :contains?) do
+  module Enumerable
+    alias contains? include?
+  end
+end
+
+
+#
+# * Enumerable#has?
+#
+ExtensionsProject.implement(Enumerable, :has?) do
+  module Enumerable
+    alias has? include?
+  end
+end
+
+
+#
+# * Enumerable#map_with_index
+#
+ExtensionsProject.implement(Enumerable, :map_with_index) do
+  module Enumerable
+    #
+    # Same as Enumerable#map, but the index is yielded as well.  See
+    # Enumerable#each_with_index.
+    #   puts files.map_with_index { |fn, idx| "#{idx}. #{fn}" }
+    #   print "Please select a file (0-#{files.size}): "
+    #
+    def map_with_index
+      result = []
+      self.each_with_index do |elt, idx|
+        result << yield(elt, idx)
+      end
+      result
+    end
+  end
+end
+
+
+#
+# * Enumerable#collect_with_index
+#
+ExtensionsProject.implement(Enumerable, :collect_with_index) do
+  module Enumerable
+    alias  collect_with_index  map_with_index
+  end
+end
+
+
+#
+# * Enumerable#partition_by
+#
+ExtensionsProject.implement(Enumerable, :partition_by) do
+  module Enumerable
+    #
+    # See Enumerable#partition for the background.  #partition_by is best
+    # explained by example.
+    #
+    #   (1..5).partition_by { |n| n % 3 } 
+    #        # -> { 0 => [3], 1 => [1, 4], 2 => [2,5] } 
+    #
+    #   ["I had", 1, "dollar and", 50, "cents"].partition_by { |e| e.class }
+    #        # -> { String => ["I had","dollar and","cents"], Fixnum => [1,50] } 
+    #
+    # #partition_by is used to group items in a collection by something they
+    # have in common.  The common factor is the key in the resulting hash, the
+    # array of like elements is the value.
+    #
+    def partition_by
+      result = {}
+      self.each do |e|
+        value = yield e
+        (result[value] ||= []) << e
+      end
+      result
+    end
+  end
+end
+
+
+#
+# * Enumerable#none?
+#
+ExtensionsProject.implement(Enumerable, :none?) do
+  module Enumerable
+    #
+    # Enumerable#none? is the logical opposite of the builtin method Enumerable#any?.  It
+    # returns +true+ if and only if _none_ of the elements in the collection satisfy the
+    # predicate.
+    #
+    # If no predicate is provided, Enumerable#none? returns +true+ if and only if _none_ of the
+    # elements have a true value (i.e. not +nil+ or +false+).
+    #
+    #   [].none?                      # true
+    #   [nil].none?                   # true
+    #   [5,8,9].none?                 # false
+    #   (1...10).none? { |n| n < 0 }  # true
+    #   (1...10).none? { |n| n > 0 }  # false
+    #
+    def none?  # :yield: e
+      if block_given?
+        not self.any? { |e| yield e }
+      else
+        not self.any?
+      end
+    end
+  end
+end
+
+
+#
+# * Enumerable#one?
+#
+ExtensionsProject.implement(Enumerable, :one?) do
+  module Enumerable
+    #
+    # Enumerable#one? returns +true+ if and only if <em>exactly one</em> element in the
+    # collection satisfies the given predicate.
+    #
+    # If no predicate is provided, Enumerable#one? returns +true+ if and only if <em>exactly
+    # one</em> element has a true value (i.e. not +nil+ or +false+).
+    #
+    #   [].one?                      # false
+    #   [nil].one?                   # false
+    #   [5].one?                     # true
+    #   [5,8,9].one?                 # false
+    #   (1...10).one? { |n| n == 5 } # true
+    #   (1...10).one? { |n| n < 5 }  # false
+    #
+    def one?  # :yield: e
+      matches = 0
+      if block_given?
+        self.each do |e|
+          if yield(e)
+            matches += 1
+            return false if matches > 1
+          end
+        end
+        return (matches == 1)
+      else
+        one? { |e| e }
+      end
+    end
+  end
+end
+
+
+#
+# * Object.in?
+# This has special treatment: it's included here and in object.rb, so we don't
+# want a warning if it's alredy defined.
+#
+unless Object.method_defined?(:in?)
+  ExtensionsProject.implement(Object, :in?) do
+    class Object
+      def in?(enumerable) # :nodoc: It's documented in object.rb.
+        enumerable.include?(self)
+      end
+    end
+  end
+end
+

data/vendor/extensions/hash.rb

@@ -0,0 +1,23 @@
+#!/usr/local/bin/ruby -w
+#
+# == extensions/hash.rb
+#
+# Adds methods to the builtin Hash class. 
+#
+
+require "extensions/_base"
+
+#
+# * Hash#select!
+#
+ExtensionsProject.implement(Hash, :select!) do
+  class Hash
+    #
+    # In-place version of Hash#select.  (Counterpart to, and opposite of, the
+    # built-in #reject!)
+    #
+    def select!
+      reject! { |k,v| not yield(k,v) }
+    end
+  end
+end

data/vendor/extensions/io.rb

@@ -0,0 +1,58 @@
+#!/usr/local/bin/ruby -w
+
+#
+# == extensions/io.rb
+#
+# Adds methods to the builtin IO class.
+#
+
+require "extensions/_base"
+
+# This is Ruby's built-in IO class.
+class IO
+end
+
+#
+# * IO.write
+#
+ExtensionsProject.implement(IO, :write, :class) do
+  class << IO
+    #
+    # Writes the given data to the given path and closes the file.  This is
+    # done in binary mode, complementing <tt>IO.read</tt> in standard Ruby.
+    #
+    # Returns the number of bytes written.
+    #
+    def write(path, data)
+      File.open(path, "wb") do |file|
+        return file.write(data)
+      end
+    end
+  end
+end
+
+#
+# * IO.writelines
+#
+ExtensionsProject.implement(IO, :writelines, :class) do
+  class << IO
+    #
+    # Writes the given array of data to the given path and closes the file.
+    # This is done in binary mode, complementing <tt>IO.readlines</tt> in
+    # standard Ruby.
+    #
+    # Note that +readlines+ (the standard Ruby method) returns an array of lines
+    # <em>with newlines intact</em>, whereas +writelines+ uses +puts+, and so
+    # appends newlines if necessary.  In this small way, +readlines+ and
+    # +writelines+ are not exact opposites. 
+    #
+    # Returns +nil+. 
+    #
+    def writelines(path, data)
+      File.open(path, "wb") do |file|
+        file.puts(data)
+      end
+    end
+  end
+end
+

data/vendor/extensions/kernel.rb

@@ -0,0 +1,42 @@
+#!/usr/local/bin/ruby -w
+#
+# == extensions/module.rb
+#
+# Adds methods to the builtin Kernel module. 
+#
+
+require "extensions/_base"
+
+ExtensionsProject.implement(Kernel, :require_relative) do
+  module Kernel
+      #
+      # <tt>require_relative</tt> complements the builtin method <tt>require</tt> by allowing
+      # you to load a file that is <em>relative to the file containing the require_relative
+      # statement</em>.
+      #
+      # When you use <tt>require</tt> to load a file, you are usually accessing functionality
+      # that has been properly installed, and made accessible, in your system.  <tt>require</tt>
+      # does not offer a good solution for loading files within the project's code.  This may
+      # be useful during a development phase, for accessing test data, or even for accessing
+      # files that are "locked" away inside a project, not intended for outside use.
+      #
+      # For example, if you have unit test classes in the "test" directory, and data for them
+      # under the test "test/data" directory, then you might use a line like this in a test
+      # case:
+      #
+      #   require_relative "data/customer_data_1"
+      #
+      # Since neither "test" nor "test/data" are likely to be in Ruby's library path (and for
+      # good reason), a normal <tt>require</tt> won't find them.  <tt>require_relative</tt> is
+      # a good solution for this particular problem.
+      #
+      # You may include or omit the extension (<tt>.rb</tt> or <tt>.so</tt>) of the file you
+      # are loading.
+      #
+      # _path_ must respond to <tt>to_str</tt>.
+      #
+    def require_relative(path)
+      require File.join(File.dirname(caller[0]), path.to_str)
+    end
+  end
+end

data/vendor/extensions/module.rb

@@ -0,0 +1,114 @@
+#!/usr/local/bin/ruby -w
+#
+# == extensions/module.rb
+#
+# Adds methods to the builtin Module class. 
+#
+
+require "extensions/_base"
+
+ExtensionsProject.implement(Module, :deep_const_get) do
+  class Module
+    #
+    # Recursively dereferences constants separated by "<tt>::</tt>".
+    #
+    # _const_ is a Symbol or responds to #to_str, for compatibility with the builtin method
+    # <tt>Module#const_get</tt>.
+    #
+    #   Object.const_get("String")                    # -> String
+    #   Object.const_get(:String)                     # -> String
+    #
+    #   Object.deep_const_get("String")               # -> String
+    #   Object.deep_const_get(:String)                # -> String
+    #
+    #   Object.deep_const_get("Process::Sys")         # -> Process::Sys
+    #   Object.deep_const_get("Regexp::IGNORECASE")   # -> 1
+    #   Object.deep_const_get("Regexp::MULTILINE")    # -> 4
+    #
+    #   require 'test/unit'
+    #   Test.deep_const_get("Unit::Assertions")       # -> Test::Unit::Assertions
+    #   Test.deep_const_get("::Test::Unit")           # -> Test::Unit
+    #
+    # For resolving classes or modules based on their name, see Module.by_name, which uses this
+    # method.
+    #
+    def deep_const_get(const)
+      if Symbol === const
+        const = const.to_s
+      else
+        const = const.to_str.dup
+      end
+      if const.sub!(/^::/, '')
+        base = Object
+      else
+        base = self
+      end
+      const.split(/::/).inject(base) { |mod, name| mod.const_get(name) }
+    end
+  end
+end
+
+
+ExtensionsProject.implement(Module, :by_name, :class) do
+  class Module
+    #
+    # <em>Note: the following documentation uses "class" because it's more common, but it
+    # applies to modules as well.</em>
+    #
+    # Given the _name_ of a class, returns the class itself (i.e. instance of Class).  The
+    # dereferencing starts at Object.  That is,
+    #
+    #   Class.by_name("String")
+    #
+    # is equivalent to
+    #
+    #   Object.get_const("String")
+    #
+    # The parameter _name_ is expected to be a Symbol or String, or at least to respond to
+    # <tt>to_str</tt>.
+    #
+    # An ArgumentError is raised if _name_ does not correspond to an existing class.  If _name_
+    # is not even a valid class name, the error you'll get is not defined.
+    #
+    # Examples:
+    #
+    #   Class.by_name("String")             # -> String
+    #   Class.by_name("::String")           # -> String
+    #   Class.by_name("Process::Sys")       # -> Process::Sys
+    #   Class.by_name("GorillaZ")           # -> (ArgumentError)
+    #
+    #   Class.by_name("Enumerable")         # -> Enumerable
+    #   Module.by_name("Enumerable")        # -> Enumerable
+    #
+    def Module.by_name(name)
+      if Symbol === name
+        name = name.to_s
+      else
+        name = name.to_str
+      end
+      result = Object.deep_const_get(name)
+      if result.is_a? Module
+        return result
+      else
+        raise ArgumentError, "#{name} is not a class or module"
+      end
+    end
+  end
+end
+
+
+ExtensionsProject.implement(Module, :basename) do
+  class Module
+    #
+    # Returns the immediate name of the class/module, stripped of any containing classes or
+    # modules.  Compare Ruby's builtin methods <tt>Module#name</tt> and <tt>File.basename</tt>.
+    #
+    #   Process::Sys.name           # -> "Process::Sys"
+    #   Process::Sys.basename       # -> "Sys"
+    #   String.basename             # -> "String"
+    #
+    def basename
+      self.name.sub(/^.*::/, '')
+    end
+  end
+end