nitro 0.7.0 → 0.8.0

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

data/vendor/extensions/numeric.rb

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