rango 0.1.pre → 0.1.0

data/vendor/extlib/lib/extlib/inflection.rb

@@ -1,440 +0,0 @@
-module Extlib
-
-  # = English Nouns Number Inflection.
-  #
-  # This module provides english singular <-> plural noun inflections.
-  module Inflection
-
-    class << self
-      # Take an underscored name and make it into a camelized name
-      #
-      # @example
-      #   "egg_and_hams".classify #=> "EggAndHam"
-      #   "enlarged_testes".classify #=> "EnlargedTestis"
-      #   "post".classify #=> "Post"
-      #
-      def classify(name)
-        words = name.to_s.sub(/.*\./, '').split('_')
-        words[-1] = singularize(words[-1])
-        words.collect { |word| word.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(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_const_path
-      end
-
-      # Capitalizes the first word and turns underscores into spaces and strips _id.
-      # Like titleize, this is meant for creating pretty output.
-      #
-      # @example
-      #   "employee_salary" #=> "Employee salary"
-      #   "author_id" #=> "Author"
-      def humanize(lower_case_and_underscored_word)
-        lower_case_and_underscored_word.to_s.gsub(/_id$/, '').tr('_', ' ').capitalize
-      end
-
-      # Removes the module part from the expression in the string
-      #
-      # @example
-      #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
-      #   "Inflections".demodulize #=> "Inflections"
-      def demodulize(class_name_in_module)
-        class_name_in_module.to_s.gsub(/^.*::/, '')
-      end
-
-      # Create the name of a table like Rails does for models to table names. This method
-      # uses the pluralize method on the last word in the string.
-      #
-      # @example
-      #   "RawScaledScorer".tableize #=> "raw_scaled_scorers"
-      #   "EnlargedTestis".tableize #=> "enlarged_testes"
-      #   "egg_and_ham".tableize #=> "egg_and_hams"
-      #   "fancyCategory".tableize #=> "fancy_categories"
-      def tableize(class_name)
-        words = class_name.to_const_path.tr('/', '_').split('_')
-        words[-1] = pluralize(words[-1])
-        words.join('_')
-      end
-
-      # Creates a foreign key name from a class name.
-      #
-      # @example
-      #   "Message".foreign_key #=> "message_id"
-      #   "Admin::Post".foreign_key #=> "post_id"
-      def foreign_key(class_name, key = "id")
-        underscore(demodulize(class_name.to_s)) << "_" << key.to_s
-      end
-
-      # Constantize tries to find a declared constant with the name specified
-      # in the string. It raises a NameError when the name is not in CamelCase
-      # or is not initialized.
-      #
-      # @example
-      #   "Module".constantize #=> Module
-      #   "Class".constantize #=> Class
-      def constantize(camel_cased_word)
-        unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
-          raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
-        end
-
-        Object.module_eval("::#{$1}", __FILE__, __LINE__)
-      end
-    end
-
-    @singular_of = {}
-    @plural_of = {}
-
-    @singular_rules = []
-    @plural_rules = []
-
-    class << self
-      # Defines a general inflection exception case.
-      #
-      # ==== Parameters
-      # singular<String>::
-      #   singular form of the word
-      # plural<String>::
-      #   plural form of the word
-      #
-      # ==== Examples
-      #
-      # Here we define erratum/errata exception case:
-      #
-      # English::Inflect.word "erratum", "errata"
-      #
-      # In case singular and plural forms are the same omit
-      # second argument on call:
-      #
-      # English::Inflect.word 'information'
-      def word(singular, plural=nil)
-        plural = singular unless plural
-        singular_word(singular, plural)
-        plural_word(singular, plural)
-      end
-
-      def clear(type = :all)
-        if type == :singular || type == :all
-          @singular_of = {}
-          @singular_rules = []
-          @singularization_rules, @singularization_regex = nil, nil
-        end
-        if type == :plural || type == :all
-          @singular_of = {}
-          @singular_rules = []
-          @singularization_rules, @singularization_regex = nil, nil
-        end
-      end
-
-
-      # Define a singularization exception.
-      #
-      # ==== Parameters
-      # singular<String>::
-      #   singular form of the word
-      # plural<String>::
-      #   plural form of the word
-      def singular_word(singular, plural)
-        @singular_of[plural] = singular
-        @singular_of[plural.capitalize] = singular.capitalize
-      end
-
-      # Define a pluralization exception.
-      #
-      # ==== Parameters
-      # singular<String>::
-      #   singular form of the word
-      # plural<String>::
-      #   plural form of the word
-      def plural_word(singular, plural)
-        @plural_of[singular] = plural
-        @plural_of[singular.capitalize] = plural.capitalize
-      end
-
-      # Define a general rule.
-      #
-      # ==== Parameters
-      # singular<String>::
-      #   ending of the word in singular form
-      # plural<String>::
-      #   ending of the word in plural form
-      # whole_word<Boolean>::
-      #   for capitalization, since words can be
-      #   capitalized (Man => Men)      #
-      # ==== Examples
-      # Once the following rule is defined:
-      # English::Inflect.rule 'y', 'ies'
-      #
-      # You can see the following results:
-      # irb> "fly".plural
-      # => flies
-      # irb> "cry".plural
-      # => cries
-      # Define a general rule.
-
-      def rule(singular, plural, whole_word = false)
-        singular_rule(singular, plural)
-        plural_rule(singular, plural)
-        word(singular, plural) if whole_word
-      end
-
-      # Define a singularization rule.
-      #
-      # ==== Parameters
-      # singular<String>::
-      #   ending of the word in singular form
-      # plural<String>::
-      #   ending of the word in plural form
-      #
-      # ==== Examples
-      # Once the following rule is defined:
-      # English::Inflect.singular_rule 'o', 'oes'
-      #
-      # You can see the following results:
-      # irb> "heroes".singular
-      # => hero
-      def singular_rule(singular, plural)
-        @singular_rules << [singular, plural]
-      end
-
-      # Define a plurualization rule.
-      #
-      # ==== Parameters
-      # singular<String>::
-      #   ending of the word in singular form
-      # plural<String>::
-      #   ending of the word in plural form
-      #
-      # ==== Examples
-      # Once the following rule is defined:
-      # English::Inflect.singular_rule 'fe', 'ves'
-      #
-      # You can see the following results:
-      # irb> "wife".plural
-      # => wives
-      def plural_rule(singular, plural)
-        @plural_rules << [singular, plural]
-      end
-
-      # Read prepared singularization rules.
-      def singularization_rules
-        if defined?(@singularization_regex) && @singularization_regex
-          return [@singularization_regex, @singularization_hash]
-        end
-        # No sorting needed: Regexen match on longest string
-        @singularization_regex = Regexp.new("(" + @singular_rules.map {|s,p| p}.join("|") + ")$", "i")
-        @singularization_hash  = Hash[*@singular_rules.flatten].invert
-        [@singularization_regex, @singularization_hash]
-      end
-
-      # Read prepared pluralization rules.
-      def pluralization_rules
-        if defined?(@pluralization_regex) && @pluralization_regex
-          return [@pluralization_regex, @pluralization_hash]
-        end
-        @pluralization_regex = Regexp.new("(" + @plural_rules.map {|s,p| s}.join("|") + ")$", "i")
-        @pluralization_hash  = Hash[*@plural_rules.flatten]
-        [@pluralization_regex, @pluralization_hash]
-      end
-
-      attr_reader :singular_of, :plural_of
-
-      # Convert an English word from plural to singular.
-      #
-      #   "boys".singular      #=> boy
-      #   "tomatoes".singular  #=> tomato
-      #
-      # ==== Parameters
-      # word<String>:: word to singularize
-      #
-      # ==== Returns
-      # <String>:: singularized form of word
-      #
-      # ==== Notes
-      # Aliased as singularize (a Railism)
-      def singular(word)
-        if result = singular_of[word]
-          return result.dup
-        end
-        result = word.dup
-        regex, hash = singularization_rules
-        result.sub!(regex) {|m| hash[m]}
-        singular_of[word] = result
-        return result
-      end
-
-      # Alias for #singular (a Railism).
-      #
-      alias_method(:singularize, :singular)
-
-      # Convert an English word from singular to plural.
-      #
-      #   "boy".plural     #=> boys
-      #   "tomato".plural  #=> tomatoes
-      #
-      # ==== Parameters
-      # word<String>:: word to pluralize
-      #
-      # ==== Returns
-      # <String>:: pluralized form of word
-      #
-      # ==== Notes
-      # Aliased as pluralize (a Railism)
-      def plural(word)
-        # special exceptions
-        return "" if word == ""
-        if result = plural_of[word]
-          return result.dup
-        end
-        result = word.dup
-        regex, hash = pluralization_rules
-        result.sub!(regex) {|m| hash[m]}
-        plural_of[word] = result
-        return result
-      end
-
-      # Alias for #plural (a Railism).
-      alias_method(:pluralize, :plural)
-    end
-
-    # One argument means singular and plural are the same.
-
-    word 'equipment'
-    word 'information'
-    word 'money'
-    word 'species'
-    word 'series'
-    word 'fish'
-    word 'sheep'
-    word 'moose'
-    word 'hovercraft'
-    word 'grass'
-    word 'rain'
-    word 'milk'
-    word 'rice'
-    word 'plurals'
-    word 'postgres'
-    word 'status'
-
-    # Two arguments defines a singular and plural exception.
-    word 'status'    , 'status'
-    word 'Swiss'     , 'Swiss'
-    word 'life'      , 'lives'
-    word 'wife'      , 'wives'
-    word 'goose'     , 'geese'
-    word 'criterion' , 'criteria'
-    word 'alias'     , 'aliases'
-    word 'status'    , 'statuses'
-    word 'axis'      , 'axes'
-    word 'crisis'    , 'crises'
-    word 'testis'    , 'testes'
-    word 'potato'    , 'potatoes'
-    word 'tomato'    , 'tomatoes'
-    word 'buffalo'   , 'buffaloes'
-    word 'torpedo'   , 'torpedoes'
-    word 'quiz'      , 'quizzes'
-    word 'matrix'    , 'matrices'
-    word 'vertex'    , 'vertices'
-    word 'index'     , 'indices'
-    word 'ox'        , 'oxen'
-    word 'mouse'     , 'mice'
-    word 'louse'     , 'lice'
-    word 'thesis'    , 'theses'
-    word 'thief'     , 'thieves'
-    word 'analysis'  , 'analyses'
-    word 'erratum'   , 'errata'
-    word 'phenomenon', 'phenomena'
-    word 'octopus'   , 'octopi'
-    word 'thesaurus' , 'thesauri'
-    word 'movie'     , 'movies'
-    word 'cactus'    , 'cacti'
-    word 'plus'      , 'plusses'
-    word 'cross'     , 'crosses'
-    word 'medium'    , 'media'
-    word 'datum'     , 'data'
-    word 'basis'     , 'bases'
-    word 'diagnosis' , 'diagnoses'
-
-    # One-way singularization exception (convert plural to singular).
-
-    # General rules.
-    rule 'person' , 'people', true
-    rule 'shoe'   , 'shoes', true
-    rule 'hive'   , 'hives', true
-    rule 'man'    , 'men', true
-    rule 'child'  , 'children', true
-    rule 'news'   , 'news', true
-    rule 'rf'   , 'rves'
-    rule 'af'   , 'aves'
-    rule 'ero'  , 'eroes'
-    rule 'man'  , 'men'
-    rule 'ch'   , 'ches'
-    rule 'sh'   , 'shes'
-    rule 'ss'   , 'sses'
-    rule 'ta'   , 'tum'
-    rule 'ia'   , 'ium'
-    rule 'ra'   , 'rum'
-    rule 'ay'   , 'ays'
-    rule 'ey'   , 'eys'
-    rule 'oy'   , 'oys'
-    rule 'uy'   , 'uys'
-    rule 'y'    , 'ies'
-    rule 'x'    , 'xes'
-    rule 'lf'   , 'lves'
-    rule 'ffe'  , 'ffes'
-    rule 'afe'  , 'aves'
-    rule 'ouse' , 'ouses'
-    # more cases of words ending in -oses not being singularized properly
-    # than cases of words ending in -osis
-#    rule 'osis' , 'oses'
-    rule 'ox'   , 'oxes'
-    rule 'us'   , 'uses'
-    rule ''     , 's'
-
-    # One-way singular rules.
-
-    singular_rule 'of' , 'ofs' # proof
-    singular_rule 'o'  , 'oes' # hero, heroes
-    singular_rule 'f'  , 'ves'
-
-    # One-way plural rules.
-
-    #plural_rule 'fe' , 'ves' # safe, wife
-    plural_rule 's'   , 'ses'
-    plural_rule 'ive' , 'ives' # don't want to snag wife
-    plural_rule 'fe'  , 'ves'  # don't want to snag perspectives
-
-
-  end
-end
-
-class String
-  def singular
-    Extlib::Inflection.singular(self)
-  end
-  alias_method(:singularize, :singular)
-  def plural
-    Extlib::Inflection.plural(self)
-  end
-  alias_method(:pluralize, :plural)
-end

data/vendor/extlib/lib/extlib/lazy_array.rb

@@ -1,451 +0,0 @@
-class LazyArray  # borrowed partially from StrokeDB
-  include Enumerable
-
-  attr_reader :head, :tail
-
-  def first(*args)
-    if lazy_possible?(@head, *args)
-      @head.first(*args)
-    else
-      lazy_load
-      @array.first(*args)
-    end
-  end
-
-  def last(*args)
-    if lazy_possible?(@tail, *args)
-      @tail.last(*args)
-    else
-      lazy_load
-      @array.last(*args)
-    end
-  end
-
-  def at(index)
-    if index >= 0 && lazy_possible?(@head, index + 1)
-      @head.at(index)
-    elsif index < 0 && lazy_possible?(@tail, index.abs)
-      @tail.at(index)
-    else
-      lazy_load
-      @array.at(index)
-    end
-  end
-
-  def fetch(*args, &block)
-    index = args.first
-
-    if index >= 0 && lazy_possible?(@head, index + 1)
-      @head.fetch(*args, &block)
-    elsif index < 0 && lazy_possible?(@tail, index.abs)
-      @tail.fetch(*args, &block)
-    else
-      lazy_load
-      @array.fetch(*args, &block)
-    end
-  end
-
-  def values_at(*args)
-    accumulator = []
-
-    lazy_possible = args.all? do |arg|
-      index, length = extract_slice_arguments(arg)
-
-      if index >= 0 && lazy_possible?(@head, index + length)
-        accumulator.concat(head.values_at(*arg))
-      elsif index < 0 && lazy_possible?(@tail, index.abs)
-        accumulator.concat(tail.values_at(*arg))
-      end
-    end
-
-    if lazy_possible
-      accumulator
-    else
-      lazy_load
-      @array.values_at(*args)
-    end
-  end
-
-  def index(entry)
-    (lazy_possible?(@head) && @head.index(entry)) || begin
-      lazy_load
-      @array.index(entry)
-    end
-  end
-
-  def include?(entry)
-    (lazy_possible?(@tail) && @tail.include?(entry)) ||
-    (lazy_possible?(@head) && @head.include?(entry)) || begin
-      lazy_load
-      @array.include?(entry)
-    end
-  end
-
-  def empty?
-    (@tail.nil? || @tail.empty?) &&
-    (@head.nil? || @head.empty?) && begin
-      lazy_load
-      @array.empty?
-    end
-  end
-
-  def any?(&block)
-    (lazy_possible?(@tail) && @tail.any?(&block)) ||
-    (lazy_possible?(@head) && @head.any?(&block)) || begin
-      lazy_load
-      @array.any?(&block)
-    end
-  end
-
-  def [](*args)
-    index, length = extract_slice_arguments(*args)
-
-    if length == 1 && args.size == 1 && args.first.kind_of?(Integer)
-      return at(index)
-    end
-
-    if index >= 0 && lazy_possible?(@head, index + length)
-      @head[*args]
-    elsif index < 0 && lazy_possible?(@tail, index.abs - 1 + length)
-      @tail[*args]
-    else
-      lazy_load
-      @array[*args]
-    end
-  end
-
-  alias slice []
-
-  def slice!(*args)
-    index, length = extract_slice_arguments(*args)
-
-    if index >= 0 && lazy_possible?(@head, index + length)
-      @head.slice!(*args)
-    elsif index < 0 && lazy_possible?(@tail, index.abs - 1 + length)
-      @tail.slice!(*args)
-    else
-      lazy_load
-      @array.slice!(*args)
-    end
-  end
-
-  def []=(*args)
-    index, length = extract_slice_arguments(*args[0..-2])
-
-    if index >= 0 && lazy_possible?(@head, index + length)
-      @head.[]=(*args)
-    elsif index < 0 && lazy_possible?(@tail, index.abs - 1 + length)
-      @tail.[]=(*args)
-    else
-      lazy_load
-      @array.[]=(*args)
-    end
-  end
-
-  alias splice []=
-
-  def reverse
-    dup.reverse!
-  end
-
-  def reverse!
-    # reverse without kicking if possible
-    if loaded?
-      @array = @array.reverse
-    else
-      @head, @tail = @tail.reverse, @head.reverse
-
-      proc = @load_with_proc
-
-      @load_with_proc = lambda do |v|
-        proc.call(v)
-        v.instance_variable_get(:@array).reverse!
-      end
-    end
-
-    self
-  end
-
-  def <<(entry)
-    if loaded?
-      lazy_load
-      @array << entry
-    else
-      @tail << entry
-    end
-    self
-  end
-
-  def concat(other)
-    if loaded?
-      lazy_load
-      @array.concat(other)
-    else
-      @tail.concat(other)
-    end
-    self
-  end
-
-  def push(*entries)
-    if loaded?
-      lazy_load
-      @array.push(*entries)
-    else
-      @tail.push(*entries)
-    end
-    self
-  end
-
-  def unshift(*entries)
-    if loaded?
-      lazy_load
-      @array.unshift(*entries)
-    else
-      @head.unshift(*entries)
-    end
-    self
-  end
-
-  def insert(index, *entries)
-    if index >= 0 && lazy_possible?(@head, index)
-      @head.insert(index, *entries)
-    elsif index < 0 && lazy_possible?(@tail, index.abs - 1)
-      @tail.insert(index, *entries)
-    else
-      lazy_load
-      @array.insert(index, *entries)
-    end
-    self
-  end
-
-  def pop(*args)
-    if lazy_possible?(@tail, *args)
-      @tail.pop(*args)
-    else
-      lazy_load
-      @array.pop(*args)
-    end
-  end
-
-  def shift(*args)
-    if lazy_possible?(@head, *args)
-      @head.shift(*args)
-    else
-      lazy_load
-      @array.shift(*args)
-    end
-  end
-
-  def delete_at(index)
-    if index >= 0 && lazy_possible?(@head, index + 1)
-      @head.delete_at(index)
-    elsif index < 0 && lazy_possible?(@tail, index.abs)
-      @tail.delete_at(index)
-    else
-      lazy_load
-      @array.delete_at(index)
-    end
-  end
-
-  def delete_if(&block)
-    if loaded?
-      lazy_load
-      @array.delete_if(&block)
-    else
-      @reapers << block
-      @head.delete_if(&block)
-      @tail.delete_if(&block)
-    end
-    self
-  end
-
-  def replace(other)
-    mark_loaded
-    @array.replace(other)
-    self
-  end
-
-  def clear
-    mark_loaded
-    @array.clear
-    self
-  end
-
-  def to_a
-    lazy_load
-    @array.to_a
-  end
-
-  alias to_ary to_a
-
-  def load_with(&block)
-    @load_with_proc = block
-    self
-  end
-
-  def loaded?
-    @loaded == true
-  end
-
-  def kind_of?(klass)
-    super || @array.kind_of?(klass)
-  end
-
-  alias is_a? kind_of?
-
-  def respond_to?(method, include_private = false)
-    super || @array.respond_to?(method)
-  end
-
-  def freeze
-    if loaded?
-      @array.freeze
-    else
-      @head.freeze
-      @tail.freeze
-    end
-    @frozen = true
-    self
-  end
-
-  def frozen?
-    @frozen == true
-  end
-
-  def ==(other)
-    if equal?(other)
-      return true
-    end
-
-    unless other.respond_to?(:to_ary)
-      return false
-    end
-
-    # if necessary, convert to something that can be compared
-    other = other.to_ary unless other.respond_to?(:[])
-
-    cmp?(other, :==)
-  end
-
-  def eql?(other)
-    if equal?(other)
-      return true
-    end
-
-    unless other.class.equal?(self.class)
-      return false
-    end
-
-    cmp?(other, :eql?)
-  end
-
-  def lazy_possible?(list, need_length = 1)
-    !loaded? && need_length <= list.size
-  end
-
-  private
-
-  def initialize
-    @frozen         = false
-    @loaded         = false
-    @load_with_proc = lambda { |v| v }
-    @head           = []
-    @tail           = []
-    @array          = []
-    @reapers        = []
-  end
-
-  def initialize_copy(original)
-    @head  = @head.try_dup
-    @tail  = @tail.try_dup
-    @array = @array.try_dup
-  end
-
-  def lazy_load
-    return if loaded?
-    mark_loaded
-    @load_with_proc[self]
-    @array.unshift(*@head)
-    @array.concat(@tail)
-    @head = @tail = nil
-    @reapers.each { |r| @array.delete_if(&r) } if @reapers
-    @array.freeze if frozen?
-  end
-
-  def mark_loaded
-    @loaded = true
-  end
-
-  ##
-  # Extract arguments for #slice an #slice! and return index and length
-  #
-  # @param [Integer, Array(Integer), Range] *args the index,
-  #   index and length, or range indicating first and last position
-  #
-  # @return [Integer] the index
-  # @return [Integer,NilClass] the length, if any
-  #
-  # @api private
-  def extract_slice_arguments(*args)
-    first_arg, second_arg = args
-
-    if args.size == 2 && first_arg.kind_of?(Integer) && second_arg.kind_of?(Integer)
-      return first_arg, second_arg
-    elsif args.size == 1
-      if first_arg.kind_of?(Integer)
-        return first_arg, 1
-      elsif first_arg.kind_of?(Range)
-        index = first_arg.first
-        length  = first_arg.last - index
-        length += 1 unless first_arg.exclude_end?
-        return index, length
-      end
-    end
-
-    raise ArgumentError, "arguments may be 1 or 2 Integers, or 1 Range object, was: #{args.inspect}", caller(1)
-  end
-
-  def each
-    lazy_load
-    if block_given?
-      @array.each { |entry| yield entry }
-      self
-    else
-      @array.each
-    end
-  end
-
-  # delegate any not-explicitly-handled methods to @array, if possible.
-  # this is handy for handling methods mixed-into Array like group_by
-  def method_missing(method, *args, &block)
-    if @array.respond_to?(method)
-      lazy_load
-      results = @array.send(method, *args, &block)
-      results.equal?(@array) ? self : results
-    else
-      super
-    end
-  end
-
-  def cmp?(other, operator)
-    unless loaded?
-      # compare the head against the beginning of other.  start at index
-      # 0 and incrementally compare each entry. if other is a LazyArray
-      # this has a lesser likelyhood of triggering a lazy load
-      0.upto(@head.size - 1) do |i|
-        return false unless @head[i].__send__(operator, other[i])
-      end
-
-      # compare the tail against the end of other.  start at index
-      # -1 and decrementally compare each entry. if other is a LazyArray
-      # this has a lesser likelyhood of triggering a lazy load
-      -1.downto(@tail.size * -1) do |i|
-        return false unless @tail[i].__send__(operator, other[i])
-      end
-
-      lazy_load
-    end
-
-    @array.send(operator, other.to_ary)
-  end
-end