thorero 0.9.4.4 → 0.9.4.5

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

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

data/lib/extlib/pooling.rb

@@ -1,233 +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 || begin
-        @scavenger = Thread.new do
-          loop do
-            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.reserved_count == 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
-          8
-        end
-      end
-    end
-
-    def release
-      @__pool.release(self) unless @__pool.nil?
-    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_count = 0
-      end
-
-      def lock
-        @resource.__pool_lock
-      end
-
-      def scavenge_interval
-        @resource.scavenge_interval
-      end
-
-      def new
-        instance = nil
-
-        lock.synchronize do
-          instance = acquire
-        end
-
-        Extlib::Pooling::append_pool(self)
-
-        if instance.nil?
-          # Account for the current thread, and the pool scavenger.
-          if ThreadGroup::Default.list.size == 2 && @reserved_count >= @max_size
-            raise ThreadStopError.new(size)
-          else
-            sleep(0.05)
-            new
-          end
-        else
-          instance
-        end
-      end
-
-      def release(instance)
-        lock.synchronize do
-          instance.instance_variable_set(:@__pool, nil)
-          @reserved_count -= 1
-          @available.push(instance)
-        end
-        nil
-      end
-
-      def delete(instance)
-        lock.synchronize do
-          instance.instance_variable_set(:@__pool, nil)
-          @reserved_count -= 1
-        end
-        nil
-      end
-
-      def size
-        @available.size + @reserved_count
-      end
-      alias length size
-
-      def inspect
-        "#<Extlib::Pooling::Pool<#{@resource.name}> available=#{@available.size} reserved_count=#{@reserved_count}>"
-      end
-
-      def flush!
-        @available.pop.dispose until @available.empty?
-      end
-
-      def dispose
-        flush!
-        @resource.__pools.delete(@args)
-        !Extlib::Pooling::pools.delete?(self).nil?
-      end
-
-      # Disabled temporarily.
-      #
-      # 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
-
-      def reserved_count
-        @reserved_count
-      end
-
-      private
-
-      def acquire
-        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_count += 1
-          instance.instance_variable_set(:@__pool, self)
-          instance.instance_variable_set(:@__allocated_in_pool, Time.now)
-          instance
-        end
-      end
-    end
-
-    def self.scavenger_interval
-      60
-    end
-  end # module Pooling
-end # module Extlib

data/lib/extlib/rubygems.rb

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

@@ -1,39 +0,0 @@
-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
-
-    # @param arr<Array> Initial set values.
-    #
-    # @return <Array> The array the Set was initialized with
-    def initialize(arr = [])
-      arr.each {|x| self[x] = true}
-    end
-
-    # @param value<Object> Value to add to set.
-    #
-    # @return <TrueClass>
-    def <<(value)
-      self[value] = true
-    end
-
-    # @param arr<Array> Values to merge with set.
-    #
-    # @return <SimpleSet> The set after the Array was merged in.
-    def merge(arr)
-      super(arr.inject({}) {|s,x| s[x] = true; s })
-    end
-
-    # @return <String> A human readable version of the set.
-    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

@@ -1,132 +0,0 @@
-require "pathname"
-
-class String
-  ##
-  # @return <String> The string with all regexp special characters escaped.
-  #
-  # @example
-  #   "*?{}.".escape_regexp #=> "\\*\\?\\{\\}\\."
-  def escape_regexp
-    Regexp.escape self
-  end
-  
-  ##
-  # @return String The string with all regexp special characters unescaped.
-  #
-  # @example
-  #   "\\*\\?\\{\\}\\.".unescape_regexp #=> "*?{}."
-  def unescape_regexp
-    self.gsub(/\\([\.\?\|\(\)\[\]\{\}\^\$\*\+\-])/, '\1')
-  end
-  
-  ##
-  # @return <String> The string converted to snake case.
-  #
-  # @example
-  #   "FooBar".snake_case #=> "foo_bar"
-  # @example
-  #   "HeadlineCNNNews".snake_case #=> "headline_cnn_news"
-  # @example
-  #   "CNN".snake_case #=> "cnn"
-  def snake_case
-    return self.downcase if self =~ /^[A-Z]+$/
-    self.gsub(/([A-Z]+)(?=[A-Z][a-z]?)|\B[A-Z]/, '_\&') =~ /_*(.*)/
-      return $+.downcase
-  end
-
-  ##
-  # @return <String> The string converted to camel case.
-  #
-  # @example
-  #   "foo_bar".camel_case #=> "FooBar"
-  def camel_case
-    return self if self !~ /_/ && self =~ /[A-Z]+.*/
-    split('_').map{|e| e.capitalize}.join
-  end
-
-  ##
-  # @return <String> The path string converted to a constant name.
-  #
-  # @example
-  #   "merb/core_ext/string".to_const_string #=> "Merb::CoreExt::String"
-  def to_const_string
-    gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-  end
-
-  ##
-  # @return <String>
-  #   The path that is associated with the constantized string, assuming a
-  #   conventional structure.
-  #
-  # @example
-  #   "FooBar::Baz".to_const_path # => "foo_bar/baz"
-  def to_const_path
-    snake_case.gsub(/::/, "/")
-  end
-
-  ##
-  # @param o<String> The path component to join with the string.
-  #
-  # @return <String> The original path concatenated with o.
-  #
-  # @example
-  #   "merb"/"core_ext" #=> "merb/core_ext"
-  def /(o)
-    File.join(self, o.to_s)
-  end
-
-  ##
-  # @param other<String> Base path to calculate against
-  #
-  # @return <String> Relative path from between the two
-  #
-  # @example
-  #   "/opt/local/lib".relative_path_from("/opt/local/lib/ruby/site_ruby") # => "../.."
-  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
-
-  # 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