abiquo-etk 0.4.13

data/vendor/activesupport-2.3.8/README

@@ -0,0 +1,43 @@
+= Active Support -- Utility classes and standard library extensions from Rails
+
+Active Support is a collection of various utility classes and standard library extensions that were found useful
+for Rails. All these additions have hence been collected in this bundle as way to gather all that sugar that makes
+Ruby sweeter.
+
+
+== Download
+
+The latest version of Active Support can be found at
+
+* http://rubyforge.org/project/showfiles.php?group_id=182
+
+Documentation can be found at 
+
+* http://as.rubyonrails.com
+
+
+== Installation
+
+The preferred method of installing Active Support is through its GEM file. You'll need to have
+RubyGems[http://rubygems.rubyforge.org/wiki/wiki.pl] installed for that, though. If you have it,
+then use:
+
+  % [sudo] gem install activesupport-1.0.0.gem
+
+
+== License
+
+Active Support is released under the MIT license.
+
+
+== Support
+
+The Active Support homepage is http://www.rubyonrails.com. You can find the Active Support
+RubyForge page at http://rubyforge.org/projects/activesupport. And as Jim from Rake says:
+
+   Feel free to submit commits or feature requests.  If you send a patch,
+   remember to update the corresponding unit tests.  If fact, I prefer
+   new feature to be submitted in the form of new unit tests.
+
+For other information, feel free to ask on the ruby-talk mailing list
+(which is mirrored to comp.lang.ruby) or contact mailto:david@loudthinking.com.

data/vendor/activesupport-2.3.8/lib/active_support/all.rb

@@ -0,0 +1,8 @@
+# For forward compatibility with Rails 3.
+#
+# require 'active_support' loads a very bare minumum in Rails 3.
+# require 'active_support/all' loads the whole suite like Rails 2 did.
+#
+# To prepare for Rails 3, switch to require 'active_support/all' now.
+
+require 'active_support'

data/vendor/activesupport-2.3.8/lib/active_support/backtrace_cleaner.rb

@@ -0,0 +1,72 @@
+module ActiveSupport
+  # Many backtraces include too much information that's not relevant for the context. This makes it hard to find the signal
+  # in the backtrace and adds debugging time. With a BacktraceCleaner, you can setup filters and silencers for your particular
+  # context, so only the relevant lines are included.
+  #
+  # If you need to reconfigure an existing BacktraceCleaner, like the one in Rails, to show as much as possible, you can always
+  # call BacktraceCleaner#remove_silencers!
+  #
+  # Example:
+  #
+  #   bc = BacktraceCleaner.new
+  #   bc.add_filter   { |line| line.gsub(Rails.root, '') } 
+  #   bc.add_silencer { |line| line =~ /mongrel|rubygems/ }
+  #   bc.clean(exception.backtrace) # will strip the Rails.root prefix and skip any lines from mongrel or rubygems
+  #
+  # Inspired by the Quiet Backtrace gem by Thoughtbot.
+  class BacktraceCleaner
+    def initialize
+      @filters, @silencers = [], []
+    end
+    
+    # Returns the backtrace after all filters and silencers has been run against it. Filters run first, then silencers.
+    def clean(backtrace)
+      silence(filter(backtrace))
+    end
+
+    # Adds a filter from the block provided. Each line in the backtrace will be mapped against this filter.
+    #
+    # Example:
+    #
+    #   # Will turn "/my/rails/root/app/models/person.rb" into "/app/models/person.rb"
+    #   backtrace_cleaner.add_filter { |line| line.gsub(Rails.root, '') }
+    def add_filter(&block)
+      @filters << block
+    end
+
+    # Adds a silencer from the block provided. If the silencer returns true for a given line, it'll be excluded from the
+    # clean backtrace.
+    #
+    # Example:
+    #
+    #   # Will reject all lines that include the word "mongrel", like "/gems/mongrel/server.rb" or "/app/my_mongrel_server/rb"
+    #   backtrace_cleaner.add_silencer { |line| line =~ /mongrel/ }
+    def add_silencer(&block)
+      @silencers << block
+    end
+
+    # Will remove all silencers, but leave in the filters. This is useful if your context of debugging suddenly expands as
+    # you suspect a bug in the libraries you use.
+    def remove_silencers!
+      @silencers = []
+    end
+
+    
+    private
+      def filter(backtrace)
+        @filters.each do |f|
+          backtrace = backtrace.map { |line| f.call(line) }
+        end
+        
+        backtrace
+      end
+      
+      def silence(backtrace)
+        @silencers.each do |s|
+          backtrace = backtrace.reject { |line| s.call(line) }
+        end
+        
+        backtrace
+      end
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/base64.rb

@@ -0,0 +1,33 @@
+begin
+  require 'base64'
+rescue LoadError
+end
+
+module ActiveSupport
+  if defined? ::Base64
+    Base64 = ::Base64
+  else
+    # Base64 provides utility methods for encoding and de-coding binary data 
+    # using a base 64 representation. A base 64 representation of binary data
+    # consists entirely of printable US-ASCII characters. The Base64 module
+    # is included in Ruby 1.8, but has been removed in Ruby 1.9.
+    module Base64
+      # Encodes a string to its base 64 representation. Each 60 characters of
+      # output is separated by a newline character.
+      #
+      #  ActiveSupport::Base64.encode64("Original unencoded string") 
+      #  # => "T3JpZ2luYWwgdW5lbmNvZGVkIHN0cmluZw==\n"
+      def self.encode64(data)
+        [data].pack("m")
+      end
+
+      # Decodes a base 64 encoded string to its original representation.
+      #
+      #  ActiveSupport::Base64.decode64("T3JpZ2luYWwgdW5lbmNvZGVkIHN0cmluZw==") 
+      #  # => "Original unencoded string"
+      def self.decode64(data)
+        data.unpack("m").first
+      end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/basic_object.rb

@@ -0,0 +1,24 @@
+# A base class with no predefined methods that tries to behave like Builder's
+# BlankSlate in Ruby 1.9. In Ruby pre-1.9, this is actually the
+# Builder::BlankSlate class.
+#
+# Ruby 1.9 introduces BasicObject which differs slightly from Builder's
+# BlankSlate that has been used so far. ActiveSupport::BasicObject provides a
+# barebones base class that emulates Builder::BlankSlate while still relying on
+# Ruby 1.9's BasicObject in Ruby 1.9.
+module ActiveSupport
+  if defined? ::BasicObject
+    class BasicObject < ::BasicObject
+      undef_method :==
+      undef_method :equal?
+
+      # Let ActiveSupport::BasicObject at least raise exceptions.
+      def raise(*args)
+        ::Object.send(:raise, *args)
+      end
+    end
+  else
+    require 'blankslate'
+    BasicObject = BlankSlate
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/buffered_logger.rb

@@ -0,0 +1,127 @@
+module ActiveSupport
+  # Inspired by the buffered logger idea by Ezra
+  class BufferedLogger
+    module Severity
+      DEBUG   = 0
+      INFO    = 1
+      WARN    = 2
+      ERROR   = 3
+      FATAL   = 4
+      UNKNOWN = 5
+    end
+    include Severity
+
+    MAX_BUFFER_SIZE = 1000
+
+    ##
+    # :singleton-method:
+    # Set to false to disable the silencer
+    cattr_accessor :silencer
+    self.silencer = true
+
+    # Silences the logger for the duration of the block.
+    def silence(temporary_level = ERROR)
+      if silencer
+        begin
+          old_logger_level, self.level = level, temporary_level
+          yield self
+        ensure
+          self.level = old_logger_level
+        end
+      else
+        yield self
+      end
+    end
+
+    attr_accessor :level
+    attr_reader :auto_flushing
+
+    def initialize(log, level = DEBUG)
+      @level         = level
+      @buffer        = {}
+      @auto_flushing = 1
+      @guard = Mutex.new
+
+      if log.respond_to?(:write)
+        @log = log
+      elsif File.exist?(log)
+        @log = open(log, (File::WRONLY | File::APPEND))
+        @log.sync = true
+      else
+        FileUtils.mkdir_p(File.dirname(log))
+        @log = open(log, (File::WRONLY | File::APPEND | File::CREAT))
+        @log.sync = true
+        @log.write("# Logfile created on %s" % [Time.now.to_s])
+      end
+    end
+
+    def add(severity, message = nil, progname = nil, &block)
+      return if @level > severity
+      message = (message || (block && block.call) || progname).to_s
+      # If a newline is necessary then create a new message ending with a newline.
+      # Ensures that the original message is not mutated.
+      message = "#{message}\n" unless message[-1] == ?\n
+      buffer << message
+      auto_flush
+      message
+    end
+
+    for severity in Severity.constants
+      class_eval <<-EOT, __FILE__, __LINE__ + 1
+        def #{severity.downcase}(message = nil, progname = nil, &block)  # def debug(message = nil, progname = nil, &block)
+          add(#{severity}, message, progname, &block)                    #   add(DEBUG, message, progname, &block)
+        end                                                              # end
+                                                                         #
+        def #{severity.downcase}?                                        # def debug?
+          #{severity} >= @level                                          #   DEBUG >= @level
+        end                                                              # end
+      EOT
+    end
+
+    # Set the auto-flush period. Set to true to flush after every log message,
+    # to an integer to flush every N messages, or to false, nil, or zero to
+    # never auto-flush. If you turn auto-flushing off, be sure to regularly
+    # flush the log yourself -- it will eat up memory until you do.
+    def auto_flushing=(period)
+      @auto_flushing =
+        case period
+        when true;                1
+        when false, nil, 0;       MAX_BUFFER_SIZE
+        when Integer;             period
+        else raise ArgumentError, "Unrecognized auto_flushing period: #{period.inspect}"
+        end
+    end
+
+    def flush
+      @guard.synchronize do
+        unless buffer.empty?
+          old_buffer = buffer
+          @log.write(old_buffer.join)
+        end
+
+        # Important to do this even if buffer was empty or else @buffer will
+        # accumulate empty arrays for each request where nothing was logged.
+        clear_buffer
+      end
+    end
+
+    def close
+      flush
+      @log.close if @log.respond_to?(:close)
+      @log = nil
+    end
+
+    protected
+      def auto_flush
+        flush if buffer.size >= @auto_flushing
+      end
+
+      def buffer
+        @buffer[Thread.current] ||= []
+      end
+
+      def clear_buffer
+        @buffer.delete(Thread.current)
+      end
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/cache/compressed_mem_cache_store.rb

@@ -0,0 +1,20 @@
+module ActiveSupport
+  module Cache
+    class CompressedMemCacheStore < MemCacheStore
+      def read(name, options = nil)
+        if value = super(name, (options || {}).merge(:raw => true))
+          if raw?(options)
+            value
+          else
+            Marshal.load(ActiveSupport::Gzip.decompress(value))
+          end
+        end
+      end
+
+      def write(name, value, options = nil)
+        value = ActiveSupport::Gzip.compress(Marshal.dump(value)) unless raw?(options)
+        super(name, value, (options || {}).merge(:raw => true))
+      end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/cache/drb_store.rb

@@ -0,0 +1,14 @@
+module ActiveSupport
+  module Cache
+    class DRbStore < MemoryStore #:nodoc:
+      attr_reader :address
+
+      def initialize(address = 'druby://localhost:9192')
+        require 'drb' unless defined?(DRbObject)
+        super()
+        @address = address
+        @data = DRbObject.new(nil, address)
+      end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/cache/file_store.rb

@@ -0,0 +1,72 @@
+module ActiveSupport
+  module Cache
+    # A cache store implementation which stores everything on the filesystem.
+    class FileStore < Store
+      attr_reader :cache_path
+
+      def initialize(cache_path)
+        @cache_path = cache_path
+      end
+
+      def read(name, options = nil)
+        super
+        File.open(real_file_path(name), 'rb') { |f| Marshal.load(f) } rescue nil
+      end
+
+      def write(name, value, options = nil)
+        super
+        ensure_cache_path(File.dirname(real_file_path(name)))
+        File.atomic_write(real_file_path(name), cache_path) { |f| Marshal.dump(value, f) }
+        value
+      rescue => e
+        logger.error "Couldn't create cache directory: #{name} (#{e.message})" if logger
+      end
+
+      def delete(name, options = nil)
+        super
+        File.delete(real_file_path(name))
+      rescue SystemCallError => e
+        # If there's no cache, then there's nothing to complain about
+      end
+
+      def delete_matched(matcher, options = nil)
+        super
+        search_dir(@cache_path) do |f|
+          if f =~ matcher
+            begin
+              File.delete(f)
+            rescue SystemCallError => e
+              # If there's no cache, then there's nothing to complain about
+            end
+          end
+        end
+      end
+
+      def exist?(name, options = nil)
+        super
+        File.exist?(real_file_path(name))
+      end
+
+      private
+        def real_file_path(name)
+          '%s/%s.cache' % [@cache_path, name.gsub('?', '.').gsub(':', '.')]
+        end
+
+        def ensure_cache_path(path)
+          FileUtils.makedirs(path) unless File.exist?(path)
+        end
+
+        def search_dir(dir, &callback)
+          Dir.foreach(dir) do |d|
+            next if d == "." || d == ".."
+            name = File.join(dir, d)
+            if File.directory?(name)
+              search_dir(name, &callback)
+            else
+              callback.call name
+            end
+          end
+        end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/cache/mem_cache_store.rb

@@ -0,0 +1,143 @@
+require 'memcache'
+
+module ActiveSupport
+  module Cache
+    # A cache store implementation which stores data in Memcached:
+    # http://www.danga.com/memcached/
+    #
+    # This is currently the most popular cache store for production websites.
+    #
+    # Special features:
+    # - Clustering and load balancing. One can specify multiple memcached servers,
+    #   and MemCacheStore will load balance between all available servers. If a
+    #   server goes down, then MemCacheStore will ignore it until it goes back
+    #   online.
+    # - Time-based expiry support. See #write and the +:expires_in+ option.
+    # - Per-request in memory cache for all communication with the MemCache server(s).
+    class MemCacheStore < Store
+      module Response # :nodoc:
+        STORED      = "STORED\r\n"
+        NOT_STORED  = "NOT_STORED\r\n"
+        EXISTS      = "EXISTS\r\n"
+        NOT_FOUND   = "NOT_FOUND\r\n"
+        DELETED     = "DELETED\r\n"
+      end
+
+      def self.build_mem_cache(*addresses)
+        addresses = addresses.flatten
+        options = addresses.extract_options!
+        addresses = ["localhost"] if addresses.empty?
+        MemCache.new(addresses, options)
+      end
+
+      # Creates a new MemCacheStore object, with the given memcached server
+      # addresses. Each address is either a host name, or a host-with-port string
+      # in the form of "host_name:port". For example:
+      #
+      #   ActiveSupport::Cache::MemCacheStore.new("localhost", "server-downstairs.localnetwork:8229")
+      #
+      # If no addresses are specified, then MemCacheStore will connect to
+      # localhost port 11211 (the default memcached port).
+      #
+      # Instead of addresses one can pass in a MemCache-like object. For example:
+      #
+      #   require 'memcached' # gem install memcached; uses C bindings to libmemcached
+      #   ActiveSupport::Cache::MemCacheStore.new(Memcached::Rails.new("localhost:11211"))
+      def initialize(*addresses)
+        if addresses.first.respond_to?(:get)
+          @data = addresses.first
+        else
+          @data = self.class.build_mem_cache(*addresses)
+        end
+
+        extend Strategy::LocalCache
+      end
+
+      # Reads multiple keys from the cache.
+      def read_multi(*keys)
+        @data.get_multi keys
+      end
+
+      def read(key, options = nil) # :nodoc:
+        super
+        @data.get(key, raw?(options))
+      rescue MemCache::MemCacheError => e
+        logger.error("MemCacheError (#{e}): #{e.message}")
+        nil
+      end
+
+      # Writes a value to the cache.
+      #
+      # Possible options:
+      # - +:unless_exist+ - set to true if you don't want to update the cache
+      #   if the key is already set.
+      # - +:expires_in+ - the number of seconds that this value may stay in
+      #   the cache. See ActiveSupport::Cache::Store#write for an example.
+      def write(key, value, options = nil)
+        super
+        method = options && options[:unless_exist] ? :add : :set
+        # memcache-client will break the connection if you send it an integer
+        # in raw mode, so we convert it to a string to be sure it continues working.
+        value = value.to_s if raw?(options)
+        response = @data.send(method, key, value, expires_in(options), raw?(options))
+        response == Response::STORED
+      rescue MemCache::MemCacheError => e
+        logger.error("MemCacheError (#{e}): #{e.message}")
+        false
+      end
+
+      def delete(key, options = nil) # :nodoc:
+        super
+        response = @data.delete(key, expires_in(options))
+        response == Response::DELETED
+      rescue MemCache::MemCacheError => e
+        logger.error("MemCacheError (#{e}): #{e.message}")
+        false
+      end
+
+      def exist?(key, options = nil) # :nodoc:
+        # Doesn't call super, cause exist? in memcache is in fact a read
+        # But who cares? Reading is very fast anyway
+        # Local cache is checked first, if it doesn't know then memcache itself is read from
+        !read(key, options).nil?
+      end
+
+      def increment(key, amount = 1) # :nodoc:
+        log("incrementing", key, amount)
+
+        response = @data.incr(key, amount)
+        response == Response::NOT_FOUND ? nil : response
+      rescue MemCache::MemCacheError
+        nil
+      end
+
+      def decrement(key, amount = 1) # :nodoc:
+        log("decrement", key, amount)
+        response = @data.decr(key, amount)
+        response == Response::NOT_FOUND ? nil : response
+      rescue MemCache::MemCacheError
+        nil
+      end
+
+      def delete_matched(matcher, options = nil) # :nodoc:
+        # don't do any local caching at present, just pass
+        # through and let the error happen
+        super
+        raise "Not supported by Memcache"
+      end
+
+      def clear
+        @data.flush_all
+      end
+
+      def stats
+        @data.stats
+      end
+
+      private
+        def raw?(options)
+          options && options[:raw]
+        end
+    end
+  end
+end

data/vendor/activesupport-2.3.8/lib/active_support/cache/memory_store.rb

@@ -0,0 +1,58 @@
+module ActiveSupport
+  module Cache
+    # A cache store implementation which stores everything into memory in the
+    # same process. If you're running multiple Ruby on Rails server processes
+    # (which is the case if you're using mongrel_cluster or Phusion Passenger),
+    # then this means that your Rails server process instances won't be able
+    # to share cache data with each other. If your application never performs
+    # manual cache item expiry (e.g. when you're using generational cache keys),
+    # then using MemoryStore is ok. Otherwise, consider carefully whether you
+    # should be using this cache store.
+    #
+    # MemoryStore is not only able to store strings, but also arbitrary Ruby
+    # objects.
+    #
+    # MemoryStore is not thread-safe. Use SynchronizedMemoryStore instead
+    # if you need thread-safety.
+    class MemoryStore < Store
+      def initialize
+        @data = {}
+      end
+
+      def read_multi(*names)
+        results = {}
+        names.each { |n| results[n] = read(n) }
+        results
+      end
+
+      def read(name, options = nil)
+        super
+        @data[name]
+      end
+
+      def write(name, value, options = nil)
+        super
+        @data[name] = value.freeze
+      end
+
+      def delete(name, options = nil)
+        super
+        @data.delete(name)
+      end
+
+      def delete_matched(matcher, options = nil)
+        super
+        @data.delete_if { |k,v| k =~ matcher }
+      end
+
+      def exist?(name, options = nil)
+        super
+        @data.has_key?(name)
+      end
+
+      def clear
+        @data.clear
+      end
+    end
+  end
+end