stale 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 1.8.7

data/Gemfile

@@ -0,0 +1,5 @@
+source :rubygems
+
+gemspec
+
+gem 'dalli', :require => false

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Norbert Crombach
+
+MIT License
+
+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.

data/README.md

@@ -0,0 +1,7 @@
+# Stale
+
+Experimental fragment caching layer for Rails.
+
+## Resources
+
+This library is heavily influenced by [Interlock](https://github.com/evan/interlock) and [Primer](https://github.com/jcoglan/primer).

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+end
+
+task :default => :test

data/lib/stale.rb

@@ -0,0 +1,13 @@
+require 'active_support/core_ext'
+
+require 'stale/cache'
+require 'stale/dependencies'
+require 'stale/fragments'
+require 'stale/interface'
+require 'stale/parameters'
+
+require 'stale/model'
+require 'stale/view'
+require 'stale/controller'
+
+require 'stale/configuration'

data/lib/stale/cache.rb

@@ -0,0 +1,49 @@
+module Stale
+  class Cache
+    attr_reader :data
+
+    def initialize(data)
+      @data = data
+    end
+
+    def get(key)
+      data.get(key_with_prefix(key))
+    end
+
+    def set(key, value, ttl = nil)
+      data.set(key_with_prefix(key), value, ttl)
+    end
+
+    def add(key, value, ttl = nil)
+      data.add(key_with_prefix(key), value, ttl)
+    end
+
+    def delete(*keys)
+      keys.each do |key|
+        data.delete(key_with_prefix(key))
+      end
+    end
+
+    def modify(key, ttl = nil, &block)
+      stored = false
+      retries = 0
+
+      while !stored
+        stored = data.cas(key_with_prefix(key), ttl, &block)
+
+        if stored.nil?
+          stored = add(key, block.call(nil), ttl)
+        elsif stored == false
+          retries += 1
+        end
+      end
+
+      stored
+    end
+
+    private
+    def key_with_prefix(key)
+      Stale.configuration[:key_prefix] + key
+    end
+  end
+end

data/lib/stale/configuration.rb

@@ -0,0 +1,46 @@
+module Stale
+  class Configuration
+    include Parameters
+
+    DEFAULT_OPTIONS = {
+      :expiration_time => 1.day,
+      :key_prefix => 'stale:',
+      :key_separator => ':',
+      :model_key_separator => ':',
+      :dependency_key_suffix => ':dependencies'
+    }
+
+    attr_accessor :cache, :interface
+    attr_reader :options
+
+    def initialize
+      @options = DEFAULT_OPTIONS.clone
+      @interface = Interface
+    end
+
+    def [](key)
+      options[key]
+    end
+
+    def []=(key, value)
+      options[key] = value
+    end
+  end
+
+  mattr_accessor :configuration
+  self.configuration = Configuration.new
+
+  def self.configure(&block)
+    configuration = Configuration.new
+    yield configuration if block_given?
+    self.configuration = configuration
+  end
+
+  def self.interface
+    configuration.interface
+  end
+
+  def self.cache
+    configuration.cache
+  end
+end

data/lib/stale/controller.rb

@@ -0,0 +1,20 @@
+module Stale
+  module Controller
+    include Fragments
+
+    def stale(parameters, &block)
+      if !perform_caching
+        yield
+        return
+      end
+
+      key = Stale.interface.key_for_parameters(parameters, self)
+      Stale.interface.register_dependencies(key)
+
+      if !stale_fragment_exist?(key)
+        yield
+        nil
+      end
+    end
+  end
+end

data/lib/stale/dependencies.rb

@@ -0,0 +1,39 @@
+module Stale
+  module Dependencies
+    def register_dependencies(key_array)
+      model_keys = models_from_key(key_array)
+      key_string = key_as_string(key_array)
+
+      model_keys.each do |model_key|
+        register_dependency(model_key, key_string)
+      end
+    end
+
+    def expire_dependencies(model_key)
+      expire_dependencies_from_list(dependency_key_for_instance(model_key))
+      expire_dependencies_from_list(dependency_key_for_collection(model_key))
+    end
+
+    def register_dependency(model_key, key_string)
+      add_dependency_to_list(dependency_key_for_instance(model_key), key_string)
+    end
+
+    def dependency_key_for_instance(model_key)
+      model_key + Stale.configuration[:dependency_key_suffix]
+    end
+
+    def dependency_key_for_collection(model_key)
+      collection_from_key(model_key) + Stale.configuration[:dependency_key_suffix]
+    end
+
+    def add_dependency_to_list(dependency_key, key_string)
+      Stale.cache.modify(dependency_key) do |dependency_list|
+        (Array(dependency_list) << key_string).uniq
+      end
+    end
+
+    def expire_dependencies_from_list(dependency_key)
+      Stale.cache.delete(*Array(Stale.cache.get(dependency_key)))
+    end
+  end
+end

data/lib/stale/fragments.rb

@@ -0,0 +1,19 @@
+module Stale
+  module Fragments
+    def read_stale_fragment(key_array)
+      key_string = Stale.interface.key_as_string(key_array)
+      Stale.cache.get(key_string)
+    end
+
+    def write_stale_fragment(key_array, value, ttl = nil)
+      ttl ||= Stale.configuration[:expiration_time]
+
+      key_string = Stale.interface.key_as_string(key_array)
+      Stale.cache.set(key_string, value, ttl)
+    end
+
+    def stale_fragment_exist?(key_array)
+      !!read_stale_fragment(key_array)
+    end
+  end
+end

data/lib/stale/interface.rb

@@ -0,0 +1,31 @@
+module Stale
+  module Interface
+    include Dependencies
+
+    extend self
+
+    def key_for_parameters(parameters, controller)
+      Stale.configuration.key_for_parameters(parameters, controller)
+    end
+
+    def key_for_model(collection, id = nil, *args)
+      [key_for_collection(collection), id, *args].join(Stale.configuration[:model_key_separator])
+    end
+
+    def key_for_collection(collection)
+      collection.is_a?(Class) ? collection.name.underscore : collection
+    end
+
+    def key_as_string(key_array)
+      Array(key_array).join(Stale.configuration[:key_separator])
+    end
+
+    def models_from_key(key_array)
+      key_array.select { |key_part| key_part.include?(Stale.configuration[:model_key_separator]) }
+    end
+
+    def collection_from_key(model_key)
+      key_for_model(model_key.split(Stale.configuration[:model_key_separator], 2).first)
+    end
+  end
+end

data/lib/stale/model.rb

@@ -0,0 +1,23 @@
+module Stale
+  module Model
+    IDENTIFIER = :stale_key
+
+    def self.included(base)
+      base.class_eval do
+        after_commit :expire_stale_dependencies if respond_to?(:after_commit)
+      end
+    end
+
+    def stale_id
+      to_param
+    end
+
+    def stale_key
+      Stale.interface.key_for_model(self.class, stale_id)
+    end
+
+    def expire_stale_dependencies
+      Stale.interface.expire_dependencies(stale_key)
+    end
+  end
+end

data/lib/stale/parameters.rb

@@ -0,0 +1,31 @@
+module Stale
+  module Parameters
+    def key_for_parameters(parameters, controller = nil)
+      parameters.map { |parameter| key_for_parameter(parameter, controller) }
+    end
+
+    def key_for_parameter(parameter, controller = nil)
+      if parameter.is_a?(Symbol)
+        self.named_parameters[parameter].call(controller)
+      elsif parameter.respond_to?(Model::IDENTIFIER)
+        parameter.send(Model::IDENTIFIER)
+      elsif parameter.is_a?(Class)
+        Stale.interface.key_for_model(parameter)
+      elsif parameter.is_a?(Array)
+        Stale.interface.key_for_model(*parameter)
+      else
+        parameter.to_param
+      end
+    end
+
+    def define_named_parameter(method, &block)
+      block = method.to_proc unless block_given?
+      self.named_parameters[method] = block
+    end
+    alias_method :parameter, :define_named_parameter
+
+    def named_parameters
+      @named_parameters ||= {}
+    end
+  end
+end

data/lib/stale/version.rb

@@ -0,0 +1,3 @@
+module Stale
+  VERSION = "0.0.1"
+end

data/lib/stale/view.rb

@@ -0,0 +1,39 @@
+module Stale
+  module View
+    include Fragments
+
+    def stale(parameters, &block)
+      if !controller.perform_caching
+        safe_concat(build_stale_fragment(&block))
+        return
+      end
+
+      key = Stale.interface.key_for_parameters(parameters, controller)
+      Stale.interface.register_dependencies(key)
+
+      unless fragment = read_stale_fragment(key)
+        fragment = build_stale_fragment(&block)
+        write_stale_fragment(key, fragment)
+      end
+
+      safe_concat(fragment)
+      nil
+    end
+
+    private
+    def build_stale_fragment(&block)
+      # copied from actionpack/lib/action_view/helpers/cache_helper.rb
+      pos = output_buffer.length
+      yield
+      if output_buffer.html_safe?
+        safe_output_buffer = output_buffer.to_str
+        fragment = safe_output_buffer.slice!(pos..-1)
+        self.output_buffer = output_buffer.class.new(safe_output_buffer)
+      else
+        fragment = output_buffer.slice!(pos..-1)
+      end
+
+      fragment
+    end
+  end
+end

data/stale.gemspec

@@ -0,0 +1,18 @@
+Gem::Specification.new do |s|
+  s.name        = "stale"
+  s.version     = "0.0.1"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Norbert Crombach"]
+  s.email       = ["norbert.crombach@primetheory.org"]
+  s.homepage    = "http://github.com/norbert/stale"
+  s.summary     = %q{Experimental fragment caching layer.}
+
+  s.rubyforge_project = "stale"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = s.files.grep(/^test\//)
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'rails', '~> 3.2'
+  s.add_development_dependency 'mocha', '0.12.1'
+end

data/test/cache_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+class StaleCacheTest < ActiveSupport::TestCase
+  setup do
+    @data = mock('data')
+    @cache = Stale::Cache.new(@data)
+
+    Stale.configure do |config|
+      config.cache = @cache
+      config[:key_prefix] = 'test:'
+    end
+  end
+
+  teardown do
+    Stale.configure
+  end
+
+  test "performs get with prefix" do
+    @data.expects(:get).with('test:key').returns('test')
+    assert_equal 'test', @cache.get('key')
+  end
+
+  test "performs set with prefix" do
+    @data.expects(:set).with('test:key', 'test', 30).returns(true)
+    assert @cache.set('key', 'test', 30)
+  end
+
+  test "performs add with prefix" do
+    @data.expects(:add).with('test:key', 'test', 30).returns(true)
+    assert @cache.add('key', 'test', 30)
+  end
+
+  test "performs delete with prefix using multi block" do
+    @data.expects(:multi).never # FIXME
+    @data.expects(:delete).with('test:key:1')
+    @data.expects(:delete).with('test:key:2')
+    assert @cache.delete('key:1', 'key:2')
+  end
+
+  test "modifies keys with cas when set" do
+    @data.expects(:cas).with('test:key', nil).yields(1).returns(true)
+    assert @cache.modify('key') { |value| value + 1 }
+  end
+
+  test "modifies keys with add when not set" do
+    @data.expects(:cas).with('test:key', 30).yields(nil).returns(nil)
+    @data.expects(:add).with('test:key', 1, 30).returns(true)
+    assert @cache.modify('key', 30) { |value| value.to_i + 1 }
+  end
+
+  test "modifies keys by retrying when cas fails" do
+    @data.expects(:cas).twice.with('test:key', 30).yields(1).returns(false).then.returns(true)
+    assert @cache.modify('key', 30) { |value| value + 1 }
+  end
+end

data/test/configuration_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+class StaleConfigurationTest < ActiveSupport::TestCase
+  teardown do
+    Stale.configure
+  end
+
+  test "allows configuration with block" do
+    result = nil
+    Stale.configure do |config|
+      result = config
+    end
+    assert_equal result, Stale.configuration
+  end
+
+  test "has accessors for options" do
+    @configuration = Stale::Configuration.new
+    value = 1.hour
+    assert_equal value, @configuration[:expiration_time] = value
+    assert_equal value, @configuration[:expiration_time]
+  end
+
+  test "provides accessors for cache and interface" do
+    @configuration = Stale::Configuration.new
+    @cache = mock('cache')
+    @interface = mock('interface')
+    @configuration.cache = @cache
+    @configuration.interface = @interface
+    Stale.configuration = @configuration
+    assert_equal @cache, Stale.cache
+    assert_equal @interface, Stale.interface
+  end
+end

data/test/controller_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+class StaleControllerTest < ActiveSupport::TestCase
+  setup do
+    @controller = StaleTestController.new
+    @controller.perform_caching = true
+  end
+
+  test "runs block when fragment does not exist" do
+    key = ['test']
+    @controller.expects(:stale_fragment_exist?).with(key).returns(false)
+
+    assert_throws(:perform) {
+      @controller.stale(key) {
+        throw :perform
+      }
+    }
+  end
+
+  test "does not run block when fragment exists" do
+    key = ['test']
+    @controller.expects(:stale_fragment_exist?).with(key).returns(true)
+
+    assert_nothing_thrown {
+      @controller.stale(key) {
+        throw :perform
+      }
+    }
+  end
+
+  test "runs block when caching is disabled" do
+    key = ['test']
+    @controller.perform_caching = false
+    @controller.expects(:stale_fragment_exist?).never
+
+    assert_throws(:perform) {
+      @controller.stale(key) {
+        throw :perform
+      }
+    }
+  end
+
+  test "registers dependencies for the converted key" do
+    key = [:test]
+    Stale.interface.expects(:key_for_parameters).with(key, @controller).returns(['test'])
+    Stale.interface.expects(:register_dependencies).with(['test'])
+    @controller.expects(:stale_fragment_exist?).with(['test']).returns(false)
+
+    @controller.stale(key) {
+      nil
+    }
+  end
+end

data/test/dependencies_test.rb

@@ -0,0 +1,46 @@
+require 'test_helper'
+
+class StaleDependenciesTest < ActiveSupport::TestCase
+  setup do
+    @cache = Stale.configuration.cache = mock('cache')
+    @interface = Stale.interface
+  end
+
+  teardown do
+    Stale.configure
+  end
+
+  test "registers no dependencies for a key without models" do
+    @interface.expects(:register_dependency).never
+    @interface.register_dependencies(['test'])
+  end
+
+  test "registers dependencies for a key with models" do
+    @interface.expects(:register_dependency).with('model:1', 'test:model:1:model:2')
+    @interface.expects(:register_dependency).with('model:2', 'test:model:1:model:2')
+    @interface.register_dependencies(['test', 'model:1', 'model:2'])
+  end
+
+  test "expires dependencies for a model and collection" do
+    @interface.expects(:expire_dependencies_from_list).with('model:1:dependencies')
+    @interface.expects(:expire_dependencies_from_list).with('model::dependencies')
+    @interface.expire_dependencies('model:1')
+  end
+
+  test "registers dependencies for models" do
+    @interface.expects(:add_dependency_to_list).with('model:1:dependencies', 'test:model:1')
+    @interface.register_dependency('model:1', 'test:model:1')
+  end
+
+  test "adds dependencies to lists" do
+    @cache.expects(:modify).with('model:1:dependencies').yields(nil).returns(true)
+    @interface.add_dependency_to_list('model:1:dependencies', 'test:model:1')
+  end
+
+  test "expires dependencies from lists" do
+    keys = ['test:model:1', 'test:model:1:attributes']
+    @cache.expects(:get).with('model:1:dependencies').returns(keys)
+    @cache.expects(:delete).with(*keys)
+    @interface.expire_dependencies_from_list('model:1:dependencies')
+  end
+end

data/test/fragments_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+class StaleFragmentsTest < ActiveSupport::TestCase
+  setup do
+    @cache = Stale.configuration.cache = mock('cache')
+    @view = StaleTestView.new
+  end
+
+  teardown do
+    Stale.configure
+  end
+
+  test "reads fragments by key" do
+    @cache.expects(:get).with('controller:action').returns('test')
+    assert_equal 'test', @view.read_stale_fragment(['controller', 'action'])
+  end
+
+  test "writes fragments by key with default expiration time" do
+    @cache.expects(:set).with('controller:action', 'test', Stale.configuration[:expiration_time])
+    @view.write_stale_fragment(['controller', 'action'], 'test')
+  end
+
+  test "writes fragments by key with given expiration time" do
+    @cache.expects(:set).with('controller:action', 'test', 30)
+    @view.write_stale_fragment(['controller', 'action'], 'test', 30)
+  end
+
+  test "checks if fragments exist by reading" do
+    @cache.expects(:get).with('controller:action').returns('test')
+    assert @view.stale_fragment_exist?(['controller', 'action'])
+  end
+end

data/test/interface_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+class StaleInterfaceTest < ActiveSupport::TestCase
+  setup do
+    @interface = Stale.interface
+  end
+
+  test "delegates converting parameters to configuration" do
+    controller_mock = mock('controller')
+    Stale.configuration.expects(:key_for_parameters).with(['test'], controller_mock)
+    @interface.key_for_parameters(['test'], controller_mock)
+  end
+
+  test "generates keys for models" do
+    assert_equal 'stale_test_model:1', @interface.key_for_model(StaleTestModel, 1)
+    assert_equal 'stale_test_model:', @interface.key_for_model(StaleTestModel)
+    assert_equal 'stale_test_model:1', @interface.key_for_model('stale_test_model', 1)
+    assert_equal 'stale_test_model:1:attributes', @interface.key_for_model('stale_test_model', 1, :attributes)
+  end
+
+  test "converts key arrays to strings" do
+    assert_equal 'test:model:1', @interface.key_as_string(['test', 'model:1'])
+  end
+
+  test "extracts model keys from arrays" do
+    assert_equal ['model:1', 'model:2:attributes'], @interface.models_from_key(['test', 'model:1', 'model:2:attributes'])
+  end
+
+  test "extracts collections from model keys" do
+    assert_equal 'model:', @interface.collection_from_key('model:1')
+  end
+end

data/test/model_test.rb

@@ -0,0 +1,10 @@
+require 'test_helper'
+
+class StaleModelTest < ActiveSupport::TestCase
+  test "expires dependencies for model key" do
+    @model = StaleTestModel.new(1)
+    Stale.interface.expects(:expire_dependencies).with(@model.stale_key)
+
+    @model.expire_stale_dependencies
+  end
+end

data/test/parameters_test.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+
+class StaleParametersTest < ActiveSupport::TestCase
+  def controller_mock
+    mock('controller', :controller_name => 'test')
+  end
+
+  setup do
+    @configuration = Stale::Configuration.new
+  end
+
+  test "defines named parameters with block" do
+    @configuration.define_named_parameter :controller_name do |controller|
+      controller.controller_name
+    end
+
+    assert_equal 'test', @configuration.key_for_parameter(:controller_name, controller_mock)
+  end
+
+  test "defines named parameters without block" do
+    @configuration.define_named_parameter :controller_name
+
+    assert_equal 'test', @configuration.key_for_parameter(:controller_name, controller_mock)
+  end
+
+  test "converts model parameters to keys" do
+    assert_equal 'stale_test_model:1', @configuration.key_for_parameter(StaleTestModel.new(1))
+  end
+
+  test "converts class parameters to keys" do
+    assert_equal 'stale_test_model:', @configuration.key_for_parameter(StaleTestModel)
+  end
+
+  test "converts array parameters to keys" do
+    assert_equal 'stale_test_model:2', @configuration.key_for_parameter([StaleTestModel, 2])
+  end
+
+  test "converts string parameters to keys" do
+    assert_equal 'test', @configuration.key_for_parameter('test')
+  end
+
+  test "raises when converting unknown named parameters to keys" do
+    # FIXME
+    assert_raises(NoMethodError) {
+      @configuration.key_for_parameter(:test, mock('controller'))
+    }
+  end
+
+  test "converts multiple parameters to keys in order" do
+    @configuration.define_named_parameter :controller_name
+
+    assert_equal ['test', 'index'], @configuration.key_for_parameters([:controller_name, 'index'], controller_mock)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,46 @@
+require 'stale'
+
+require 'test/unit'
+require 'mocha'
+
+class StaleTestController
+  include Stale::Controller
+
+  attr_accessor :perform_caching
+
+  def controller_name
+    'stale_test_controller'
+  end
+end
+
+class StaleTestModel
+  include Stale::Model
+
+  attr_reader :id
+
+  def initialize(id)
+    @id = id
+  end
+
+  def to_param
+    id
+  end
+end
+
+class StaleTestView
+  include Stale::View
+
+  attr_reader :controller, :output_buffer
+
+  def initialize
+    @controller = StaleTestController.new
+  end
+
+  def safe_concat(value)
+    @output_buffer = value
+  end
+
+  def build_stale_fragment
+    yield
+  end
+end

data/test/view_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+class StaleViewTest < ActiveSupport::TestCase
+  setup do
+    @view = StaleTestView.new
+    @view.controller.perform_caching = true
+  end
+
+  test "builds and writes fragment when fragment does not exist" do
+    key = ['test']
+    @view.expects(:read_stale_fragment).with(key).returns(nil)
+    @view.expects(:write_stale_fragment).with(key, 'perform')
+
+    @view.stale(key) {
+      'perform'
+    }
+    assert_equal 'perform', @view.output_buffer
+  end
+
+  test "does not build fragment when fragment exists" do
+    key = ['test']
+    @view.expects(:read_stale_fragment).with(key).returns('test')
+    @view.expects(:write_stale_fragment).never
+
+    assert_nothing_thrown {
+      @view.stale(key) {
+        throw :perform
+      }
+    }
+    assert_equal 'test', @view.output_buffer
+  end
+
+  test "builds fragment without reading when caching is disabled" do
+    key = ['test']
+    @view.controller.perform_caching = false
+    @view.expects(:read_stale_fragment).never
+    @view.expects(:write_stale_fragment).never
+
+    @view.stale(key) {
+      'perform'
+    }
+    assert_equal 'perform', @view.output_buffer
+  end
+
+  test "registers dependencies for the converted key" do
+    key = [:test]
+    Stale.interface.expects(:key_for_parameters).with(key, @view.controller).returns(['test'])
+    Stale.interface.expects(:register_dependencies).with(['test'])
+    @view.expects(:read_stale_fragment).with(['test']).returns('test')
+
+    @view.stale(key) {
+      nil
+    }
+  end
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: stale
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Norbert Crombach
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.12.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.12.1
+description: 
+email:
+- norbert.crombach@primetheory.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/stale.rb
+- lib/stale/cache.rb
+- lib/stale/configuration.rb
+- lib/stale/controller.rb
+- lib/stale/dependencies.rb
+- lib/stale/fragments.rb
+- lib/stale/interface.rb
+- lib/stale/model.rb
+- lib/stale/parameters.rb
+- lib/stale/version.rb
+- lib/stale/view.rb
+- stale.gemspec
+- test/cache_test.rb
+- test/configuration_test.rb
+- test/controller_test.rb
+- test/dependencies_test.rb
+- test/fragments_test.rb
+- test/interface_test.rb
+- test/model_test.rb
+- test/parameters_test.rb
+- test/test_helper.rb
+- test/view_test.rb
+homepage: http://github.com/norbert/stale
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: stale
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Experimental fragment caching layer.
+test_files:
+- test/cache_test.rb
+- test/configuration_test.rb
+- test/controller_test.rb
+- test/dependencies_test.rb
+- test/fragments_test.rb
+- test/interface_test.rb
+- test/model_test.rb
+- test/parameters_test.rb
+- test/test_helper.rb
+- test/view_test.rb