rango 0.0.4 → 0.0.6

data/vendor/extlib/benchmarks/camel_case.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+require "rubygems"
+require "rbench"
+
+require "pathname"
+
+class String
+  ##
+  # @return <String> The string converted to camel case.
+  #
+  # @example
+  #   "foo_bar".camel_case #=> "FooBar"
+  def camel_case
+    return self if self !~ /_/ && self =~ /[A-Z]+.*/
+    split('_').map{|e| e.capitalize}.join
+  end
+
+  # By default, camelize converts strings to UpperCamelCase.
+  #
+  # camelize will also convert '/' to '::' which is useful for converting paths to namespaces
+  #
+  # @example
+  #   "active_record".camelize #=> "ActiveRecord"
+  #   "active_record/errors".camelize #=> "ActiveRecord::Errors"
+  #
+  def camelize
+    self.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+  end
+end # class String
+
+
+
+# It's not really fair to compare the two but
+# Extlib has no direct equivalent to String#camel_case.
+RBench.run(10_000) do
+  report "String#camelize" do
+    "underscore_string".camelize
+    "a_bit_longer_underscore_string".camelize
+  end
+
+  report "String#camel_case" do
+    "underscore_string".camel_case
+    "a_bit_longer_underscore_string".camel_case
+  end
+end

data/vendor/extlib/benchmarks/to_const_path.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+require "rubygems"
+require "rbench"
+
+class String
+  ##
+  # @return <String> The string converted to snake case.
+  #
+  # @example
+  #   "FooBar".snake_case #=> "foo_bar"
+  # @example
+  #   "HeadlineCNNNews".snake_case #=> "headline_cnn_news"
+  # @example
+  #   "CNN".snake_case #=> "cnn"
+  def snake_case
+    return self.downcase if self =~ /^[A-Z]+$/
+    self.gsub(/([A-Z]+)(?=[A-Z][a-z]?)|\B[A-Z]/, '_\&') =~ /_*(.*)/
+      return $+.downcase
+  end
+
+  ##
+  # @return <String>
+  #   The path that is associated with the constantized string, assuming a
+  #   conventional structure.
+  #
+  # @example
+  #   "FooBar::Baz".to_const_path # => "foo_bar/baz"
+  def to_const_path
+    snake_case.gsub(/::/, "/")
+  end
+
+  # The reverse of +camelize+. Makes an underscored form from the expression in the string.
+  #
+  # Changes '::' to '/' to convert namespaces to paths.
+  #
+  # @example
+  #   "ActiveRecord".underscore #=> "active_record"
+  #   "ActiveRecord::Errors".underscore #=> active_record/errors
+  #
+  def underscore
+    self.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+  end
+end # class String
+
+
+RBench.run(10_000) do
+  report "String#underscore" do
+    "CamelCaseString".underscore
+    "SomeABitLongerCamel::CaseString".underscore
+  end
+
+  report "String#to_const_path" do
+    "CamelCaseString".to_const_path
+    "SomeABitLongerCamel::CaseString".to_const_path
+  end
+
+  report "String#snake_case" do
+    "CamelCaseString".snake_case
+    "SomeABitLongerCamelCaseString".snake_case
+  end
+end

data/vendor/extlib/benchmarks/to_const_string.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+require "rubygems"
+require "rbench"
+
+class String
+  ##
+  # @return <String> The path string converted to a constant name.
+  #
+  # @example
+  #   "merb/core_ext/string".to_const_string #=> "Merb::CoreExt::String"
+  def to_const_string
+    gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+  end
+end # class String
+
+
+# The original of this file was copied for the ActiveSupport project which is
+# part of the Ruby On Rails web-framework (http://rubyonrails.org)
+#
+# Methods have been modified or removed. English inflection is now provided via
+# the english gem (http://english.rubyforge.org)
+#
+# sudo gem install english
+#
+gem 'english', '~>0.3.1'
+require 'english/inflect'
+
+module Extlib
+  module Inflection
+    class << self
+      # Take an underscored name and make it into a camelized name
+      #
+      # @example
+      #   "egg_and_hams".classify #=> "EggAndHam"
+      #   "post".classify #=> "Post"
+      #
+      def classify(name)
+        camelize(singularize(name.to_s.sub(/.*\./, '')))
+      end
+
+      # By default, camelize converts strings to UpperCamelCase.
+      #
+      # camelize will also convert '/' to '::' which is useful for converting paths to namespaces
+      #
+      # @example
+      #   "active_record".camelize #=> "ActiveRecord"
+      #   "active_record/errors".camelize #=> "ActiveRecord::Errors"
+      #
+      def camelize(lower_case_and_underscored_word, *args)
+        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+      end
+
+      # The reverse of +camelize+. Makes an underscored form from the expression in the string.
+      #
+      # Changes '::' to '/' to convert namespaces to paths.
+      #
+      # @example
+      #   "ActiveRecord".underscore #=> "active_record"
+      #   "ActiveRecord::Errors".underscore #=> active_record/errors
+      #
+      def underscore(camel_cased_word)
+        camel_cased_word.to_s.gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase
+      end
+
+      def singularize(word)
+        English::Inflect.singular(word)
+      end
+
+      def pluralize(word)
+        English::Inflect.plural(word)
+      end
+    end
+  end # module Inflection
+end # module Extlib
+
+
+RBench.run(10_000) do
+  report "Extlib::Inflection.camelize" do
+    Extlib::Inflection.classify("some/hypothetic/module")
+    Extlib::Inflection.classify("just_a_module")
+  end
+
+  report "String#to_const_string" do
+    "some/hypothetic/module".to_const_string
+    "just_a_module".to_const_string
+  end
+end

data/vendor/extlib/lib/extlib.rb

@@ -0,0 +1,50 @@
+require 'pathname'
+
+# for Pathname /
+require 'extlib/pathname'
+require 'extlib/class.rb'
+require 'extlib/object'
+require 'extlib/object_space'
+require 'extlib/array'
+require 'extlib/string'
+require 'extlib/symbol'
+require 'extlib/hash'
+require 'extlib/mash'
+require 'extlib/virtual_file'
+require 'extlib/logger'
+require 'extlib/time'
+require 'extlib/datetime'
+require 'extlib/assertions'
+require 'extlib/blank'
+require 'extlib/boolean'
+require 'extlib/byte_array'
+require 'extlib/inflection'
+require 'extlib/lazy_array'
+require 'extlib/module'
+require 'extlib/nil'
+require 'extlib/numeric'
+require 'extlib/blank'
+require 'extlib/simple_set'
+require 'extlib/struct'
+require 'extlib/symbol'
+
+Extlib.autoload('Hook', 'extlib/hook')
+Extlib.autoload('Pooling', 'extlib/pooling')
+
+module Extlib
+
+  def self.exiting= bool
+    if bool && Extlib.const_defined?('Pooling')
+      if Extlib::Pooling.scavenger?
+        Extlib::Pooling.scavenger.wakeup
+      end
+    end
+    @exiting = true
+  end
+
+  def self.exiting
+    return @exiting if defined?(@exiting)
+    @exiting = false
+  end
+
+end

data/vendor/extlib/lib/extlib/array.rb

@@ -0,0 +1,36 @@
+class Array
+
+  ##
+  # Transforms an Array of key/value pairs into a Hash
+  #
+  # This is a better idiom than using Hash[*array.flatten] in Ruby 1.8.6
+  # because it is not possible to limit the flattening to a single
+  # level.
+  #
+  # @return [Hash]
+  #   A Hash where each entry in the Array is turned into a key/value
+  #
+  # @api public
+  def to_hash
+    h = {}
+    each { |k,v| h[k] = v }
+    h
+  end
+
+  ##
+  # Transforms an Array of key/value pairs into a Mash
+  #
+  # This is a better idiom than using Mash[*array.flatten] in Ruby 1.8.6
+  # because it is not possible to limit the flattening to a single
+  # level.
+  #
+  # @return [Mash]
+  #   A Hash where each entry in the Array is turned into a key/value
+  #
+  # @api public
+  def to_mash
+    m = Mash.new
+    each { |k,v| m[k] = v }
+    m
+  end
+end # class Array

data/vendor/extlib/lib/extlib/assertions.rb

@@ -0,0 +1,8 @@
+module Extlib
+  module Assertions
+    def assert_kind_of(name, value, *klasses)
+      klasses.each { |k| return if value.kind_of?(k) }
+      raise ArgumentError, "+#{name}+ should be #{klasses.map { |k| k.name } * ' or '}, but was #{value.class.name}", caller(2)
+    end
+  end
+end

data/vendor/extlib/lib/extlib/blank.rb

@@ -0,0 +1,89 @@
+class Object
+  ##
+  # Returns true if the object is nil or empty (if applicable)
+  #
+  #   [].blank?         #=>  true
+  #   [1].blank?        #=>  false
+  #   [nil].blank?      #=>  false
+  #
+  # @return [TrueClass, FalseClass]
+  #
+  # @api public
+  def blank?
+    nil? || (respond_to?(:empty?) && empty?)
+  end
+end # class Object
+
+class Numeric
+  ##
+  # Numerics are never blank
+  #
+  #   0.blank?          #=>  false
+  #   1.blank?          #=>  false
+  #   6.54321.blank?    #=>  false
+  #
+  # @return [FalseClass]
+  #
+  # @api public
+  def blank?
+    false
+  end
+end # class Numeric
+
+class NilClass
+  ##
+  # Nil is always blank
+  #
+  #   nil.blank?        #=>  true
+  #
+  # @return [TrueClass]
+  #
+  # @api public
+  def blank?
+    true
+  end
+end # class NilClass
+
+class TrueClass
+  ##
+  # True is never blank.
+  #
+  #   true.blank?       #=>  false
+  #
+  # @return [FalseClass]
+  #
+  # @api public
+  def blank?
+    false
+  end
+end # class TrueClass
+
+class FalseClass
+  ##
+  # False is always blank.
+  #
+  #   false.blank?      #=>  true
+  #
+  # @return [TrueClass]
+  #
+  # @api public
+  def blank?
+    true
+  end
+end # class FalseClass
+
+class String
+  ##
+  # Strips out whitespace then tests if the string is empty.
+  #
+  #   "".blank?         #=>  true
+  #   "     ".blank?    #=>  true
+  #   " hey ho ".blank? #=>  false
+  #
+  # @return [TrueClass, FalseClass]
+  #
+  # @api public
+  def blank?
+    strip.empty?
+  end
+end # class String

data/vendor/extlib/lib/extlib/boolean.rb

@@ -0,0 +1,11 @@
+class TrueClass
+  def try_dup
+    self
+  end
+end
+
+class FalseClass
+  def try_dup
+    self
+  end
+end

data/vendor/extlib/lib/extlib/byte_array.rb

@@ -0,0 +1,6 @@
+# This class has exists to represent binary data. This is mainly
+# used by DataObjects. Binary data sometimes needs to be quoted differently
+# than regular string data (even if the string is just plain ASCII).
+module Extlib
+  class ByteArray < ::String; end
+end

data/vendor/extlib/lib/extlib/class.rb

@@ -0,0 +1,177 @@
+# Copyright (c) 2004-2008 David Heinemeier Hansson
+#
+# 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.
+
+# Allows attributes to be shared within an inheritance hierarchy, but where
+# each descendant gets a copy of their parents' attributes, instead of just a
+# pointer to the same. This means that the child can add elements to, for
+# example, an array without those additions being shared with either their
+# parent, siblings, or children, which is unlike the regular class-level
+# attributes that are shared across the entire hierarchy.
+class Class
+  # Defines class-level and instance-level attribute reader.
+  #
+  # @param *syms<Array> Array of attributes to define reader for.
+  # @return <Array[#to_s]> List of attributes that were made into cattr_readers
+  #
+  # @api public
+  #
+  # @todo Is this inconsistent in that it does not allow you to prevent
+  #   an instance_reader via :instance_reader => false
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      RUBY
+    end
+  end
+
+  # Defines class-level (and optionally instance-level) attribute writer.
+  #
+  # @param <Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to define writer for.
+  # @option syms :instance_writer<Boolean> if true, instance-level attribute writer is defined.
+  # @return <Array[#to_s]> List of attributes that were made into cattr_writers
+  #
+  # @api public
+  def cattr_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.flatten.each do |sym|
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+      RUBY
+
+      unless options[:instance_writer] == false
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def #{sym}=(obj)
+            @@#{sym} = obj
+          end
+        RUBY
+      end
+    end
+  end
+
+  # Defines class-level (and optionally instance-level) attribute accessor.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to define accessor for.
+  # @option syms :instance_writer<Boolean> if true, instance-level attribute writer is defined.
+  # @return <Array[#to_s]> List of attributes that were made into accessors
+  #
+  # @api public
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+
+  # Defines class-level inheritable attribute reader. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[#to_s]> Array of attributes to define inheritable reader for.
+  # @return <Array[#to_s]> Array of attributes converted into inheritable_readers.
+  #
+  # @api public
+  #
+  # @todo Do we want to block instance_reader via :instance_reader => false
+  # @todo It would be preferable that we do something with a Hash passed in
+  #   (error out or do the same as other methods above) instead of silently
+  #   moving on). In particular, this makes the return value of this function
+  #   less useful.
+  def class_inheritable_reader(*ivars)
+    instance_reader = ivars.pop[:reader] if ivars.last.is_a?(Hash)
+
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}
+          return @#{ivar} if defined?(@#{ivar})
+          return nil      if self.object_id == #{self.object_id}
+          ivar = superclass.#{ivar}
+          return nil if ivar.nil?
+          @#{ivar} = ivar.try_dup
+        end
+      RUBY
+
+      unless instance_reader == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}
+            self.class.#{ivar}
+          end
+        RUBY
+      end
+    end
+  end
+
+  # Defines class-level inheritable attribute writer. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+  #   define inheritable writer for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of the attributes that were made into inheritable writers.
+  #
+  # @api public
+  #
+  # @todo We need a style for class_eval <<-HEREDOC. I'd like to make it
+  #   class_eval(<<-RUBY, __FILE__, __LINE__), but we should codify it somewhere.
+  def class_inheritable_writer(*ivars)
+    instance_writer = ivars.pop[:instance_writer] if ivars.last.is_a?(Hash)
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}=(obj)
+          @#{ivar} = obj
+        end
+      RUBY
+      unless instance_writer == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}=(obj) self.class.#{ivar} = obj end
+        RUBY
+      end
+    end
+  end
+
+  # Defines class-level inheritable attribute accessor. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+  #   define inheritable accessor for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of attributes turned into inheritable accessors.
+  #
+  # @api public
+  def class_inheritable_accessor(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms)
+  end
+end