mack-facets 0.8.2 → 0.8.3

data/lib/gems/extlib-0.9.9/lib/extlib/mash.rb

@@ -0,0 +1,148 @@
+# 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
+
+  # @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
+
+  # @param *rejected<Array[(String, Symbol)] The mash keys to exclude.
+  #
+  # @return <Mash> A new mash without the selected keys.
+  #
+  # @example
+  #   { :one => 1, :two => 2, :three => 3 }.except(:one)
+  #     #=> { "two" => 2, "three" => 3 }
+  def except(*keys)
+    super(*keys.map {|k| convert_key(k)})
+  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)
+    if value.class == Hash
+      value.to_mash
+    elsif value.is_a?(Array)
+      value.collect { |e| convert_value(e) }
+    else
+      value
+    end
+  end
+end

data/lib/gems/extlib-0.9.9/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.9/lib/extlib/nil.rb

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

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

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

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

@@ -0,0 +1,162 @@
+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
+
+  # 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.9/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.9/lib/extlib/pathname.rb

@@ -0,0 +1,15 @@
+class Pathname
+  # Append path segments and expand to absolute path
+  #
+  #   file = Pathname(Dir.pwd) / "subdir1" / :subdir2 / "filename.ext"
+  #
+  # @param [Pathname, String, #to_s] path path segment to concatenate with receiver
+  #
+  # @return [Pathname]
+  #   receiver with _path_ appended and expanded to an absolute path
+  #
+  # @api public
+  def /(path)
+    (self + path).expand_path
+  end
+end # class Pathname

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

@@ -0,0 +1,231 @@
+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
+
+    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
+              # Wait for another thread to release an instance.
+              # If we exhaust the pool and don't release the active instance,
+              # we'll wait here forever, so it's *very* important to always
+              # release your services and *never* exhaust the pool within
+              # a single thread.
+              wait.wait(lock)
+            end
+          end
+        end until instance
+        instance
+      end
+
+      def release(instance)
+        lock.synchronize do
+          instance.instance_variable_set(:@__allocated_in_pool, Time.now)
+          @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)
+          wait.signal
+        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 + 0.02)
+            instance.dispose
+            @available.delete(instance)
+          end
+        end
+        size == 0
+      end
+
+    end
+
+    def self.scavenger_interval
+      60
+    end
+  end # module Pooling
+end # module Extlib