mack-facets 0.8.2 → 0.8.3

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

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

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

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

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

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

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

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

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

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

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