dalli 2.0.1 → 3.2.8

data/lib/active_support/cache/dalli_store.rb

@@ -1,203 +0,0 @@
-# encoding: ascii
-require 'dalli'
-require 'digest/md5'
-
-module ActiveSupport
-  module Cache
-    class DalliStore
-
-      ESCAPE_KEY_CHARS = /[\x00-\x20%\x7F-\xFF]/
-
-      # Creates a new DalliStore 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::DalliStore.new("localhost", "server-downstairs.localnetwork:8229")
-      #
-      # If no addresses are specified, then DalliStore will connect to
-      # localhost port 11211 (the default memcached port).
-      #
-      def initialize(*addresses)
-        addresses = addresses.flatten
-        options = addresses.extract_options!
-        options[:compression] = options.delete(:compress) || options[:compression]
-        addresses << 'localhost:11211' if addresses.empty?
-        @data = Dalli::Client.new(addresses, options)
-      end
-
-      def fetch(name, options={})
-        if block_given?
-          unless options[:force]
-            entry = instrument(:read, name, options) do |payload|
-              payload[:super_operation] = :fetch if payload
-              read_entry(name, options)
-            end
-          end
-
-          if entry
-            instrument(:fetch_hit, name, options) { |payload| }
-            entry
-          else
-            result = instrument(:generate, name, options) do |payload|
-              yield
-            end
-            write(name, result, options)
-            result
-          end
-        else
-          read(name, options)
-        end
-      end
-
-      def read(name, options={})
-        instrument(:read, name, options) do |payload|
-          entry = read_entry(name, options)
-          payload[:hit] = !!entry if payload
-          entry
-        end
-      end
-
-      def write(name, value, options={})
-        instrument(:write, name, options) do |payload|
-          write_entry(name, value, options)
-        end
-      end
-
-      def exist?(name, options={})
-        !!read_entry(name, options)
-      end
-
-      def delete(name, options={})
-        @data.delete(name)
-      end
-
-      # Reads multiple keys from the cache using a single call to the
-      # servers for all keys. Keys must be Strings.
-      def read_multi(*names)
-        names.extract_options!
-        names = names.flatten
-
-        mapping = names.inject({}) { |memo, name| memo[escape(name)] = name; memo }
-        instrument(:read_multi, names) do
-          results = @data.get_multi(mapping.keys)
-          results.inject({}) do |memo, (inner, value)|
-            entry = results[inner]
-            # NB Backwards data compatibility, to be removed at some point
-            memo[mapping[inner]] = (entry.is_a?(ActiveSupport::Cache::Entry) ? entry.value : entry)
-            memo
-          end
-        end
-      end
-
-      # Increment a cached value. This method uses the memcached incr atomic
-      # operator and can only be used on values written with the :raw option.
-      # Calling it on a value not stored with :raw will fail.
-      # :initial defaults to the amount passed in, as if the counter was initially zero.
-      # memcached counters cannot hold negative values.
-      def increment(name, amount = 1, options={}) # :nodoc:
-        initial = options[:initial] || amount
-        expires_in = options[:expires_in]
-        instrument(:increment, name, :amount => amount) do
-          @data.incr(name, amount, expires_in, initial)
-        end
-      rescue Dalli::DalliError => e
-        logger.error("DalliError: #{e.message}") if logger
-        nil
-      end
-
-      # Decrement a cached value. This method uses the memcached decr atomic
-      # operator and can only be used on values written with the :raw option.
-      # Calling it on a value not stored with :raw will fail.
-      # :initial defaults to zero, as if the counter was initially zero.
-      # memcached counters cannot hold negative values.
-      def decrement(name, amount = 1, options={}) # :nodoc:
-        initial = options[:initial] || 0
-        expires_in = options[:expires_in]
-        instrument(:decrement, name, :amount => amount) do
-          @data.decr(name, amount, expires_in, initial)
-        end
-      rescue Dalli::DalliError => e
-        logger.error("DalliError: #{e.message}") if logger
-        nil
-      end
-
-      # Clear the entire cache on all memcached servers. This method should
-      # be used with care when using a shared cache.
-      def clear(options=nil)
-        @data.flush_all
-      end
-
-      # Get the statistics from the memcached servers.
-      def stats
-        @data.stats
-      end
-
-      def reset
-        @data.reset
-      end
-
-      protected
-
-      # Read an entry from the cache.
-      def read_entry(key, options) # :nodoc:
-        entry = @data.get(escape(key), options)
-        # NB Backwards data compatibility, to be removed at some point
-        entry.is_a?(ActiveSupport::Cache::Entry) ? entry.value : entry
-      rescue Dalli::DalliError => e
-        logger.error("DalliError: #{e.message}") if logger
-        nil
-      end
-
-      # Write an entry to the cache.
-      def write_entry(key, value, options) # :nodoc:
-        options ||= {}
-        method = options[:unless_exist] ? :add : :set
-        expires_in = options[:expires_in]
-        @data.send(method, escape(key), value, expires_in, options)
-      rescue Dalli::DalliError => e
-        logger.error("DalliError: #{e.message}") if logger
-        false
-      end
-
-      # Delete an entry from the cache.
-      def delete_entry(key, options) # :nodoc:
-        @data.delete(escape(key))
-      rescue Dalli::DalliError => e
-        logger.error("DalliError: #{e.message}") if logger
-        false
-      end
-
-      private
-
-      def escape(key)
-        key = key.to_s.dup
-        key = key.force_encoding("BINARY") if key.encoding_aware?
-        key = key.gsub(ESCAPE_KEY_CHARS){ |match| "%#{match.getbyte(0).to_s(16).upcase}" }
-        key = "#{key[0, 213]}:md5:#{Digest::MD5.hexdigest(key)}" if key.size > 250
-        key
-      end
-
-      def instrument(operation, key, options = nil)
-        log(operation, key, options)
-
-        if ActiveSupport::Cache::Store.instrument
-          payload = { :key => key }
-          payload.merge!(options) if options.is_a?(Hash)
-          ActiveSupport::Notifications.instrument("cache_#{operation}.active_support", payload){ yield(payload) }
-        else
-          yield(nil)
-        end
-      end
-
-      def log(operation, key, options = nil)
-        return unless logger && logger.debug?
-        logger.debug("Cache #{operation}: #{key}#{options.blank? ? "" : " (#{options.inspect})"}")
-      end
-
-      def logger
-        Dalli.logger
-      end
-
-    end
-  end
-end

data/test/abstract_unit.rb

@@ -1,281 +0,0 @@
-# Used to test the full Rails stack.
-# Stolen from the Rails 3.0 source.
-# Needed for the session store tests.
-require 'active_support/core_ext/kernel/reporting'
-require 'active_support/core_ext/string/encoding'
-if "ruby".encoding_aware?
-  # These are the normal settings that will be set up by Railties
-  # TODO: Have these tests support other combinations of these values
-  silence_warnings do
-    Encoding.default_internal = "UTF-8"
-    Encoding.default_external = "UTF-8"
-  end
-end
-
-require 'test/unit'
-require 'abstract_controller'
-require 'action_controller'
-require 'action_view'
-require 'action_dispatch'
-require 'active_support/dependencies'
-require 'action_controller/caching'
-require 'action_controller/caching/sweeping'
-
-require 'pp' # require 'pp' early to prevent hidden_methods from not picking up the pretty-print methods until too late
-
-module Rails
-  def self.logger
-    @logger ||= begin
-      l = Logger.new(STDOUT)
-      l.level = Logger::INFO; l
-    end
-  end
-end
-
-# Monkey patch the old routes initialization to be silenced.
-class ActionDispatch::Routing::DeprecatedMapper
-  def initialize_with_silencer(*args)
-    ActiveSupport::Deprecation.silence { initialize_without_silencer(*args) }
-  end
-  alias_method_chain :initialize, :silencer
-end
-
-ActiveSupport::Dependencies.hook!
-
-# Show backtraces for deprecated behavior for quicker cleanup.
-ActiveSupport::Deprecation.debug = true
-
-ORIGINAL_LOCALES = I18n.available_locales.map {|locale| locale.to_s }.sort
-
-module RackTestUtils
-  def body_to_string(body)
-    if body.respond_to?(:each)
-      str = ""
-      body.each {|s| str << s }
-      str
-    else
-      body
-    end
-  end
-  extend self
-end
-
-module SetupOnce
-  extend ActiveSupport::Concern
-
-  included do
-    cattr_accessor :setup_once_block
-    self.setup_once_block = nil
-
-    setup :run_setup_once
-  end
-
-  module ClassMethods
-    def setup_once(&block)
-      self.setup_once_block = block
-    end
-  end
-
-  private
-    def run_setup_once
-      if self.setup_once_block
-        self.setup_once_block.call
-        self.setup_once_block = nil
-      end
-    end
-end
-
-SharedTestRoutes = ActionDispatch::Routing::RouteSet.new
-
-module ActiveSupport
-  class TestCase
-    include SetupOnce
-    # Hold off drawing routes until all the possible controller classes
-    # have been loaded.
-    setup_once do
-      SharedTestRoutes.draw do
-        match ':controller(/:action(/:id))'
-      end
-
-      ActionController::IntegrationTest.app.routes.draw do
-        match ':controller(/:action(/:id))'
-      end
-    end
-  end
-end
-
-class RoutedRackApp
-  attr_reader :routes
-
-  def initialize(routes, &blk)
-    @routes = routes
-    @stack = ActionDispatch::MiddlewareStack.new(&blk).build(@routes)
-  end
-
-  def call(env)
-    @stack.call(env)
-  end
-end
-
-class BasicController
-  attr_accessor :request
-
-  def config
-    @config ||= ActiveSupport::InheritableOptions.new(ActionController::Base.config).tap do |config|
-      # VIEW TODO: View tests should not require a controller
-      public_dir = File.expand_path("../fixtures/public", __FILE__)
-      config.assets_dir = public_dir
-      config.javascripts_dir = "#{public_dir}/javascripts"
-      config.stylesheets_dir = "#{public_dir}/stylesheets"
-      config
-    end
-  end
-end
-
-class ActionDispatch::IntegrationTest < ActiveSupport::TestCase
-  setup do
-    @routes = SharedTestRoutes
-  end
-end
-
-class ActionController::IntegrationTest < ActiveSupport::TestCase
-  def self.build_app(routes = nil)
-    RoutedRackApp.new(routes || ActionDispatch::Routing::RouteSet.new) do |middleware|
-      middleware.use "ActionDispatch::Callbacks"
-      middleware.use "ActionDispatch::ParamsParser"
-      middleware.use "ActionDispatch::Cookies"
-      middleware.use "ActionDispatch::Flash"
-      middleware.use "ActionDispatch::Head"
-      yield(middleware) if block_given?
-    end
-  end
-
-  self.app = build_app
-
-  # Stub Rails dispatcher so it does not get controller references and
-  # simply return the controller#action as Rack::Body.
-  class StubDispatcher < ::ActionDispatch::Routing::RouteSet::Dispatcher
-    protected
-    def controller_reference(controller_param)
-      controller_param
-    end
-
-    def dispatch(controller, action, env)
-      [200, {'Content-Type' => 'text/html'}, ["#{controller}##{action}"]]
-    end
-  end
-
-  def self.stub_controllers
-    old_dispatcher = ActionDispatch::Routing::RouteSet::Dispatcher
-    ActionDispatch::Routing::RouteSet.module_eval { remove_const :Dispatcher }
-    ActionDispatch::Routing::RouteSet.module_eval { const_set :Dispatcher, StubDispatcher }
-    yield ActionDispatch::Routing::RouteSet.new
-  ensure
-    ActionDispatch::Routing::RouteSet.module_eval { remove_const :Dispatcher }
-    ActionDispatch::Routing::RouteSet.module_eval { const_set :Dispatcher, old_dispatcher }
-  end
-
-  def with_routing(&block)
-    temporary_routes = ActionDispatch::Routing::RouteSet.new
-    old_app, self.class.app = self.class.app, self.class.build_app(temporary_routes)
-    old_routes = SharedTestRoutes
-    silence_warnings { Object.const_set(:SharedTestRoutes, temporary_routes) }
-
-    yield temporary_routes
-  ensure
-    self.class.app = old_app
-    silence_warnings { Object.const_set(:SharedTestRoutes, old_routes) }
-  end
-
-  def with_autoload_path(path)
-    path = File.join(File.dirname(__FILE__), "fixtures", path)
-    if ActiveSupport::Dependencies.autoload_paths.include?(path)
-      yield
-    else
-      begin
-        ActiveSupport::Dependencies.autoload_paths << path
-        yield
-      ensure
-        ActiveSupport::Dependencies.autoload_paths.reject! {|p| p == path}
-        ActiveSupport::Dependencies.clear
-      end
-    end
-  end
-end
-
-# Temporary base class
-class Rack::TestCase < ActionController::IntegrationTest
-  def self.testing(klass = nil)
-    if klass
-      @testing = "/#{klass.name.underscore}".sub!(/_controller$/, '')
-    else
-      @testing
-    end
-  end
-
-  def get(thing, *args)
-    if thing.is_a?(Symbol)
-      super("#{self.class.testing}/#{thing}", *args)
-    else
-      super
-    end
-  end
-
-  def assert_body(body)
-    assert_equal body, Array.wrap(response.body).join
-  end
-
-  def assert_status(code)
-    assert_equal code, response.status
-  end
-
-  def assert_response(body, status = 200, headers = {})
-    assert_body   body
-    assert_status status
-    headers.each do |header, value|
-      assert_header header, value
-    end
-  end
-
-  def assert_content_type(type)
-    assert_equal type, response.headers["Content-Type"]
-  end
-
-  def assert_header(name, value)
-    assert_equal value, response.headers[name]
-  end
-end
-
-class ActionController::Base
-  def self.test_routes(&block)
-    routes = ActionDispatch::Routing::RouteSet.new
-    routes.draw(&block)
-    include routes.url_helpers
-  end
-end
-
-class ::ApplicationController < ActionController::Base
-end
-
-module ActionController
-  class Base
-    include ActionController::Testing
-  end
-
-  Base.view_paths = []
-
-  class TestCase
-    include ActionDispatch::TestProcess
-
-    setup do
-      @routes = SharedTestRoutes
-    end
-  end
-end
-
-# This stub emulates the Railtie including the URL helpers from a Rails application
-module ActionController
-  class Base
-    include SharedTestRoutes.url_helpers
-  end
-end

data/test/benchmark_test.rb

@@ -1,187 +0,0 @@
-require 'helper'
-require 'benchmark'
-require 'active_support/cache/dalli_store'
-
-describe 'performance' do
-  before do
-    puts "Testing #{Dalli::VERSION} with #{RUBY_DESCRIPTION}"
-    # We'll use a simple @value to try to avoid spending time in Marshal,
-    # which is a constant penalty that both clients have to pay
-    @value = []
-    @marshalled = Marshal.dump(@value)
-
-    @servers = ['127.0.0.1:19122', 'localhost:19122']
-    @key1 = "Short"
-    @key2 = "Sym1-2-3::45"*8
-    @key3 = "Long"*40
-    @key4 = "Medium"*8
-    # 5 and 6 are only used for multiget miss test
-    @key5 = "Medium2"*8
-    @key6 = "Long3"*40
-    @counter = 'counter'
-  end
-
-  should 'run benchmarks' do
-    memcached do
-
-      Benchmark.bm(31) do |x|
-
-        n = 2500
-
-        @ds = ActiveSupport::Cache::DalliStore.new(@servers)
-        x.report("mixed:rails:dalli") do
-          n.times do
-            @ds.read @key1
-            @ds.write @key2, @value
-            @ds.fetch(@key3) { @value }
-            @ds.fetch(@key2) { @value }
-            @ds.fetch(@key1) { @value }
-            @ds.write @key2, @value, :unless_exists => true
-            @ds.delete @key2
-            @ds.increment @counter, 1, :initial => 100
-            @ds.increment @counter, 1, :expires_in => 12
-            @ds.decrement @counter, 1
-          end
-        end
-
-        @m = Dalli::Client.new(@servers)
-        x.report("set:plain:dalli") do
-          n.times do
-            @m.set @key1, @marshalled, 0, :raw => true
-            @m.set @key2, @marshalled, 0, :raw => true
-            @m.set @key3, @marshalled, 0, :raw => true
-            @m.set @key1, @marshalled, 0, :raw => true
-            @m.set @key2, @marshalled, 0, :raw => true
-            @m.set @key3, @marshalled, 0, :raw => true
-          end
-        end
-
-        @m = Dalli::Client.new(@servers)
-        x.report("setq:plain:dalli") do
-          @m.multi do
-            n.times do
-              @m.set @key1, @marshalled, 0, :raw => true
-              @m.set @key2, @marshalled, 0, :raw => true
-              @m.set @key3, @marshalled, 0, :raw => true
-              @m.set @key1, @marshalled, 0, :raw => true
-              @m.set @key2, @marshalled, 0, :raw => true
-              @m.set @key3, @marshalled, 0, :raw => true
-            end
-          end
-        end
-
-        @m = Dalli::Client.new(@servers)
-        x.report("set:ruby:dalli") do
-          n.times do
-            @m.set @key1, @value
-            @m.set @key2, @value
-            @m.set @key3, @value
-            @m.set @key1, @value
-            @m.set @key2, @value
-            @m.set @key3, @value
-          end
-        end
-
-        @m = Dalli::Client.new(@servers)
-        x.report("get:plain:dalli") do
-          n.times do
-            @m.get @key1, :raw => true
-            @m.get @key2, :raw => true
-            @m.get @key3, :raw => true
-            @m.get @key1, :raw => true
-            @m.get @key2, :raw => true
-            @m.get @key3, :raw => true
-          end
-        end
-
-        @m = Dalli::Client.new(@servers)
-        x.report("get:ruby:dalli") do
-          n.times do
-            @m.get @key1
-            @m.get @key2
-            @m.get @key3
-            @m.get @key1
-            @m.get @key2
-            @m.get @key3
-          end
-        end
-
-        @m = Dalli::Client.new(@servers)
-        x.report("multiget:ruby:dalli") do
-          n.times do
-            # We don't use the keys array because splat is slow
-            @m.get_multi @key1, @key2, @key3, @key4, @key5, @key6
-          end
-        end
-
-        @m = Dalli::Client.new(@servers)
-        x.report("missing:ruby:dalli") do
-          n.times do
-            begin @m.delete @key1; rescue; end
-            begin @m.get @key1; rescue; end
-            begin @m.delete @key2; rescue; end
-            begin @m.get @key2; rescue; end
-            begin @m.delete @key3; rescue; end
-            begin @m.get @key3; rescue; end
-          end
-        end
-
-        @m = Dalli::Client.new(@servers)
-        x.report("mixed:ruby:dalli") do
-          n.times do
-            @m.set @key1, @value
-            @m.set @key2, @value
-            @m.set @key3, @value
-            @m.get @key1
-            @m.get @key2
-            @m.get @key3
-            @m.set @key1, @value
-            @m.get @key1
-            @m.set @key2, @value
-            @m.get @key2
-            @m.set @key3, @value
-            @m.get @key3
-          end
-        end
-
-        @m = Dalli::Client.new(@servers)
-        x.report("mixedq:ruby:dalli") do
-          @m.multi do
-            n.times do
-              @m.set @key1, @value
-              @m.set @key2, @value
-              @m.set @key3, @value
-              @m.get @key1
-              @m.get @key2
-              @m.get @key3
-              @m.set @key1, @value
-              @m.get @key1
-              @m.set @key2, @value
-              @m.replace @key2, @value
-              @m.delete @key3
-              @m.add @key3, @value
-              @m.get @key2
-              @m.set @key3, @value
-              @m.get @key3
-            end
-          end
-        end
-
-        @m = Dalli::Client.new(@servers)
-        x.report("incr:ruby:dalli") do
-          counter = 'foocount'
-          n.times do
-            @m.incr counter, 1, 0, 1
-          end
-          n.times do
-            @m.decr counter, 1
-          end
-
-          assert_equal 0, @m.incr(counter, 0)
-        end
-
-      end
-    end
-
-  end
-end

data/test/helper.rb

@@ -1,41 +0,0 @@
-$TESTING = true
-require 'rubygems'
-# require 'simplecov'
-# SimpleCov.start
-WANT_RAILS_VERSION = ENV['RAILS_VERSION'] || '>= 3.0.0'
-gem 'rails', WANT_RAILS_VERSION
-require 'rails'
-puts "Testing with Rails #{Rails.version}"
-
-require 'mini_shoulda'
-require 'minitest/pride'
-require 'minitest/autorun'
-require 'memcached_mock'
-require 'mocha'
-
-require 'dalli'
-require 'logger'
-
-Dalli.logger = Logger.new(STDOUT)
-Dalli.logger.level = Logger::ERROR
-
-class MiniTest::Spec
-  include MemcachedMock::Helper
-
-  def assert_error(error, regexp=nil, &block)
-    ex = assert_raises(error, &block)
-    assert_match(regexp, ex.message, "#{ex.class.name}: #{ex.message}\n#{ex.backtrace.join("\n\t")}")
-  end
-
-  def with_activesupport
-    require 'active_support/all'
-    require 'active_support/cache/dalli_store'
-    yield
-  end
-
-  def with_actionpack
-    require 'action_dispatch'
-    require 'action_controller'
-    yield
-  end
-end