robsharp-extlib 0.9.15

data/lib/extlib/inflection.rb

@@ -0,0 +1,442 @@
+require 'extlib/string'
+
+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/lib/extlib/lazy_array.rb

@@ -0,0 +1,453 @@
+require 'extlib/try_dup'
+
+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