cachex 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.DS_Store
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cachex.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Milovan Zogovic
+
+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,103 @@
+# Cachex
+
+This gem is only proof of concept and it is not safe for use in production.
+
+## Idea
+
+This gem is inspired by excellent [Cashier](https://github.com/twinturbo/cashier) gem. I wanted to take it a step further and try to automate tag dependency generation.
+
+I had this scenario in mind:
+
+* Blog has many posts
+* Each post has an author (user)
+* Each post has many comments
+* Each comment has its own author (user)
+
+Each model has its own partial. Inside `_post` partial we have `_user` partial that renders post's author. `_post` partial also include many `_comment` partials. Each `_comment` partial have author's name displayed in it.
+
+We're also using fragment caching in order to cache entire post for faster serving. The burning question is: **what happens if user decides to change its name (or perhaps, more commonly, an avatar)?**. We have to invalidate every cached partial that displayed that user. How do we do that?
+
+If we're using auto-expiring key strategy the only way to accomplish this would be to `touch` **everything** that has to do with that user. That just doesn't make any sense.
+
+If we're using tag-based strategy, then we would need to manually tag every fragment with all users that have to do something with it (even users from its comments). Such approach is going to be very hard when we get to deeply nested partials. Top most partial will have to be aware of **all dependencies** down to the deepest one.
+
+And finally, my solution: **to automatically extract all dependencies from all sub-partials and to store them to help cache invalidation**.
+
+## Example
+
+Here is how the example above is implemented with `cachex`.
+
+We have `_post` partial defined like this:
+
+
+    <%= cachex dom_id(post) do %>
+      <article class="post">
+        <h1><%= post.title %></h1>
+        <p>Author: <%= render post.user %></p>
+        
+        <section class="comments">
+          <h3>Comments:</h3>
+          <%= render post.comments %>
+        </section>
+      </article>
+    <% end %>
+
+Please note that instead of using `cache` we're using `cachex` helper method. We need to pass at least one argument which is the key for given record. It is good practice to use something that can be easily generated and parsed, so `dom_id` method will do the job.
+
+The rest is just good old rails partial. From it, we're rendering `_user` partial to output post author, and multiple `_comment` partials.
+
+Here is how `_user` partial looks like:
+
+
+    <%= cachex dom_id(user) do %>
+      <span class="user"><%= user.name %></span>
+    <% end %>
+
+Again, nothing special to it. Just displaying the user name.
+
+And, here is how the `_comment` partial looks like:
+
+
+    <%= cachex dom_id(comment), "user_#{comment.user_id}" do %>
+      <article class="comment">
+        <p><%= comment.body %></p>
+        <p>Author: <%= comment.user.name %></p>
+      </article>
+    <% end %>
+
+You notice that we've passed second parameter to `cachex` call. Actually, you may pass as many as you like. These are keys that current partial depends on. In our case it depends on comment's author. We could have just rendered the user partial here as well, but just wanted to demonstrate that you can also pass dependencies manually.
+
+Now comes the magic. First time this gets rendered, post will aggregate all dependencies from all sub-partials. In our case post will be tagged with following dependencies: 
+
+* It's author
+* All of its comments
+* All of its comment authors
+
+**If any of these keys expire, post will expire as well!** 
+
+For example, if one of the author's of post comment changes its name, following will happen:
+
+* Post fragment starts regenerating
+* Author fragment is read from cache
+* All comments (but the one with changed author) is read from cache
+* The comment with changed author re-renders
+* Dependencies are aggregated again and re-applied
+* Post gets cached
+
+`Cachex` stores dependencies in `REDIS` in both directions and it uses sets to manage them, so it works really fast.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cachex'
+
+And then execute:
+
+    $ rails generate cachex:install
+
+
+## Author
+
+Developed by Milovan Zogovic.

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/cachex.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/cachex/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Milovan Zogovic"]
+  gem.email         = ["milovan.zogovic@gmail.com"]
+  gem.description   = %q{Automated tag based fragment caching}
+  gem.summary       = %q{Automated tag based fragment caching}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "cachex"
+  gem.require_paths = ["lib"]
+  gem.version       = Cachex::VERSION
+end

data/lib/cachex.rb

@@ -0,0 +1,70 @@
+require 'cachex/adapters/redis_store'
+require 'cachex/config'
+require 'cachex/node'
+require 'cachex/version'
+require 'cachex/view_helpers'
+require 'cachex/railtie'
+
+module Cachex
+  extend self
+
+  def cache(context, key, tags=[], &block)
+    if !@parent || @parent.key == 'root'
+      @parent = Node.new('root') # avoiding to reuse same root
+    end
+
+    node = Node.new(key, tags)
+    @parent.add_child node
+
+    if !Rails.cache.exist?(key) || !adapter.redis.exists(fqkey(key))
+      grandparent = @parent
+      @parent = node
+      content = context.capture(&block)
+      Rails.cache.write(key, content)
+      @parent = grandparent
+
+      # two-way dependency binding
+      adapter.redis.del fqkey(key)
+      if (all_tags = node.all_tags).length > 0
+        adapter.redis.sadd fqkey(key), all_tags
+        all_tags.each do |tag|
+          adapter.redis.sadd fqtag(tag), key
+        end
+      end
+
+    else
+      content = Rails.cache.read(key)
+      node.add_tags adapter.redis.smembers(fqkey(key))
+    end
+
+    # Rails.logger.info "--- #{key} depends on #{node.all_tags.inspect}"
+
+    content
+  end
+
+
+  def expire(*tags)
+    tags.each do |tag|
+      Rails.cache.delete tag
+
+      adapter.redis.smembers(fqtag(tag)).each do |key|
+        Rails.cache.delete key
+      end
+      adapter.redis.del fqtag(tag)
+    end
+  end
+
+
+  def fqkey(key)
+    "cachex_key_dependencies_#{key}"
+  end
+
+  def fqtag(tag)
+    "cachex_tag_dependencies_#{tag}"
+  end
+
+  def adapter
+    config.adapter
+  end
+
+end

data/lib/cachex/adapters/redis_store.rb

@@ -0,0 +1,8 @@
+module Cachex
+  module Adapters
+    class RedisStore
+      attr_accessor :redis
+
+    end
+  end
+end

data/lib/cachex/config.rb

@@ -0,0 +1,24 @@
+module Cachex
+
+  def self.config
+    if !@config
+      @config = Config.new
+      yield @config
+    end
+    @config
+  end
+
+  class Config
+    attr_reader :adapter
+
+    def adapter=(adapter)
+      case adapter.to_sym
+      when :redis
+        @adapter = Adapters::RedisStore.new
+      else
+        raise ArgumentError, "Specified Cachex adapter is not supported!"
+      end
+    end
+
+  end
+end

data/lib/cachex/node.rb

@@ -0,0 +1,27 @@
+module Cachex
+
+  class Node
+    attr_reader :key
+
+    def initialize(key, tags=[])
+      @children = []
+      @key = key
+      @tags = tags
+    end
+
+    def add_child(node)
+      @children ||= []
+      @children << node
+    end
+
+    def add_tags(additional_tags)
+      @tags += additional_tags
+    end
+
+    def all_tags
+      [@tags, @children.map(&:key), @children.map(&:all_tags)].flatten.compact.uniq
+    end
+
+  end
+
+end

data/lib/cachex/railtie.rb

@@ -0,0 +1,7 @@
+module Cachex
+  class Railtie < Rails::Railtie
+    initializer 'cachex.view_helpers' do
+      ActionView::Base.send :include, ViewHelpers
+    end
+  end
+end

data/lib/cachex/version.rb

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

data/lib/cachex/view_helpers.rb

@@ -0,0 +1,7 @@
+module Cachex
+  module ViewHelpers
+    def cachex(key, *tags, &block)
+      Cachex.cache self, key, tags, &block
+    end
+  end
+end

data/lib/generators/cachex/install_generator.rb

@@ -0,0 +1,12 @@
+module Cachex
+
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path("../../templates", __FILE__)
+
+    desc "Copies initializer script"
+    def copy_initializer
+      copy_file "cachex.rb", "config/initializers/cachex.rb"
+    end
+  end
+
+end

data/lib/generators/templates/cachex.rb

@@ -0,0 +1,4 @@
+Cachex.config do |c|
+  c.adapter = :redis
+  c.adapter.redis = Redis.new(host: '127.0.0.1', port: '6379')
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: cachex
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Milovan Zogovic
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-15 00:00:00.000000000 Z
+dependencies: []
+description: Automated tag based fragment caching
+email:
+- milovan.zogovic@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- cachex.gemspec
+- lib/cachex.rb
+- lib/cachex/adapters/redis_store.rb
+- lib/cachex/config.rb
+- lib/cachex/node.rb
+- lib/cachex/railtie.rb
+- lib/cachex/version.rb
+- lib/cachex/view_helpers.rb
+- lib/generators/cachex/install_generator.rb
+- lib/generators/templates/cachex.rb
+homepage: ''
+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: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Automated tag based fragment caching
+test_files: []