thorero 0.9.4

data/lib/extlib/mash.rb

@@ -0,0 +1,143 @@
+# 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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,165 @@
+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

data/lib/extlib/object_space.rb

@@ -0,0 +1,13 @@
+module ObjectSpace
+  
+  class << self
+
+    # @return <Array[Class]> All the classes in the object space.
+    def classes
+      klasses = []
+      ObjectSpace.each_object(Class) {|o| klasses << o}
+      klasses
+    end
+  end
+  
+end

data/lib/extlib/pathname.rb

@@ -0,0 +1,5 @@
+class Pathname
+  def /(path)
+    (self + path).expand_path
+  end
+end # class Pathname

data/lib/extlib/pooling.rb

@@ -0,0 +1,233 @@
+require 'set'
+require 'thread'
+
+module Extlib
+  # ==== Notes
+  # Provides pooling support to class it got included in.
+  #
+  # Pooling of objects is a faster way of aquiring instances
+  # of objects compared to regular allocation and initialization
+  # because instances are keeped in memory reused.
+  #
+  # Classes that include Pooling module have re-defined new
+  # method that returns instances acquired from pool.
+  #
+  # Term resource is used for any type of poolable objects
+  # and should NOT be thought as DataMapper Resource or
+  # ActiveResource resource and such.
+  #
+  # In Data Objects connections are pooled so that it is
+  # unnecessary to allocate and initialize connection object
+  # each time connection is needed, like per request in a
+  # web application.
+  #
+  # Pool obviously has to be thread safe because state of
+  # object is reset when it is released.
+  module Pooling
+
+    def self.scavenger
+      @scavenger || begin
+        @scavenger = Thread.new do
+          loop do
+            lock.synchronize do
+              pools.each do |pool|
+                # This is a useful check, but non-essential, and right now it breaks lots of stuff.
+                # if pool.expired?
+                pool.lock.synchronize do
+                  if pool.reserved_count == 0
+                    pool.dispose
+                  end
+                end
+                # end
+              end
+            end
+            sleep(scavenger_interval)
+          end # loop
+        end
+
+        @scavenger.priority = -10
+        @scavenger
+      end
+    end
+
+    def self.pools
+      @pools ||= Set.new
+    end
+
+    def self.append_pool(pool)
+      lock.synchronize do
+        pools << pool
+      end
+      Extlib::Pooling::scavenger
+    end
+
+    def self.lock
+      @lock ||= Mutex.new
+    end
+
+    class CrossPoolError < StandardError
+    end
+
+    class OrphanedObjectError < StandardError
+    end
+
+    class ThreadStopError < StandardError
+    end
+
+    def self.included(target)
+      target.class_eval do
+        class << self
+          alias __new new
+        end
+
+        @__pools = Hash.new { |h,k| __pool_lock.synchronize { h[k] = Pool.new(target.pool_size, target, k) } }
+        @__pool_lock = Mutex.new
+
+        def self.__pool_lock
+          @__pool_lock
+        end
+
+        def self.new(*args)
+          @__pools[args].new
+        end
+
+        def self.__pools
+          @__pools
+        end
+
+        def self.pool_size
+          8
+        end
+      end
+    end
+
+    def release
+      @__pool.release(self) unless @__pool.nil?
+    end
+
+    class Pool
+      def initialize(max_size, resource, args)
+        raise ArgumentError.new("+max_size+ should be a Fixnum but was #{max_size.inspect}") unless Fixnum === max_size
+        raise ArgumentError.new("+resource+ should be a Class but was #{resource.inspect}") unless Class === resource
+
+        @max_size = max_size
+        @resource = resource
+        @args = args
+
+        @available = []
+        @reserved_count = 0
+      end
+
+      def lock
+        @resource.__pool_lock
+      end
+
+      def scavenge_interval
+        @resource.scavenge_interval
+      end
+
+      def new
+        instance = nil
+
+        lock.synchronize do
+          instance = acquire
+        end
+
+        Extlib::Pooling::append_pool(self)
+
+        if instance.nil?
+          # Account for the current thread, and the pool scavenger.
+          if ThreadGroup::Default.list.size == 2 && @reserved_count >= @max_size
+            raise ThreadStopError.new(size)
+          else
+            sleep(0.05)
+            new
+          end
+        else
+          instance
+        end
+      end
+
+      def release(instance)
+        lock.synchronize do
+          instance.instance_variable_set(:@__pool, nil)
+          @reserved_count -= 1
+          @available.push(instance)
+        end
+        nil
+      end
+
+      def delete(instance)
+        lock.synchronize do
+          instance.instance_variable_set(:@__pool, nil)
+          @reserved_count -= 1
+        end
+        nil
+      end
+
+      def size
+        @available.size + @reserved_count
+      end
+      alias length size
+
+      def inspect
+        "#<Extlib::Pooling::Pool<#{@resource.name}> available=#{@available.size} reserved_count=#{@reserved_count}>"
+      end
+
+      def flush!
+        @available.pop.dispose until @available.empty?
+      end
+
+      def dispose
+        flush!
+        @resource.__pools.delete(@args)
+        !Extlib::Pooling::pools.delete?(self).nil?
+      end
+
+      # Disabled temporarily.
+      #
+      # def expired?
+      #   lock.synchronize do
+      #     @available.each do |instance|
+      #       if instance.instance_variable_get(:@__allocated_in_pool) + scavenge_interval < Time.now
+      #         instance.dispose
+      #         @available.delete(instance)
+      #       end
+      #     end
+      #
+      #     size == 0
+      #   end
+      # end
+
+      def reserved_count
+        @reserved_count
+      end
+
+      private
+
+      def acquire
+        instance = if !@available.empty?
+          @available.pop
+        elsif size < @max_size
+          @resource.__new(*@args)
+        else
+          nil
+        end
+
+        if instance.nil?
+          instance
+        else
+          raise CrossPoolError.new(instance) if instance.instance_variable_get(:@__pool)
+          @reserved_count += 1
+          instance.instance_variable_set(:@__pool, self)
+          instance.instance_variable_set(:@__allocated_in_pool, Time.now)
+          instance
+        end
+      end
+    end
+
+    def self.scavenger_interval
+      60
+    end
+  end # module Pooling
+end # module Extlib