esod-client 0.1.0

data/lib/activesupport-2.2.2/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/lib/activesupport-2.2.2/lib/active_support/cache/drb_store.rb

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

data/lib/activesupport-2.2.2/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/lib/activesupport-2.2.2/lib/active_support/cache/mem_cache_store.rb

@@ -0,0 +1,127 @@
+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.
+    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
+
+      attr_reader :addresses
+
+      # 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).
+      def initialize(*addresses)
+        addresses = addresses.flatten
+        options = addresses.extract_options!
+        addresses = ["localhost"] if addresses.empty?
+        @addresses = addresses
+        @data = MemCache.new(addresses, options)
+      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
+        !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:
+        super
+        raise "Not supported by Memcache"
+      end
+
+      def clear
+        @data.flush_all
+      end
+
+      def stats
+        @data.stats
+      end
+
+      private
+        def expires_in(options)
+          (options && options[:expires_in]) || 0
+        end
+
+        def raw?(options)
+          options && options[:raw]
+        end
+    end
+  end
+end

data/lib/activesupport-2.2.2/lib/active_support/cache/memory_store.rb

@@ -0,0 +1,52 @@
+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(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

data/lib/activesupport-2.2.2/lib/active_support/cache/synchronized_memory_store.rb

@@ -0,0 +1,47 @@
+module ActiveSupport
+  module Cache
+    # Like MemoryStore, but thread-safe.
+    class SynchronizedMemoryStore < MemoryStore
+      def initialize
+        super
+        @guard = Monitor.new
+      end
+
+      def fetch(key, options = {})
+        @guard.synchronize { super }
+      end
+
+      def read(name, options = nil)
+        @guard.synchronize { super }
+      end
+
+      def write(name, value, options = nil)
+        @guard.synchronize { super }
+      end
+
+      def delete(name, options = nil)
+        @guard.synchronize { super }
+      end
+
+      def delete_matched(matcher, options = nil)
+        @guard.synchronize { super }
+      end
+
+      def exist?(name,options = nil)
+        @guard.synchronize { super }
+      end
+
+      def increment(key, amount = 1)
+        @guard.synchronize { super }
+      end
+
+      def decrement(key, amount = 1)
+        @guard.synchronize { super }
+      end
+
+      def clear
+        @guard.synchronize { super }
+      end
+    end
+  end
+end

data/lib/activesupport-2.2.2/lib/active_support/callbacks.rb

@@ -0,0 +1,280 @@
+module ActiveSupport
+  # Callbacks are hooks into the lifecycle of an object that allow you to trigger logic
+  # before or after an alteration of the object state.
+  #
+  # Mixing in this module allows you to define callbacks in your class.
+  #
+  # Example:
+  #   class Storage
+  #     include ActiveSupport::Callbacks
+  #
+  #     define_callbacks :before_save, :after_save
+  #   end
+  #
+  #   class ConfigStorage < Storage
+  #     before_save :saving_message
+  #     def saving_message
+  #       puts "saving..."
+  #     end
+  #
+  #     after_save do |object|
+  #       puts "saved"
+  #     end
+  #
+  #     def save
+  #       run_callbacks(:before_save)
+  #       puts "- save"
+  #       run_callbacks(:after_save)
+  #     end
+  #   end
+  #
+  #   config = ConfigStorage.new
+  #   config.save
+  #
+  # Output:
+  #   saving...
+  #   - save
+  #   saved
+  #
+  # Callbacks from parent classes are inherited.
+  #
+  # Example:
+  #   class Storage
+  #     include ActiveSupport::Callbacks
+  #
+  #     define_callbacks :before_save, :after_save
+  #
+  #     before_save :prepare
+  #     def prepare
+  #       puts "preparing save"
+  #     end
+  #   end
+  #
+  #   class ConfigStorage < Storage
+  #     before_save :saving_message
+  #     def saving_message
+  #       puts "saving..."
+  #     end
+  #
+  #     after_save do |object|
+  #       puts "saved"
+  #     end
+  #
+  #     def save
+  #       run_callbacks(:before_save)
+  #       puts "- save"
+  #       run_callbacks(:after_save)
+  #     end
+  #   end
+  #
+  #   config = ConfigStorage.new
+  #   config.save
+  #
+  # Output:
+  #   preparing save
+  #   saving...
+  #   - save
+  #   saved
+  module Callbacks
+    class CallbackChain < Array
+      def self.build(kind, *methods, &block)
+        methods, options = extract_options(*methods, &block)
+        methods.map! { |method| Callback.new(kind, method, options) }
+        new(methods)
+      end
+
+      def run(object, options = {}, &terminator)
+        enumerator = options[:enumerator] || :each
+
+        unless block_given?
+          send(enumerator) { |callback| callback.call(object) }
+        else
+          send(enumerator) do |callback|
+            result = callback.call(object)
+            break result if terminator.call(result, object)
+          end
+        end
+      end
+
+      # TODO: Decompose into more Array like behavior
+      def replace_or_append!(chain)
+        if index = index(chain)
+          self[index] = chain
+        else
+          self << chain
+        end
+        self
+      end
+
+      def find(callback, &block)
+        select { |c| c == callback && (!block_given? || yield(c)) }.first
+      end
+
+      def delete(callback)
+        super(callback.is_a?(Callback) ? callback : find(callback))
+      end
+
+      private
+        def self.extract_options(*methods, &block)
+          methods.flatten!
+          options = methods.extract_options!
+          methods << block if block_given?
+          return methods, options
+        end
+
+        def extract_options(*methods, &block)
+          self.class.extract_options(*methods, &block)
+        end
+    end
+
+    class Callback
+      attr_reader :kind, :method, :identifier, :options
+
+      def initialize(kind, method, options = {})
+        @kind       = kind
+        @method     = method
+        @identifier = options[:identifier]
+        @options    = options
+      end
+
+      def ==(other)
+        case other
+        when Callback
+          (self.identifier && self.identifier == other.identifier) || self.method == other.method
+        else
+          (self.identifier && self.identifier == other) || self.method == other
+        end
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def dup
+        self.class.new(@kind, @method, @options.dup)
+      end
+
+      def hash
+        if @identifier
+          @identifier.hash
+        else
+          @method.hash
+        end
+      end
+
+      def call(*args, &block)
+        evaluate_method(method, *args, &block) if should_run_callback?(*args)
+      rescue LocalJumpError
+        raise ArgumentError,
+          "Cannot yield from a Proc type filter. The Proc must take two " +
+          "arguments and execute #call on the second argument."
+      end
+
+      private
+        def evaluate_method(method, *args, &block)
+          case method
+            when Symbol
+              object = args.shift
+              object.send(method, *args, &block)
+            when String
+              eval(method, args.first.instance_eval { binding })
+            when Proc, Method
+              method.call(*args, &block)
+            else
+              if method.respond_to?(kind)
+                method.send(kind, *args, &block)
+              else
+                raise ArgumentError,
+                  "Callbacks must be a symbol denoting the method to call, a string to be evaluated, " +
+                  "a block to be invoked, or an object responding to the callback method."
+              end
+          end
+        end
+
+        def should_run_callback?(*args)
+          if options[:if]
+            evaluate_method(options[:if], *args)
+          elsif options[:unless]
+            !evaluate_method(options[:unless], *args)
+          else
+            true
+          end
+        end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def define_callbacks(*callbacks)
+        callbacks.each do |callback|
+          class_eval <<-"end_eval"
+            def self.#{callback}(*methods, &block)
+              callbacks = CallbackChain.build(:#{callback}, *methods, &block)
+              (@#{callback}_callbacks ||= CallbackChain.new).concat callbacks
+            end
+
+            def self.#{callback}_callback_chain
+              @#{callback}_callbacks ||= CallbackChain.new
+
+              if superclass.respond_to?(:#{callback}_callback_chain)
+                CallbackChain.new(superclass.#{callback}_callback_chain + @#{callback}_callbacks)
+              else
+                @#{callback}_callbacks
+              end
+            end
+          end_eval
+        end
+      end
+    end
+
+    # Runs all the callbacks defined for the given options.
+    #
+    # If a block is given it will be called after each callback receiving as arguments:
+    #
+    #  * the result from the callback
+    #  * the object which has the callback
+    #
+    # If the result from the block evaluates to false, the callback chain is stopped.
+    #
+    # Example:
+    #   class Storage
+    #     include ActiveSupport::Callbacks
+    #
+    #     define_callbacks :before_save, :after_save
+    #   end
+    #
+    #   class ConfigStorage < Storage
+    #     before_save :pass
+    #     before_save :pass
+    #     before_save :stop
+    #     before_save :pass
+    #
+    #     def pass
+    #       puts "pass"
+    #     end
+    #
+    #     def stop
+    #       puts "stop"
+    #       return false
+    #     end
+    #
+    #     def save
+    #       result = run_callbacks(:before_save) { |result, object| result == false }
+    #       puts "- save" if result
+    #     end
+    #   end
+    #
+    #   config = ConfigStorage.new
+    #   config.save
+    #
+    # Output:
+    #   pass
+    #   pass
+    #   stop
+    def run_callbacks(kind, options = {}, &block)
+      self.class.send("#{kind}_callback_chain").run(self, options, &block)
+    end
+  end
+end