thorero 0.9.4.4 → 0.9.4.5

data/lib/extlib/lazy_array.rb

@@ -1,106 +0,0 @@
-class LazyArray  # borrowed partially from StrokeDB
-  instance_methods.each { |m| undef_method m unless %w[ __id__ __send__ send dup class object_id kind_of? respond_to? assert_kind_of should should_not instance_variable_set instance_variable_get ].include?(m) }
-
-  include Enumerable
-
-  # these methods should return self or nil
-  RETURN_SELF = [ :<<, :clear, :concat, :collect!, :each, :each_index,
-    :each_with_index, :freeze, :insert, :map!, :push, :replace,
-    :reject!, :reverse!, :reverse_each, :sort!, :unshift ]
-
-  RETURN_SELF.each do |method|
-    class_eval <<-EOS, __FILE__, __LINE__
-      def #{method}(*args, &block)
-        lazy_load
-        results = @array.#{method}(*args, &block)
-        results.kind_of?(Array) ? self : results
-      end
-    EOS
-  end
-
-  (Array.public_instance_methods(false).map { |m| m.to_sym } - RETURN_SELF - [ :taguri= ]).each do |method|
-    class_eval <<-EOS, __FILE__, __LINE__
-      def #{method}(*args, &block)
-        lazy_load
-        @array.#{method}(*args, &block)
-      end
-    EOS
-  end
-
-  def replace(other)
-    mark_loaded
-    @array.replace(other.entries)
-    self
-  end
-
-  def clear
-    mark_loaded
-    @array.clear
-    self
-  end
-
-  def eql?(other)
-    lazy_load
-    @array.eql?(other.entries)
-  end
-
-  alias == eql?
-
-  def load_with(&block)
-    @load_with_proc = block
-    self
-  end
-
-  def loaded?
-    @loaded == true
-  end
-
-  def unload
-    clear
-    @loaded = false
-    self
-  end
-
-  def respond_to?(method, include_private = false)
-    super || @array.respond_to?(method, include_private)
-  end
-
-  def to_proc
-    @load_with_proc
-  end
-
-  private
-
-  def initialize(*args, &block)
-    @loaded         = false
-    @load_with_proc = proc { |v| v }
-    @array          = Array.new(*args, &block)
-  end
-
-  def initialize_copy(original)
-    @array = original.entries
-    load_with(&original)
-    mark_loaded if @array.any?
-  end
-
-  def lazy_load
-    return if loaded?
-    mark_loaded
-    @load_with_proc[self]
-  end
-
-  def mark_loaded
-    @loaded = true
-  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
-      @array.send(method, *args, &block)
-    else
-      super
-    end
-  end
-end

data/lib/extlib/mash.rb

@@ -1,143 +0,0 @@
-# This class has dubious semantics and we only have it so that people can write
-# params[:key] instead of params['key'].
-class Mash < Hash
-
-  # @param constructor<Object>
-  #   The default value for the mash. Defaults to an empty hash.
-  #
-  # @details [Alternatives]
-  #   If constructor is a Hash, a new mash will be created based on the keys of
-  #   the hash and no default value will be set.
-  def initialize(constructor = {})
-    if constructor.is_a?(Hash) 
-      super() 
-      update(constructor) 
-    else 
-      super(constructor) 
-    end 
-  end
-
-  # @param key<Object> The default value for the mash. Defaults to nil.
-  #
-  # @details [Alternatives]
-  #   If key is a Symbol and it is a key in the mash, then the default value will
-  #   be set to the value matching the key.
-  def default(key = nil) 
-    if key.is_a?(Symbol) && include?(key = key.to_s) 
-      self[key] 
-    else 
-      super 
-    end 
-  end 
- 
-  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer) 
-  alias_method :regular_update, :update unless method_defined?(:regular_update)
-
-  # @param key<Object> The key to set.
-  # @param value<Object>
-  #   The value to set the key to.
-  #
-  # @see Mash#convert_key
-  # @see Mash#convert_value
-  def []=(key, value) 
-    regular_writer(convert_key(key), convert_value(value)) 
-  end
-
-  # @param other_hash<Hash>
-  #   A hash to update values in the mash with. The keys and the values will be
-  #   converted to Mash format.
-  #
-  # @return <Mash> The updated mash.
-  def update(other_hash) 
-    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) } 
-    self 
-  end 
- 
-  alias_method :merge!, :update
-
-  # @param key<Object> The key to check for. This will be run through convert_key.
-  #
-  # @return <TrueClass, FalseClass> True if the key exists in the mash.
-  def key?(key) 
-    super(convert_key(key)) 
-  end 
-
-  # def include? def has_key? def member?
-  alias_method :include?, :key?
-  alias_method :has_key?, :key?
-  alias_method :member?, :key?
-
-  # @param key<Object> The key to fetch. This will be run through convert_key.
-  # @param *extras<Array> Default value.
-  #
-  # @return <Object> The value at key or the default value.
-  def fetch(key, *extras) 
-    super(convert_key(key), *extras) 
-  end
-
-  # @param *indices<Array>
-  #   The keys to retrieve values for. These will be run through +convert_key+.
-  #
-  # @return <Array> The values at each of the provided keys
-  def values_at(*indices) 
-    indices.collect {|key| self[convert_key(key)]} 
-  end
-
-  # @return <Mash> A duplicate of this mash.
-  def dup 
-    Mash.new(self) 
-  end
-
-  # @param hash<Hash> The hash to merge with the mash.
-  #
-  # @return <Mash> A new mash with the hash values merged in.
-  def merge(hash) 
-    self.dup.update(hash) 
-  end
-
-  # @param key<Object>
-  #   The key to delete from the mash.\
-  def delete(key) 
-    super(convert_key(key)) 
-  end
-
-  # Used to provide the same interface as Hash.
-  #
-  # @return <Mash> This mash unchanged.
-  def stringify_keys!; self end
- 
-  # @return <Hash> The mash as a Hash with string keys.
-  def to_hash 
-    Hash.new(default).merge(self) 
-  end 
- 
-  protected
-  # @param key<Object> The key to convert.
-  #
-  # @param <Object>
-  #   The converted key. If the key was a symbol, it will be converted to a
-  #   string.
-  #
-  # @api private
-  def convert_key(key) 
-    key.kind_of?(Symbol) ? key.to_s : key 
-  end
-
-  # @param value<Object> The value to convert.
-  #
-  # @return <Object>
-  #   The converted value. A Hash or an Array of hashes, will be converted to
-  #   their Mash equivalents.
-  #
-  # @api private
-  def convert_value(value) 
-    case value 
-    when Hash 
-      value.to_mash 
-    when Array 
-      value.collect { |e| convert_value(e) } 
-    else 
-      value 
-    end 
-  end
-end

data/lib/extlib/module.rb

@@ -1,37 +0,0 @@
-class Module
-  def find_const(const_name)
-    if const_name[0..1] == '::'
-      Object.find_const(const_name[2..-1])
-    else
-      nested_const_lookup(const_name)
-    end
-  end
-
-  private
-
-  # Doesn't do any caching since constants can change with remove_const
-  def nested_const_lookup(const_name)
-    constants = [ Object ]
-
-    unless self == Object
-      self.name.split('::').each do |part|
-        constants.unshift(constants.first.const_get(part))
-      end
-    end
-
-    parts = const_name.split('::')
-
-    # from most to least specific constant, use each as a base and try
-    # to find a constant with the name const_name within them
-    constants.each do |const|
-      # return the nested constant if available
-      return const if parts.all? do |part|
-        const = const.const_defined?(part) ? const.const_get(part) : nil
-      end
-    end
-
-    # if we get this far then the nested constant was not found
-    raise NameError, "uninitialized constant #{const_name}"
-  end
-
-end # class Module

data/lib/extlib/object.rb

@@ -1,165 +0,0 @@
-class Object
-  # Extracts the singleton class, so that metaprogramming can be done on it.
-  #
-  # @return <Class> The meta class.
-  #
-  # @example [Setup]
-  #   class MyString < String; end
-  #
-  #   MyString.instance_eval do
-  #     define_method :foo do
-  #       puts self
-  #     end
-  #   end
-  #
-  #   MyString.meta_class.instance_eval do
-  #     define_method :bar do
-  #       puts self
-  #     end
-  #   end
-  #
-  #   def String.add_meta_var(var)
-  #     self.meta_class.instance_eval do
-  #       define_method var do
-  #         puts "HELLO"
-  #       end
-  #     end
-  #   end
-  #
-  # @example
-  #   MyString.new("Hello").foo #=> "Hello"
-  # @example
-  #   MyString.new("Hello").bar
-  #     #=> NoMethodError: undefined method `bar' for "Hello":MyString
-  # @example
-  #   MyString.foo
-  #     #=> NoMethodError: undefined method `foo' for MyString:Class
-  # @example  
-  #   MyString.bar
-  #     #=> MyString
-  # @example  
-  #   String.bar
-  #     #=> NoMethodError: undefined method `bar' for String:Class
-  # @example
-  #   MyString.add_meta_var(:x)
-  #   MyString.x #=> HELLO
-  #
-  # @details [Description of Examples]
-  #   As you can see, using #meta_class allows you to execute code (and here,
-  #   define a method) on the metaclass itself. It also allows you to define
-  #   class methods that can be run on subclasses, and then be able to execute
-  #   code on the metaclass of the subclass (here MyString).
-  #
-  #   In this case, we were able to define a class method (add_meta_var) on
-  #   String that was executable by the MyString subclass. It was then able to
-  #   define a method on the subclass by adding it to the MyString metaclass.
-  #
-  #   For more information, you can check out _why's excellent article at:
-  #   http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
-  def meta_class() class << self; self end end
-
-  # @return <TrueClass, FalseClass>
-  #   True if the empty? is true or if the object responds to strip (e.g. a
-  #   String) and strip.empty? is true, or if !self is true.
-  #
-  # @example [].blank?         #=>  true
-  # @example [1].blank?        #=>  false
-  # @example [nil].blank?      #=>  false
-  # @example nil.blank?        #=>  true
-  # @example true.blank?       #=>  false
-  # @example false.blank?      #=>  true
-  # @example "".blank?         #=>  true
-  # @example "     ".blank?    #=>  true
-  # @example " hey ho ".blank? #=>  false
-  def blank?
-    if respond_to?(:empty?) && respond_to?(:strip)
-      empty? or strip.empty?
-    elsif respond_to?(:empty?)
-      empty?
-    else
-      !self
-    end
-  end
-
-  # @param name<String> The name of the constant to get, e.g. "Merb::Router".
-  #
-  # @return <Object> The constant corresponding to the name.
-  def full_const_get(name)
-    list = name.split("::")
-    list.shift if list.first.blank?
-    obj = self
-    list.each do |x| 
-      # This is required because const_get tries to look for constants in the 
-      # ancestor chain, but we only want constants that are HERE
-      obj = obj.const_defined?(x) ? obj.const_get(x) : obj.const_missing(x)
-    end
-    obj
-  end
-  
-  # @param name<String> The name of the constant to get, e.g. "Merb::Router".
-  # @param value<Object> The value to assign to the constant.
-  #
-  # @return <Object> The constant corresponding to the name.
-  def full_const_set(name, value)    
-    list = name.split("::")
-    toplevel = list.first.blank?
-    list.shift if toplevel
-    last = list.pop
-    obj = list.empty? ? Object : Object.full_const_get(list.join("::"))
-    obj.const_set(last, value) if obj && !obj.const_defined?(last)
-  end
-
-  # Defines module from a string name (e.g. Foo::Bar::Baz)
-  # If module already exists, no exception raised.
-  #
-  # @param name<String> The name of the full module name to make
-  #
-  # @return <NilClass>
-  def make_module(str)
-    mod = str.split("::")
-    start = mod.map {|x| "module #{x}"}.join("; ")
-    ender = (["end"] * mod.size).join("; ")
-    self.class_eval <<-HERE
-      #{start}
-      #{ender}
-    HERE
-  end
-
-  # @param duck<Symbol, Class, Array> The thing to compare the object to.
-  #
-  # @note
-  #   The behavior of the method depends on the type of duck as follows:
-  #   Symbol:: Check whether the object respond_to?(duck).
-  #   Class:: Check whether the object is_a?(duck).
-  #   Array::
-  #     Check whether the object quacks_like? at least one of the options in the
-  #     array.
-  #
-  # @return <TrueClass, FalseClass>
-  #   True if the object quacks like duck.
-  def quacks_like?(duck)
-    case duck
-    when Symbol
-      self.respond_to?(duck)
-    when Class
-      self.is_a?(duck)
-    when Array
-      duck.any? {|d| self.quacks_like?(d) }
-    else
-      false
-    end
-  end
-  
-  # @param arrayish<#include?> Container to check, to see if it includes the object.
-  # @param *more<Array>:: additional args, will be flattened into arrayish
-  #
-  # @return <TrueClass, FalseClass>
-  #   True if the object is included in arrayish (+ more)
-  #
-  # @example 1.in?([1,2,3]) #=> true
-  # @example 1.in?(1,2,3) #=> true
-  def in?(arrayish,*more)
-    arrayish = more.unshift(arrayish) unless more.empty?
-    arrayish.include?(self)
-  end
-end