split_cacheable 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 048a0263fd1ce03ec972455cd98fbe5ef2e66407
+  data.tar.gz: 8fefa33bf269410149f43805eefeaccc58f9e177
+SHA512:
+  metadata.gz: 67809fddc3a286a0710ecca6f9ad55e937bb7cf22af37afc74b725065cd474560116945caa11fbd8e6a27aaea41a732553b18b95c36d3fad18c0c20d6343d964
+  data.tar.gz: c63cb1e25204522877c02bede101413dc2c646718b1c6a9b5438e24dfd260db031aa2e0545abb4b3246e6ef5163babd5816d50edf060203da9f8273b706c9a9a

data/.gitignore

@@ -0,0 +1,17 @@
+*.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 split_cacheable.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 harrystech
+
+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/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Daniel Schwartz
+
+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,83 @@
+# Split::Cacheable
+
+An extension to [Split](http://github.com/andrew/split) to allow for automatic cache bucket creation accross Split tests.
+
+## Requirements
+
+The split gem and its dependencies.
+
+## Setup
+
+In your Gemfile:
+
+    gem 'split_cacheable'
+
+Then run:
+
+    bundle install
+
+## Why?
+
+We use action caching in Rails 3 to cache both our standard and mobile site. We wanted to be able to quickly run Split tests without worrying about setting a custom cache_path each time as well as remembering to make the needed changes to our ActiveRecord models. 
+
+## How? 
+
+Under the hood, action caching uses `fragment_cache_key` in `ActionController::Base`. This gem patches this method to incldue our generated current tests and variations. 
+
+If you already override `fragment_cache_key` in your project you can get the split partial cache key we generate by calling `current_tests_and_variations`
+
+## Controller DSL
+
+We've created an easy to remember DSL for adding active tests to specific methods:
+
+```
+class ProductController < ApplicationController
+    cacheable_ab_test :login_flow,
+        :only => [:index, :some_other_method], 
+        :except => [:index, :some_other_method], 
+        :if => Proc.new { |controller| controller.mobile_device? }
+        
+    def index
+    
+    end
+end
+```
+
+* `:login_flow`: The name of the test as it appears in your Split configuration
+* `:only`: A symbol or an array of symbols corresponding to the action names you'd like this test to run for
+* `:except`: A symbol or an array of symbols corresponding to the action names you'd like to exclude from the test (it will run on all actions not listed here)
+* `:if`: A boolean value or Proc to be evaluated at runtime. The current controller instance is passed into the Proc for you to use
+
+Only include either `:only` or `:except` -- if you include both, `:only` will take precedence.
+
+## Outside Controller Access
+
+If you'd like to manually expire your action caches in models/sweeper/wherever we give you access to create an instance of the adapter use internally.
+
+### Instantiate an adapter
+
+`Split::Cacheable::Adapter.new(<controller_instance>, <action_name>)`
+
+* `controller_instance`: A new instance of an ActionController::Base subclass
+* `action_name`: A symbol that corresponds to the action you want to uncache
+
+ex: `Split::Cacheable::Adapter.new(ProductController.new, :index)`
+
+### Then get all possible variations to uncache
+
+`Split::Cacheable::Adapter.new(ProductController.new, :index).get_all_possible_variations`
+
+This will return an array of all the possible cache keys ever generated so you can manually uncache your views:
+
+```
+Split::Cacheable::Adapter.new(ProductController.new, :index).get_all_possible_variations.each { |split_cache_key|
+    Rails.cache.delete("views/#{split_cache_key}/#{current_host}/products")
+}
+```
+
+Note that we don't evaluate the `:if` option when you instantiate the controller manually. This is because we assume `Proc`s will usually be used to decide whether to show the test based on the current request. By not evaluating the `:if`s in this scenario we are able to return all possible cache keys regardless of request type. 
+
+## Development
+
+Source hosted at [GitHub](http://github.com/harrystech/split_cacheable).<br>
+Report Issues/Feature requests on [GitHub Issues](http://github.com/harrystech/split_cacheable/issues).

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/split_cacheable/engine.rb

@@ -0,0 +1,12 @@
+module Split
+    module Cacheable
+        class Engine < ::Rails::Engine
+            initializer "split" do |app|
+                if Split.configuration.include_rails_helper
+                    ActionController::Base.send :include, Split::Cacheable::Helper
+                    ActionController::Base.helper Split::Cacheable::Helper
+                end
+            end
+        end
+    end
+end

data/lib/split_cacheable/helper.rb

@@ -0,0 +1,39 @@
+module Split
+    module Cacheable
+        module Helper
+            def self.included(base)
+                base.send :include, InstanceMethods
+                base.extend ClassMethods
+            end
+
+            module InstanceMethods
+                # Patch the default ActionController::Base action_cache key creation
+                # by prepending our current tests + variation key generated in the next method
+                def fragment_cache_key(key)
+                    super("#{current_tests_and_variations}/#{key}")
+                end
+
+                # Controller helper method to get the current active tests + variations in the form of a partial cache key
+                def current_tests_and_variations
+                    Split::Cacheable::Adapter.new(self, self.action_name.to_sym).get_current_variations
+                end
+            end
+
+            module ClassMethods
+                # This is how you specify your tests in a sub-class of ActionController::Base
+                # ex: cacheable_ab_test :homepage_hero, :only => :our_story, :if => Rails.env.production?
+                def cacheable_ab_test(test_name, options)
+                    options[:except] = Array(options[:except])
+                    options[:only] = Array(options[:only])
+
+                    self.split_cacheable_ab_tests << options.merge({:test_name => test_name})
+                end
+
+                # Class level variable. cacheable_ab_test's get pushed onto it
+                def split_cacheable_ab_tests
+                    @split_cacheable_ab_tests ||= Array.new
+                end
+            end
+        end
+    end
+end

data/lib/split_cacheable/version.rb

@@ -0,0 +1,5 @@
+module Split
+	module Cacheable
+		VERSION = "1.0.0"
+	end
+end

data/lib/split_cacheable.rb

@@ -0,0 +1,93 @@
+require 'pry'
+require 'pry-byebug'
+require "split_cacheable/version"
+require 'split_cacheable/helper'
+require 'split_cacheable/engine' if defined?(Rails) && Rails::VERSION::MAJOR === 3
+require 'split'
+
+# This is the main Adapter instance. It expects:
+#     controller_instance => An instance of ActionController::Base
+#     action_name => The current action being performed (as a symbol)
+#
+# We don't include this as a module so that you can instantite this yourself
+# so you can call get_all_possible_variations to clear your caches
+
+module Split
+    module Cacheable
+        class Adapter
+            DEFAULT_KEY = 'default/control'
+
+            def initialize(controller_instance, action_name)
+                @controller = controller_instance
+                @action_name = action_name
+            end
+
+            # Get all tests which should be active on this controller for this action
+            def active_tests
+                ab_tests = @controller.class.split_cacheable_ab_tests.select { |test_obj|
+                    is_active = false
+
+                    if test_obj[:only].include?(@action_name)
+                        is_active = true
+                    end
+
+                    if test_obj[:only].empty? && !test_obj[:except].include?(@action_name)
+                        is_active = true
+                    end
+
+                    # The assumption here is that we should only evaluate the :if Proc or Boolean
+                    # if we are part of a live ActionController::Base.
+                    # This allows active_tests to return all possible active tests for when you call get_all_possible_variations
+                    if (defined?(@controller.request) && !@controller.request.nil?) && test_obj[:if]
+                        if is_active && (test_obj[:if].is_a?(Proc) ? test_obj[:if].call(@controller) : !!test_obj[:if])
+                            is_active = true
+                        else
+                            is_active = false
+                        end
+                    end
+
+                    is_active
+                }
+            end
+
+            # Use Split to return a partial cache key (used in fragment_cache_key)
+            # by calling ab_test which is an internal Split::Helper method that is now on your
+            # controller instance
+            #
+            # You should not be calling this method outside of a live ActionController::Base
+            def get_current_variations
+                if !defined?(@controller.request) || @controller.request.nil?
+                    return DEFAULT_KEY
+                else
+                    return !active_tests.empty? ? active_tests.map{|test_obj| "#{test_obj[:test_name]}/#{@controller.ab_test(test_obj[:test_name])}"}.join('/') : DEFAULT_KEY
+                end
+            end
+
+            # Search the Split::ExperimentCatalog to find all tests and generate
+            # every possible partial cache key
+            #
+            # Use this to clear all your action_caches
+            def get_all_possible_variations
+                test_variations = Array.new
+                active_tests.each { |test_obj|  
+                    split_test = Split::ExperimentCatalog.find(test_obj[:test_name])
+                    if split_test
+                        test_variations << split_test.alternatives.map { |alternative|
+                            "#{split_test.name}/#{alternative.name}"
+                        } 
+                    end
+                }
+
+                case test_variations.length
+                when 0
+                    return [DEFAULT_KEY]
+                when 1
+                    return test_variations[0]
+                else
+                    first_test = test_variations.shift
+                    return first_test.product(*test_variations).map{|a| a.join("/")}
+                end
+            end
+        end
+    end
+end

data/spec/cacheable_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Split::Cacheable do
+    ALL_VARIATIONS = ["test_1/old/test_2/left", "test_1/old/test_2/right", "test_1/new/test_2/left", "test_1/new/test_2/right"]
+
+    it "should return the default variation if there is no request" do
+        Split::Cacheable::Adapter.new(TestControllerWithoutRequest.new, :index).get_current_variations.should eql Split::Cacheable::Adapter::DEFAULT_KEY
+    end
+
+    it "should return a possible active variation if the controller has a request" do
+        ALL_VARIATIONS.should include(Split::Cacheable::Adapter.new(TestControllerWithRequest.new, :index).get_current_variations)
+    end
+
+    it "should return all active tests for a controller/action combination" do
+        Split::Cacheable::Adapter.new(TestControllerWithRequest.new, :index).active_tests.should eql [{:only=>[:index], :except=>[], :test_name=>:test_1}, {:only=>[], :except=>[:show], :test_name=>:test_2}]
+    end
+
+    it "should return all possible variations of the cachekey" do
+        Split::Cacheable::Adapter.new(TestControllerWithoutRequest.new, :index).get_all_possible_variations.should eql ALL_VARIATIONS
+    end
+
+    it "should disregard tests that don't pass the :if Proc" do
+        controller = TestControllerWithRequestAndProc.new
+        Split::Cacheable::Adapter.new(controller, :index).get_current_variations.should eql Split::Cacheable::Adapter::DEFAULT_KEY
+
+        controller.instance_variable_set("@mobile_device", true)
+        ALL_VARIATIONS.should include(Split::Cacheable::Adapter.new(TestControllerWithRequest.new, :index).get_current_variations)
+    end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,71 @@
+ENV['RACK_ENV'] = "test"
+
+require 'rubygems'
+require 'bundler/setup'
+require 'split'
+require 'ostruct'
+require 'split/helper'
+require 'split_cacheable'
+require 'split_cacheable/helper'
+
+Split.configure do |config|
+    config.enabled = true
+    config.db_failover = true
+    config.persistence = :session
+    config.experiments = {
+        "test_1" => {
+            :alternatives => ['old', 'new']
+        },
+
+        "test_2" => {
+            :alternatives => ['left', 'right']
+        },
+    }
+end
+
+class TestControllerWithoutRequest
+    include Split::Helper
+    include Split::Cacheable::Helper
+
+    cacheable_ab_test :test_1, :only => :index
+    cacheable_ab_test :test_2, :except => :show
+    def index
+            
+    end
+
+    def session
+      @session ||= {}
+    end
+
+    def params
+      @params ||= {}
+    end
+end
+
+class TestControllerWithRequest < TestControllerWithoutRequest
+    cacheable_ab_test :test_1, :only => :index
+    cacheable_ab_test :test_2, :except => :show
+    def index
+        
+    end
+
+    def request(ua = 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_6; de-de) AppleWebKit/533.20.25 (KHTML, like Gecko) Version/5.0.4 Safari/533.20.27')
+      r = OpenStruct.new
+      r.user_agent = ua
+      r.ip = '192.168.1.1'
+      @request ||= r
+    end
+end
+
+class TestControllerWithRequestAndProc < TestControllerWithRequest
+    cacheable_ab_test :test_1, :only => :index, :if => Proc.new { |c| c.mobile_device? }
+    cacheable_ab_test :test_2, :except => :show, :if => Proc.new { |c| c.mobile_device? }
+    
+    def index
+        
+    end
+
+    def mobile_device?
+        @is_mobile
+    end
+end

data/split_cacheable.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'split_cacheable/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "split_cacheable"
+  spec.version       = Split::Cacheable::VERSION
+  spec.authors       = ["Daniel Schwartz"]
+  spec.email         = ["dschwartz88@gmail.com"]
+  spec.summary       = %q{We use action caching in Rails 3 to cache both our standard and mobile site. We wanted to be able to quickly run Split tests without worrying about setting a custom cache_path each time as well as remembering to make the needed changes to our ActiveRecord models.}
+  spec.description   = %q{An extension to Split to allow for automatic cache bucket creation accross Split tests.}
+  spec.homepage      = "https://github.com/harrystech/split_cacheable"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "split"
+  spec.add_dependency "activesupport"
+
+  spec.add_development_dependency "rspec", "~>  2.14"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-byebug"
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: split_cacheable
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Daniel Schwartz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: split
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An extension to Split to allow for automatic cache bucket creation accross
+  Split tests.
+email:
+- dschwartz88@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/split_cacheable.rb
+- lib/split_cacheable/engine.rb
+- lib/split_cacheable/helper.rb
+- lib/split_cacheable/version.rb
+- spec/cacheable_spec.rb
+- spec/spec_helper.rb
+- split_cacheable.gemspec
+homepage: https://github.com/harrystech/split_cacheable
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: We use action caching in Rails 3 to cache both our standard and mobile site.
+  We wanted to be able to quickly run Split tests without worrying about setting a
+  custom cache_path each time as well as remembering to make the needed changes to
+  our ActiveRecord models.
+test_files:
+- spec/cacheable_spec.rb
+- spec/spec_helper.rb