mack-facets 0.8.1 → 0.8.2

data/lib/gems/extlib-0.9.8/lib/extlib/module.rb

@@ -0,0 +1,41 @@
+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
+  
+  def try_dup
+    self
+  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/gems/extlib-0.9.8/lib/extlib/nil.rb

@@ -0,0 +1,5 @@
+class NilClass
+  def try_dup
+    self
+  end
+end

data/lib/gems/extlib-0.9.8/lib/extlib/numeric.rb

@@ -0,0 +1,5 @@
+class Numeric
+  def try_dup
+    self
+  end
+end

data/lib/gems/extlib-0.9.8/lib/extlib/object.rb

@@ -0,0 +1,175 @@
+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
+
+  # @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("::")
+    current_module = self
+    mod.each do |x|
+      unless current_module.const_defined?(x)
+        current_module.class_eval "module #{x}; end"
+      end
+      current_module = current_module.const_get(x)
+    end
+    current_module
+  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
+  
+  # Override this in a child if it cannot be dup'ed
+  #
+  # @return <Object>
+  def try_dup
+    self.dup
+  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
+  
+  # @note
+  #   For instances of objects that don't override the #inspect method, there
+  #   is an encoded hash to uniquely identify the object. This method
+  #   reproduces this to be used in #inspect in order to keep the same look
+  #   as well as provide this information.
+  #   This is inessential, but may be useful.
+  # 
+  # @return <String>
+  #   Returns the 16-byte encoded hash for the object
+  def encoded_hash
+    (self.hash * 2).to_s(16)
+  end
+
+  # Add instance_variable_defined? for backward compatibility
+  # @param variable<Symbol, String>
+  #
+  # @return <TrueClass, FalseClass>
+  #   True if the object has the given instance variable defined
+  unless respond_to?(:instance_variable_defined?)
+    def instance_variable_defined?(variable)
+      instance_variables.include?(variable.to_s)
+    end
+  end
+end

data/lib/gems/extlib-0.9.8/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/gems/extlib-0.9.8/lib/extlib/pathname.rb

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

data/lib/gems/extlib-0.9.8/lib/extlib/pooling.rb

@@ -0,0 +1,239 @@
+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 && @scavenger.alive?
+    end
+
+    def self.scavenger
+      if @scavenger.nil? || !@scavenger.alive?
+        @scavenger = Thread.new do
+          running = true
+          while running do
+            # Sleep before we actually start doing anything.
+            # Otherwise we might clean up something we just made
+            sleep(scavenger_interval)
+
+            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.expired?
+                    pool.dispose
+                  end
+                end
+                # end
+              end
+
+              # The pool is empty, we stop the scavenger
+              # It wil be restarted if new resources are added again
+              if pools.empty?
+                running = false
+              end
+            end
+          end # loop
+        end
+      end
+
+      @scavenger.priority = -10
+      @scavenger
+    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 InvalidResourceError < StandardError
+    end
+
+    class ThreadStopError < StandardError
+    end
+
+    def self.included(target)
+      target.class_eval do
+        class << self
+          alias __new new
+        end
+
+        @__pools     = {}
+        @__pool_lock = Mutex.new
+        @__pool_wait = ConditionVariable.new
+
+        def self.__pool_lock
+          @__pool_lock
+        end
+
+        def self.__pool_wait
+          @__pool_wait
+        end
+
+        def self.new(*args)
+          (@__pools[args] ||= __pool_lock.synchronize { Pool.new(self.pool_size, self, 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
+      attr_reader :available
+      attr_reader :used
+
+      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 = []
+        @used      = {}
+        Extlib::Pooling::append_pool(self)
+      end
+
+      def lock
+        @resource.__pool_lock
+      end
+
+      def wait
+        @resource.__pool_wait
+      end
+
+      def scavenge_interval
+        @resource.scavenge_interval
+      end
+
+      def new
+        instance = nil
+        begin
+          lock.synchronize do
+            if @available.size > 0
+              instance = @available.pop
+              @used[instance.object_id] = instance
+            elsif @used.size < @max_size
+              instance = @resource.__new(*@args)
+              raise InvalidResourceError.new("#{@resource} constructor created a nil object") if instance.nil?
+              raise InvalidResourceError.new("#{instance} is already part of the pool") if @used.include? instance
+              instance.instance_variable_set(:@__pool, self)
+              instance.instance_variable_set(:@__allocated_in_pool, Time.now)
+              @used[instance.object_id] = instance
+            else
+              # Let's see whether we have multiple threads
+              # If we do, there is a chance we might be released
+              # at some point in the future and thus we wait.
+              # If there are no other threads, we exhaust the pool
+              # here and there is no more hope... So we throw an
+              # exception.
+              if ThreadGroup::Default.list.size <= 2
+                raise ThreadStopError.new(size)
+              else
+                wait.wait(lock)
+              end
+            end
+          end
+        end until instance
+        instance
+      end
+
+      def release(instance)
+        instance.instance_variable_set(:@__allocated_in_pool, Time.now)
+        lock.synchronize do
+          @used.delete(instance.object_id)
+          @available.push(instance)
+          wait.signal
+        end
+        nil
+      end
+
+      def delete(instance)
+        lock.synchronize do
+          instance.instance_variable_set(:@__pool, nil)
+          @used.delete(instance.object_id)
+        end
+        nil
+      end
+
+      def size
+        @used.size + @available.size
+      end
+      alias length size
+
+      def inspect
+        "#<Extlib::Pooling::Pool<#{@resource.name}> available=#{@available.size} used=#{@used.size} size=#{@max_size}>"
+      end
+
+      def flush!
+        @available.pop.dispose until @available.empty?
+      end
+
+      def dispose
+        flush!
+        @resource.__pools.delete(@args)
+        !Extlib::Pooling::pools.delete?(self).nil?
+      end
+
+      def expired?
+        @available.each do |instance|
+          if Extlib.exiting || instance.instance_variable_get(:@__allocated_in_pool) + Extlib::Pooling.scavenger_interval <= Time.now
+            instance.dispose
+            @available.delete(instance)
+          end
+        end
+
+        size == 0
+      end
+
+    end
+
+    def self.scavenger_interval
+      60
+    end
+  end # module Pooling
+end # module Extlib