sundbp-extlib 0.9.14

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,20 @@
+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
+
+  # alias to_s to to_str when to_str not defined
+  unless public_instance_methods(false).any? { |m| m.to_sym == :to_str }
+    alias to_str to_s
+  end
+end # class Pathname

data/lib/extlib/pooling.rb

@@ -0,0 +1,235 @@
+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?
+      defined?(@scavenger) && !@scavenger.nil? && @scavenger.alive?
+    end
+
+    def self.scavenger
+      unless scavenger?
+        @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
+
+    def detach
+      @__pool.delete(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

data/lib/extlib/rubygems.rb

@@ -0,0 +1,38 @@
+# this is a temporary workaround until rubygems Does the Right thing here
+require 'rubygems'
+module Gem
+  class SourceIndex
+
+    # This is resolved in 1.1
+    if Version.new(RubyGemsVersion) < Version.new("1.1")
+
+      # Overwrite this so that a gem of the same name and version won't push one
+      # from the gems directory out entirely.
+      #
+      # @param gem_spec<Gem::Specification> The specification of the gem to add.
+      def add_spec(gem_spec)
+        unless gem_spec.instance_variable_get("@loaded_from") &&
+          @gems[gem_spec.full_name].is_a?(Gem::Specification) &&
+          @gems[gem_spec.full_name].installation_path ==
+            File.join(defined?(Merb) && Merb.respond_to?(:root) ? Merb.root : Dir.pwd,"gems")
+
+          @gems[gem_spec.full_name] = gem_spec
+        end
+      end
+
+    end
+
+  end
+
+  class Specification
+
+    # Overwrite this so that gems in the gems directory get preferred over gems
+    # from any other location. If there are two gems of different versions in
+    # the gems directory, the later one will load as usual.
+    #
+    # @return [Array<Array>] The object used for sorting gem specs.
+    def sort_obj
+      [@name, installation_path == File.join(defined?(Merb) && Merb.respond_to?(:root) ? Merb.root : Dir.pwd,"gems") ? 1 : -1, @version.to_ints, @new_platform == Gem::Platform::RUBY ? -1 : 1]
+    end
+  end
+end

data/lib/extlib/simple_set.rb

@@ -0,0 +1,66 @@
+module Extlib
+  # Simple set implementation
+  # on top of Hash with merging support.
+  #
+  # In particular this is used to store
+  # a set of callable actions of controller.
+  class SimpleSet < Hash
+
+    ##
+    # Create a new SimpleSet containing the unique members of _arr_
+    #
+    # @param [Array] arr Initial set values.
+    #
+    # @return [Array] The array the Set was initialized with
+    #
+    # @api public
+    def initialize(arr = [])
+      Array(arr).each {|x| self[x] = true}
+    end
+
+    ##
+    # Add a value to the set, and return it
+    #
+    # @param [Object] value Value to add to set.
+    #
+    # @return [SimpleSet] Receiver
+    #
+    # @api public
+    def <<(value)
+      self[value] = true
+      self
+    end
+
+    ##
+    # Merge _arr_ with receiver, producing the union of receiver & _arr_
+    #
+    #   s = Extlib::SimpleSet.new([:a, :b, :c])
+    #   s.merge([:c, :d, :e, f])  #=> #<SimpleSet: {:e, :c, :f, :a, :d, :b}>
+    #
+    # @param [Array] arr Values to merge with set.
+    #
+    # @return [SimpleSet] The set after the Array was merged in.
+    #
+    # @api public
+    def merge(arr)
+      super(arr.inject({}) {|s,x| s[x] = true; s })
+    end
+
+    ##
+    # Get a human readable version of the set.
+    #
+    #   s = SimpleSet.new([:a, :b, :c])
+    #   s.inspect                 #=> "#<SimpleSet: {:c, :a, :b}>"
+    #
+    # @return [String] A human readable version of the set.
+    #
+    # @api public
+    def inspect
+      "#<SimpleSet: {#{keys.map {|x| x.inspect}.join(", ")}}>"
+    end
+
+    # def to_a
+    alias_method :to_a, :keys
+
+  end # SimpleSet
+end # Merb

data/lib/extlib/string.rb

@@ -0,0 +1,176 @@
+require "pathname"
+
+class String
+  ##
+  # Escape all regexp special characters.
+  #
+  #   "*?{}.".escape_regexp   #=> "\\*\\?\\{\\}\\."
+  #
+  # @return [String] Receiver with all regexp special characters escaped.
+  #
+  # @api public
+  def escape_regexp
+    Regexp.escape self
+  end
+
+  ##
+  # Unescape all regexp special characters.
+  #
+  #   "\\*\\?\\{\\}\\.".unescape_regexp #=> "*?{}."
+  #
+  # @return [String] Receiver with all regexp special characters unescaped.
+  #
+  # @api public
+  def unescape_regexp
+    self.gsub(/\\([\.\?\|\(\)\[\]\{\}\^\$\*\+\-])/, '\1')
+  end
+
+  ##
+  # Convert to snake case.
+  #
+  #   "FooBar".snake_case           #=> "foo_bar"
+  #   "HeadlineCNNNews".snake_case  #=> "headline_cnn_news"
+  #   "CNN".snake_case              #=> "cnn"
+  #
+  # @return [String] Receiver converted to snake case.
+  #
+  # @api public
+  def snake_case
+    return downcase if match(/\A[A-Z]+\z/)
+    gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+    gsub(/([a-z])([A-Z])/, '\1_\2').
+    downcase
+  end
+
+  ##
+  # Convert to camel case.
+  #
+  #   "foo_bar".camel_case          #=> "FooBar"
+  #
+  # @return [String] Receiver converted to camel case.
+  #
+  # @api public
+  def camel_case
+    return self if self !~ /_/ && self =~ /[A-Z]+.*/
+    split('_').map{|e| e.capitalize}.join
+  end
+
+  ##
+  # Convert a path string to a constant name.
+  #
+  #   "merb/core_ext/string".to_const_string #=> "Merb::CoreExt::String"
+  #
+  # @return [String] Receiver converted to a constant name.
+  #
+  # @api public
+  def to_const_string
+    gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+  end
+
+  ##
+  # Convert a constant name to a path, assuming a conventional structure.
+  #
+  #   "FooBar::Baz".to_const_path # => "foo_bar/baz"
+  #
+  # @return [String] Path to the file containing the constant named by receiver
+  #   (constantized string), assuming a conventional structure.
+  #
+  # @api public
+  def to_const_path
+    snake_case.gsub(/::/, "/")
+  end
+
+  ##
+  # Join with _o_ as a file path.
+  #
+  #   "merb"/"core_ext" #=> "merb/core_ext"
+  #
+  # @param [String] o Path component to join with receiver.
+  #
+  # @return [String] Receiver joined with o as a file path.
+  #
+  # @api public
+  def /(o)
+    File.join(self, o.to_s)
+  end
+
+  ##
+  # Calculate a relative path *from* _other_.
+  #
+  #   "/opt/local/lib".relative_path_from("/opt/local/lib/ruby/site_ruby") # => "../.."
+  #
+  # @param [String] other Base path to calculate *from*.
+  #
+  # @return [String] Relative path from _other_ to receiver.
+  #
+  # @api public
+  def relative_path_from(other)
+    Pathname.new(self).relative_path_from(Pathname.new(other)).to_s
+  end
+
+  # Overwrite this method to provide your own translations.
+  def self.translate(value)
+    translations[value] || value
+  end
+
+  def self.translations
+    @translations ||= {}
+  end
+
+  ##
+  # Replace sequences of whitespace (including newlines) with either
+  # a single space or remove them entirely (according to param _spaced_)
+  #
+  #   <<QUERY.compress_lines
+  #     SELECT name
+  #     FROM users
+  #   QUERY => "SELECT name FROM users"
+  #
+  # @param [TrueClass, FalseClass] spaced (default=true)
+  #   Determines whether returned string has whitespace collapsed or removed
+  #
+  # @return [String] Receiver with whitespace (including newlines) replaced
+  #
+  # @api public
+  def compress_lines(spaced = true)
+    split($/).map { |line| line.strip }.join(spaced ? ' ' : '')
+  end
+
+  ##
+  # Remove whitespace margin.
+  #
+  # @param [Object] indicator ???
+  #
+  # @return [String] receiver with whitespace margin removed
+  #
+  # @api public
+  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.
+  #
+  #   "%s %s %s" % %w(one two three)        #=> "one two three"
+  #   "%3$s %2$s %1$s" % %w(one two three)  #=> "three two one"
+  #
+  # @param [#to_s] values
+  #   A list of values to translate and interpolate into receiver
+  #
+  # @return [String]
+  #   Receiver translated with values translated and interpolated positionally
+  #
+  # @api public
+  def t(*values)
+    self.class::translate(self) % values.collect! { |value| value.frozen? ? value : self.class::translate(value.to_s) }
+  end
+end # class String