factorylabs-castronaut 0.7.5

data/vendor/activesupport/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/lib/active_support.rb

@@ -0,0 +1,61 @@
+#--
+# Copyright (c) 2005 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require 'active_support/vendor'
+require 'active_support/basic_object'
+require 'active_support/inflector'
+require 'active_support/callbacks'
+
+require 'active_support/core_ext'
+
+require 'active_support/buffered_logger'
+
+require 'active_support/gzip'
+require 'active_support/cache'
+
+require 'active_support/dependencies'
+require 'active_support/deprecation'
+
+require 'active_support/ordered_hash'
+require 'active_support/ordered_options'
+require 'active_support/option_merger'
+
+require 'active_support/memoizable'
+require 'active_support/string_inquirer'
+
+require 'active_support/values/time_zone'
+require 'active_support/duration'
+
+require 'active_support/json'
+
+require 'active_support/multibyte'
+
+require 'active_support/base64'
+
+require 'active_support/time_with_zone'
+
+require 'active_support/secure_random'
+
+require 'active_support/rescuable'
+
+I18n.load_path << File.dirname(__FILE__) + '/active_support/locale/en.yml'

data/vendor/activesupport/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/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/lib/active_support/buffered_logger.rb

@@ -0,0 +1,122 @@
+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
+
+    # 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__
+        def #{severity.downcase}(message = nil, progname = nil, &block)
+          add(#{severity}, message, progname, &block)
+        end
+
+        def #{severity.downcase}?
+          #{severity} >= @level
+        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
+          clear_buffer
+          @log.write(old_buffer.join)
+        end
+      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/lib/active_support/cache.rb

@@ -0,0 +1,223 @@
+require 'benchmark'
+
+module ActiveSupport
+  # See ActiveSupport::Cache::Store for documentation.
+  module Cache
+    # Creates a new CacheStore object according to the given options.
+    #
+    # If no arguments are passed to this method, then a new
+    # ActiveSupport::Cache::MemoryStore object will be returned.
+    #
+    # If you pass a Symbol as the first argument, then a corresponding cache
+    # store class under the ActiveSupport::Cache namespace will be created.
+    # For example:
+    #
+    #   ActiveSupport::Cache.lookup_store(:memory_store)
+    #   # => returns a new ActiveSupport::Cache::MemoryStore object
+    #   
+    #   ActiveSupport::Cache.lookup_store(:drb_store)
+    #   # => returns a new ActiveSupport::Cache::DRbStore object
+    #
+    # Any additional arguments will be passed to the corresponding cache store
+    # class's constructor:
+    #
+    #   ActiveSupport::Cache.lookup_store(:file_store, "/tmp/cache")
+    #   # => same as: ActiveSupport::Cache::FileStore.new("/tmp/cache")
+    #
+    # If the first argument is not a Symbol, then it will simply be returned:
+    #
+    #   ActiveSupport::Cache.lookup_store(MyOwnCacheStore.new)
+    #   # => returns MyOwnCacheStore.new
+    def self.lookup_store(*store_option)
+      store, *parameters = *([ store_option ].flatten)
+
+      case store
+      when Symbol
+        store_class_name = (store == :drb_store ? "DRbStore" : store.to_s.camelize)
+        store_class = ActiveSupport::Cache.const_get(store_class_name)
+        store_class.new(*parameters)
+      when nil
+        ActiveSupport::Cache::MemoryStore.new
+      else
+        store
+      end
+    end
+
+    def self.expand_cache_key(key, namespace = nil)
+      expanded_cache_key = namespace ? "#{namespace}/" : ""
+
+      if ENV["RAILS_CACHE_ID"] || ENV["RAILS_APP_VERSION"]
+        expanded_cache_key << "#{ENV["RAILS_CACHE_ID"] || ENV["RAILS_APP_VERSION"]}/"
+      end
+
+      expanded_cache_key << case
+        when key.respond_to?(:cache_key)
+          key.cache_key
+        when key.is_a?(Array)
+          key.collect { |element| expand_cache_key(element) }.to_param
+        when key
+          key.to_param
+        end.to_s
+
+      expanded_cache_key
+    end
+
+    # An abstract cache store class. There are multiple cache store
+    # implementations, each having its own additional features. See the classes
+    # under the ActiveSupport::Cache module, e.g.
+    # ActiveSupport::Cache::MemCacheStore. MemCacheStore is currently the most
+    # popular cache store for large production websites.
+    #
+    # ActiveSupport::Cache::Store is meant for caching strings. Some cache
+    # store implementations, like MemoryStore, are able to cache arbitrary
+    # Ruby objects, but don't count on every cache store to be able to do that.
+    #
+    #   cache = ActiveSupport::Cache::MemoryStore.new
+    #   
+    #   cache.read("city")   # => nil
+    #   cache.write("city", "Duckburgh")
+    #   cache.read("city")   # => "Duckburgh"
+    class Store
+      cattr_accessor :logger
+
+      def silence!
+        @silence = true
+        self
+      end
+
+      # Fetches data from the cache, using the given key. If there is data in
+      # the cache with the given key, then that data is returned.
+      #
+      # If there is no such data in the cache (a cache miss occurred), then
+      # then nil will be returned. However, if a block has been passed, then
+      # that block will be run in the event of a cache miss. The return value
+      # of the block will be written to the cache under the given cache key,
+      # and that return value will be returned.
+      #
+      #   cache.write("today", "Monday")
+      #   cache.fetch("today")  # => "Monday"
+      #   
+      #   cache.fetch("city")   # => nil
+      #   cache.fetch("city") do
+      #     "Duckburgh"
+      #   end
+      #   cache.fetch("city")   # => "Duckburgh"
+      #
+      # You may also specify additional options via the +options+ argument.
+      # Setting <tt>:force => true</tt> will force a cache miss:
+      #
+      #   cache.write("today", "Monday")
+      #   cache.fetch("today", :force => true)  # => nil
+      #
+      # Other options will be handled by the specific cache store implementation.
+      # Internally, #fetch calls #read, and calls #write on a cache miss.
+      # +options+ will be passed to the #read and #write calls.
+      #
+      # For example, MemCacheStore's #write method supports the +:expires_in+
+      # option, which tells the memcached server to automatically expire the
+      # cache item after a certain period. We can use this option with #fetch
+      # too:
+      #
+      #   cache = ActiveSupport::Cache::MemCacheStore.new
+      #   cache.fetch("foo", :force => true, :expires_in => 5.seconds) do
+      #     "bar"
+      #   end
+      #   cache.fetch("foo")  # => "bar"
+      #   sleep(6)
+      #   cache.fetch("foo")  # => nil
+      def fetch(key, options = {})
+        @logger_off = true
+        if !options[:force] && value = read(key, options)
+          @logger_off = false
+          log("hit", key, options)
+          value
+        elsif block_given?
+          @logger_off = false
+          log("miss", key, options)
+
+          value = nil
+          seconds = Benchmark.realtime { value = yield }
+
+          @logger_off = true
+          write(key, value, options)
+          @logger_off = false
+
+          log("write (will save #{'%.2f' % (seconds * 1000)}ms)", key, nil)
+
+          value
+        end
+      end
+
+      # Fetches data from the cache, using the given key. If there is data in
+      # the cache with the given key, then that data is returned. Otherwise,
+      # nil is returned.
+      #
+      # You may also specify additional options via the +options+ argument.
+      # The specific cache store implementation will decide what to do with
+      # +options+.
+      def read(key, options = nil)
+        log("read", key, options)
+      end
+
+      # Writes the given value to the cache, with the given key.
+      #
+      # You may also specify additional options via the +options+ argument.
+      # The specific cache store implementation will decide what to do with
+      # +options+.
+      # 
+      # For example, MemCacheStore supports the +:expires_in+ option, which
+      # tells the memcached server to automatically expire the cache item after
+      # a certain period:
+      #
+      #   cache = ActiveSupport::Cache::MemCacheStore.new
+      #   cache.write("foo", "bar", :expires_in => 5.seconds)
+      #   cache.read("foo")  # => "bar"
+      #   sleep(6)
+      #   cache.read("foo")  # => nil
+      def write(key, value, options = nil)
+        log("write", key, options)
+      end
+
+      def delete(key, options = nil)
+        log("delete", key, options)
+      end
+
+      def delete_matched(matcher, options = nil)
+        log("delete matched", matcher.inspect, options)
+      end
+
+      def exist?(key, options = nil)
+        log("exist?", key, options)
+      end
+
+      def increment(key, amount = 1)
+        log("incrementing", key, amount)
+        if num = read(key)
+          write(key, num + amount)
+        else
+          nil
+        end
+      end
+
+      def decrement(key, amount = 1)
+        log("decrementing", key, amount)
+        if num = read(key)
+          write(key, num - amount)
+        else
+          nil
+        end
+      end
+
+      private
+        def log(operation, key, options)
+          logger.debug("Cache #{operation}: #{key}#{options ? " (#{options.inspect})" : ""}") if logger && !@silence && !@logger_off
+        end
+    end
+  end
+end
+
+require 'active_support/cache/file_store'
+require 'active_support/cache/memory_store'
+require 'active_support/cache/drb_store'
+require 'active_support/cache/mem_cache_store'
+require 'active_support/cache/compressed_mem_cache_store'