extlib 0.9.2

data/lib/extlib/lazy_array.rb

@@ -0,0 +1,104 @@
+class LazyArray  # borrowed partially from StrokeDB
+  include Enumerable
+
+  # these methods should return self or nil
+  RETURN_SELF = [ :<<, :clear, :concat, :collect!, :each, :each_index,
+    :each_with_index, :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/module.rb

@@ -0,0 +1,19 @@
+class Module
+  def find_const(nested_name)
+    self.__nested_constants__[nested_name]
+  rescue NameError
+    Object::__nested_constants__[nested_name]
+  end
+
+  protected  
+  def __nested_constants__
+    @__nested_constants__ ||= Hash.new do |h,k|
+      klass = self
+      k.split('::').each do |c|
+        klass = klass.const_get(c) unless c.empty?
+      end
+      h[k] = klass
+    end
+  end
+  
+end # class Module

data/lib/extlib/object.rb

@@ -0,0 +1,7 @@
+class Object
+  unless instance_methods.include?('instance_variable_defined?')
+    def instance_variable_defined?(method)
+      instance_variables.include?(method.to_s)
+    end
+  end
+end # class Object

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,227 @@
+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 aquired 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|
+                if pool.expired?
+                  pool.lock.synchronize do
+                    if pool.size == 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
+          1
+        end
+
+        def self.scavenge_interval
+          10
+        end
+      end
+    end
+
+    def release
+      @__pool.release(self)
+    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 = Set.new
+
+        Extlib::Pooling::append_pool(self)
+      end
+
+      def lock
+        @resource.__pool_lock
+      end
+
+      def scavenge_interval
+        @resource.scavenge_interval
+      end
+
+      def new
+        instance = nil
+
+        lock.synchronize do
+          instance = aquire
+        end
+
+        if instance.nil?
+          # Account for the current thread, and the pool scavenger.
+          if ThreadGroup::Default.list.size == 2 && @reserved.size >= @max_size
+            raise ThreadStopError.new(size)
+          else
+            sleep(0.01)
+            new
+          end
+        else
+          instance
+        end
+      end
+
+      def release(instance)
+        lock.synchronize do
+          raise OrphanedObjectError.new(instance) unless @reserved.delete?(instance)
+          instance.instance_variable_set(:@__pool, nil)
+          @available.push(instance)
+        end
+        nil
+      end
+
+      def size
+        @available.size + @reserved.size
+      end
+      alias length size
+
+      def inspect
+        "#<Extlib::Pooling::Pool<#{@resource.name}> available=#{@available.size} reserved=#{@reserved.size}>"
+      end
+
+      def flush!
+        lock.synchronize do
+          @available.each do |instance|
+            instance.dispose
+          end
+          @available.clear
+        end
+      end
+
+      def dispose
+        @resource.__pools.delete(@args)
+        !Extlib::Pooling::pools.delete?(self).nil?
+      end
+
+      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
+
+      private
+
+      def aquire
+        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 << instance
+          instance.instance_variable_set(:@__pool, self)
+          instance.instance_variable_set(:@__allocated_in_pool, Time.now)
+          instance
+        end
+      end
+    end
+
+    private
+    def self.scavenger_interval
+      60
+    end
+  end # module Pooling
+end # module Extlib

data/lib/extlib/string.rb

@@ -0,0 +1,45 @@
+class String
+  # Overwrite this method to provide your own translations.
+  def self.translate(value)
+    translations[value] || value
+  end
+
+  def self.translations
+    @translations ||= {}
+  end
+
+  # Matches any whitespace (including newline) and replaces with a single space
+  #
+  # @example
+  #   <<QUERY.compress_lines
+  #     SELECT name
+  #     FROM users
+  #   QUERY
+  #   => "SELECT name FROM users"
+  def compress_lines(spaced = true)
+    split($/).map { |line| line.strip }.join(spaced ? ' ' : '')
+  end
+
+  # Useful for heredocs - removes whitespace margin.
+  def margin(indicator = nil)
+    lines = self.dup.split($/)
+
+    min_margin = 0
+    lines.each do |line|
+      if line =~ /^(\s+)/ && (min_margin == 0 || $1.size < min_margin)
+        min_margin = $1.size
+      end
+    end
+    lines.map { |line| line.sub(/^\s{#{min_margin}}/, '') }.join($/)
+  end
+
+ # Formats String for easy translation. Replaces an arbitrary number of
+  # values using numeric identifier replacement.
+  #
+  # @example
+  # "%s %s %s" % %w(one two three) #=> "one two three"
+  # "%3$s %2$s %1$s" % %w(one two three) #=> "three two one"
+  def t(*values)
+    self.class::translate(self) % values
+  end
+end # class String

data/lib/extlib/struct.rb

@@ -0,0 +1,8 @@
+class Struct
+  # Returns a hash containing the names and values for all instance variables in the Struct.
+  def attributes
+    h = {}
+    each_pair { |k,v| h[k] = v }
+    h
+  end
+end # class Struct

data/spec/blank_spec.rb

@@ -0,0 +1,85 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe Object do
+  it 'should provide blank?' do
+    Object.new.should respond_to(:blank?)
+  end
+
+  it 'should be blank if it is nil' do
+    object = Object.new
+    class << object
+      def nil?; true end
+    end
+    object.should be_blank
+  end
+
+  it 'should be blank if it is empty' do
+    {}.should be_blank
+    [].should be_blank
+  end
+
+  it 'should not be blank if not nil or empty' do
+    Object.new.should_not be_blank
+    [nil].should_not be_blank
+    { nil => 0 }.should_not be_blank
+  end
+end
+
+describe Numeric do
+  it 'should provide blank?' do
+    1.should respond_to(:blank?)
+  end
+
+  it 'should never be blank' do
+    1.should_not be_blank
+  end
+end
+
+describe NilClass do
+  it 'should provide blank?' do
+    nil.should respond_to(:blank?)
+  end
+
+  it 'should always be blank' do
+    nil.should be_blank
+  end
+end
+
+describe TrueClass do
+  it 'should provide blank?' do
+    true.should respond_to(:blank?)
+  end
+
+  it 'should never be blank' do
+    true.should_not be_blank
+  end
+end
+
+describe FalseClass do
+  it 'should provide blank?' do
+    false.should respond_to(:blank?)
+  end
+
+  it 'should always be blank' do
+    false.should be_blank
+  end
+end
+
+describe String do
+  it 'should provide blank?' do
+    'string'.should respond_to(:blank?)
+  end
+
+  it 'should be blank if empty' do
+    ''.should be_blank
+  end
+
+  it 'should be blank if it only contains whitespace' do
+    ' '.should be_blank
+    " \r \n \t ".should be_blank
+  end
+
+  it 'should not be blank if it contains non-whitespace' do
+    ' a '.should_not be_blank
+  end
+end