og 0.12.0 → 0.13.0

data/vendor/extensions/kernel.rb

@@ -1,42 +0,0 @@
-#!/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

@@ -1,114 +0,0 @@
-#!/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

data/vendor/extensions/numeric.rb

@@ -1,230 +0,0 @@
-#!/usr/local/bin/ruby -w
-#
-# == extensions/integer.rb
-#
-# Adds methods to the builtin Numeric and Integer classes.
-#
-
-require "extensions/_base"
-
-#
-# * Integer#even?
-#
-ExtensionsProject.implement(Integer, :even?) do
-  class Integer
-    #
-    # Returns true if this integer is even, false otherwise.
-    #   14.even?          # -> true
-    #   15.even?          # -> false
-    #
-    def even?
-      self % 2 == 0
-    end
-  end
-end
-
-
-#
-# * Integer#odd?
-#
-ExtensionsProject.implement(Integer, :odd?) do
-  class Integer
-    #
-    # Returns true if this integer is odd, false otherwise.
-    #   -99.odd?          # -> true
-    #   -98.odd?          # -> false
-    #
-    def odd?
-      self % 2 == 1
-    end
-  end
-end
-
-#
-# This code arose from discussions with Francis Hwang.  Leaving it here for future work.
-#
-#   class Numeric
-#     def precision_format(nplaces, flag = :pad)
-#       format = "%.#{nplaces}f"
-#       result = sprintf(format, self)
-#       case flag
-#       when :pad
-#       when :nopad
-#         result.sub!(/\.?0*$/, '')
-#       else
-#         raise ArgumentError, "Invalid value for flag: #{flag.inspect}"
-#       end
-#       result
-#     end
-#   end
-#
-#   100.precision_format(2)                 # -> "100.00"
-#   100.precision_format(2, :nopad)         # -> "100"
-#   100.1.precision_format(2)               # -> "100.10"
-#   100.1.precision_format(2, :nopad)       # -> "100.1"
-#   100.1.precision_format(2, false)
-#         # -> "ArgumentError: Invalid value for flag: false"
-#
-
-
-ExtensionsProject.implement(Numeric, :format_s) do
-  #--
-  # Copyright � 2003 Austin Ziegler
-  #
-  # Permission is hereby granted, free of charge, to any person obtaining a copy
-  # of this software and associated documentation files (the "Software"), to
-  # deal in the Software without restriction, including without limitation the
-  # rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-  # sell copies of the Software, and to permit persons to whom the Software is
-  # furnished to do so, subject to the following conditions:
-  # 
-  # The above copyright notice and this permission notice shall be included in
-  # all copies or substantial portions of the Software.
-  #
-  # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-  # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-  # IN THE SOFTWARE.
-  #++
-  class Numeric
-    #
-    # Provides the base formatting styles for #format_s. See #format_s for
-    # more details. Two keys provided that are not supported in the
-    # #format_s arguments are:
-    #
-    # <tt>:style</tt>:: Allows a style to inherit from other styles. Styles
-    #                   will be applied in oldest-first order in the event
-    #                   of multiple inheritance layers.
-    # <tt>:id</tt>::    This must be provided on any default style created
-    #                   or provided so as to provide a stop marker so that
-    #                   recursive styles do not result in an infinite loop.
-    #
-    # This is an implementation detail, not important for users of the class.
-    #
-    FORMAT_STYLES = {
-      :us       => { :sep => ',', :dec => '.', :id => :us },
-      :usd      => { :style => :us, :currency => { :id => "$", :pos => :before }, :id => :usd },
-      :eu       => { :sep => ' ', :dec => ',', :id => :us },
-      :euro     => { :style => :eu, :currency => { :id => "�", :pos => :before }, :id => :euro },
-      :percent  => { :style => :us, :currency => { :id => "%%", :pos => :after }, :id => :percent }
-    }
-
-    #
-    # Format a number as a string, using US or European conventions, and
-    # allowing for the accounting format of representing negative numbers.
-    # Optionally, currency formatting options can be provided.
-    #
-    # For example:
-    #   x = -10259.8937
-    #   x.format_s                         # => "-10,259.8937"
-    #   x.format_s(:us)                    # => "-10,259.8937" 
-    #   x.format_s(:usd)                   # => "$-10,259.8937"
-    #   x.format_s(:eu)                    # => "-10 259,8937" 
-    #   x.format_s(:euro)                  # => "�-10 259,8937"
-    #   x.format_s(:us, :acct => true)     # => "(10,259.8937)"
-    #   x.format_s(:eu, :acct => true)     # => "(10 259,8937)"
-    #   x.format_s(:usd, :acct => true)    # => "$(10,259.8937)"
-    #   x.format_s(:euro, :acct => true)   # => "�(10 259,8937)"
-    #   x.format_s(:percent)               # => "-10,259.8937%"
-    #
-    # You may configure several aspects of the formatting by providing keyword
-    # arguments after the country and accounting arguments. One example of that
-    # is the :acct keyword. A more insane example is:
-    #
-    #   x = -10259.8937
-    #   x.format_s(:us,
-    #              :sep => ' ', :dec => ',',
-    #              :neg => '<%s>', :size => 2, 
-    #              :fd => true)                    # -> "<1 02 59,89 37>"
-    # 
-    # The keyword parameters are as follows:
-    #
-    # <tt>:acct</tt>::      If +true+, then use accounting style for negative
-    #                       numbers. This overrides any value for
-    #                       <tt>:neg</tt>.
-    # <tt>:sep</tt>::       Default "," for US, " " for Euro. Separate the
-    #                       number groups from each other with this string.
-    # <tt>:dec</tt>::       Default "." for US, "," for Euro. Separate the
-    #                       number's integer part from the fractional part
-    #                       with this string.
-    # <tt>:neg</tt>::       Default <tt>"-%s"</tt>. The format string used to
-    #                       represent negative numbers. If <tt>:acct</tt> is
-    #                       +true+, this is set to <tt>"(%s)"</tt>.
-    # <tt>:size</tt>::      The number of digits per group. Defaults to
-    #                       thousands (3).
-    # <tt>:fd</tt>::        Indicates whether the decimal portion of the
-    #                       number should be formatted the same way as the
-    #                       integer portion of the number. ("fd" == "format
-    #                       decimal".) Defaults to +false+.
-    # <tt>:currency</tt>::  This is an optional hash with two keys,
-    #                       <tt>:id</tt> and <tt>:pos</tt>. <tt>:id</tt> is
-    #                       the string value of the currency (e.g.,
-    #                       <tt>"$"</tt>, <tt>"�"</tt>, <tt>"USD&nbsp;"</tt>);
-    #                       <tt>:pos</tt> is either <tt>:before</tt> or
-    #                       <tt>:after</tt>, referring to the position of the
-    #                       currency indicator. The default <tt>:pos</tt> is
-    #                       <tt>:before</tt>.
-    #
-    def format_s(style = :us, configs={})
-      style = FORMAT_STYLES[style].dup # Adopt US style by default.
-
-        # Deal with recursive styles.
-      if style[:style]
-        styles = []
-        s = style
-        while s[:style]
-          s = FORMAT_STYLES[s[:style]].dup
-          styles << s
-          break if s[:style] = s[:id]
-        end
-        styles.reverse_each { |s| style.merge!(s)  }
-      end
-        # Merge the configured style.
-      style.merge!(configs)
-
-      sm = style[:sep] || ','
-      dp = style[:dec] || '.'
-      if style[:acct]
-        fmt = '(%s)'
-      else
-        fmt = style[:neg] || '-%s'
-      end
-      sz = style[:size] || 3
-      format_decimal = style[:fd]
-      ng = (self < 0)
-      fmt = "%s" if not ng
-
-      dec, frac = self.abs.to_s.split(/\./)
-
-      dec.reverse!
-      dec.gsub!(/\d{#{sz}}/) { |m| "#{m}#{sm}" }
-      dec.gsub!(/#{sm}$/, '')
-      dec.reverse!
-
-      if format_decimal and not frac.nil?
-        frac.gsub!(/\d{#{sz}}/) { |m| "#{m}#{sm}" }
-        frac.gsub!(/#{sm}$/, '')
-      end
-
-      if frac.nil?
-        val = dec
-      else
-        val = "#{dec}#{dp}#{frac}"
-      end
-
-      if style[:currency]
-        if style[:currency][:pos].nil? or style[:currency][:pos] == :before
-          fmt = "#{style[:currency][:id]}#{fmt}"
-        elsif style[:currency][:pos] == :after
-          fmt = "#{fmt}#{style[:currency][:id]}"
-        end
-      end
-
-      fmt % val
-    end
-  end  # class Numeric
-end  # ExtensionsProject.implement
-

data/vendor/extensions/object.rb

@@ -1,164 +0,0 @@
-#!/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
-