patella 0.0.1

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 patella.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Keenan Brock
+
+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,37 @@
+# Patella
+
+Gem for the RailsConf 2012 talk Patella: It's Memoization into Memcached calculated in the background with Resque.
+[www.slideshare.net/jdwyah/patella-railsconf-2012](http://www.slideshare.net/jdwyah/patella-railsconf-2012)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'patella'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install patella
+
+## Usage
+
+```ruby
+  def self.my_slow_method(user_id)
+    all_notifications_for(User.find(user_id))
+  end
+  patella_reflex :notification_unread_count, :expires_in => 3.minutes, :class_method => true
+```
+
+See the tests for more [examples](https://github.com/kbrock/patella/blob/master/test/patella_test.rb)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/lib/patella.rb

@@ -0,0 +1,8 @@
+require "patella/version"
+require "patella/patella"
+require "patella/send_later"
+require "patella/send_later_worker"
+
+module Patella
+  # Your code goes here...
+end

data/lib/patella/patella.rb

@@ -0,0 +1,130 @@
+require 'active_support'
+require 'json'
+
+module Patella::Patella
+
+  def self.included(base)
+    base.extend ClassMethods
+    base.send :include, Patella::SendLater
+  end
+
+  def patella_key(symbol, args)
+    id_param = respond_to?(:id) ? self.id : nil
+    "patella/#{self.class.to_s}/#{id_param}/#{symbol}/#{Digest::MD5.hexdigest(args.to_json)}"
+  end
+
+  module ClassMethods
+    def patella_key(symbol, args)
+      "patella/#{self.to_s}//#{symbol}/#{Digest::MD5.hexdigest(args.to_json)}"
+    end
+
+    def patella_reflex(symbol, options = {})      
+      options[:expires_in] ||= 30*60
+      options[:soft_expiration] ||= 0
+      options[:no_backgrounding] ||= false
+      is_class = options[:class_method]
+
+      original_method = :"_unpatellaed_#{symbol}"
+
+      method_definitions = <<-EOS, __FILE__, __LINE__ + 1
+
+        if method_defined?(:#{original_method})
+          raise "Already patella'd #{symbol}"
+        end
+        alias #{original_method} #{symbol}
+
+        def caching_#{symbol}(args)
+          cache_key = self.patella_key('#{symbol}',args)
+          result = args.any? ? #{original_method}(*args) : #{original_method}()
+          json = {'result' => result, 'soft_expiration' => Time.now + #{options[:expires_in]} - #{ options[:soft_expiration]}}.to_json
+          Rails.cache.write(cache_key, json, :expires_in => #{options[:expires_in]})
+          result
+        end
+
+        def clear_#{symbol}(*args)
+          cache_key = self.patella_key('#{symbol}',args)
+          Rails.cache.delete(cache_key)
+        end
+
+        def #{symbol}(*args)
+          patella_#{symbol}(args, {:no_backgrounding => #{options[:no_backgrounding]}})
+        end 
+
+        def patella_#{symbol}(args, opts)
+          cache_key = self.patella_key('#{symbol}',args)
+          promise = { 'promise' => true }
+
+          json = Rails.cache.fetch(cache_key, :expires_in => #{options[:expires_in]}, :force => !Rails.caching?) do
+            if opts[:no_backgrounding]
+              promise['result'] = self.send(:caching_#{symbol}, args)
+              promise.delete('promise')
+            else
+              promise['result'] = self.send_later(:caching_#{symbol}, args)   #send_later sends_later when Rails.caching? otherwise sends_now
+              promise.delete('promise') unless Rails.caching?
+            end
+            promise.to_json
+          end
+
+          if promise['promise'] && opts[:no_backgrounding]
+            promise['result'] = self.send(:caching_#{symbol}, args)
+            promise.delete('promise')
+            json = promise.to_json
+          end
+
+          val = JSON.parse(json)
+          if val and !val['promise']
+            loading = false
+            soft_expiration = Time.parse(val['soft_expiration']) rescue nil
+            json_val = val
+            val = val['result']
+          else
+            val = promise
+            loading = true
+          end
+
+          if !loading and soft_expiration and Time.now > soft_expiration
+            expires = #{options[:soft_expiration]} + 10*60
+            json_val['soft_expiration'] = (Time.now - expires).to_s
+            Rails.cache.write(cache_key, json_val, :expires_in => expires)
+            self.send_later(:caching_#{symbol}, args)
+          end
+
+          PatellaResult.new val, loading
+        end
+
+        if private_method_defined?(#{original_method.inspect})                   # if private_method_defined?(:_unmemoized_mime_type)
+          private #{symbol.inspect}                                              #   private :mime_type
+        elsif protected_method_defined?(#{original_method.inspect})              # elsif protected_method_defined?(:_unmemoized_mime_type)
+          protected #{symbol.inspect}                                            #   protected :mime_type
+        end                                                                      # end
+      EOS
+
+      if is_class
+        (class << self; self; end).class_eval *method_definitions
+      else
+        class_eval *method_definitions
+      end
+    end
+  end
+end
+
+class PatellaResult < ActiveSupport::BasicObject
+
+  def initialize(target=nil, loading=false)
+    @target = target
+    @loading = loading
+  end
+
+  def loading?
+    @loading
+  end
+
+  def loaded?
+    !@loading
+  end
+
+  def method_missing(method, *args, &block)
+    @target.send(method, *args, &block)
+  end
+end
+

data/lib/patella/send_later.rb

@@ -0,0 +1,26 @@
+module Patella::SendLater
+
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  def send_later method_name, *args
+    #in dev mode, run the command in process
+    if Rails.caching?
+      Patella::SendLaterWorker.perform_later self.class.to_s, self.id, method_name, *args
+    else
+      self.send method_name, *args
+    end
+  end
+
+  module ClassMethods
+    def send_later method_name, *args
+      if Rails.caching?
+        Patella::SendLaterWorker.perform_later self.to_s, nil, method_name, *args
+      else
+        self.send method_name, *args
+      end
+    end
+  end
+
+end

data/lib/patella/send_later_worker.rb

@@ -0,0 +1,18 @@
+module Patella
+  class SendLaterWorker
+    @queue = :send_later
+
+    def self.perform_later *args
+      self.enqueue *args
+    end
+
+    def self.perform(class_name, instance_id, method_name, *args)
+      o = class_name.constantize
+      o = o.find_by_id instance_id if instance_id
+
+      o.send(method_name, *args)
+    rescue => e
+      raise e, "#{e.message} \nWith SendLater: #{class_name}#{':'+instance_id.to_s if instance_id}##{method_name}(#{args.map(&:to_s).join(',')})", e.backtrace
+    end
+  end
+end

data/lib/patella/version.rb

@@ -0,0 +1,3 @@
+module Patella
+  VERSION = "0.0.1" unless defined?(Patella::VERSION)
+end

data/patella.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/patella/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Jeff Dwyer"]
+  gem.email         = ["jdwyer@patientslikeme.com"]
+  gem.description   = "It's Memoization into Memcached calculated in the background with Resque."
+  gem.summary       = "DSL to add memoization on any method into Memcached calculated in the background with Resque."
+  gem.homepage      = "https://github.com/patientslikeme/patella"
+
+  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          = "patella"
+  gem.require_paths = ["lib"]
+  gem.version       = Patella::VERSION
+  gem.add_dependency 'resque', '~>1.16'
+  gem.add_dependency 'activesupport', '~>2.3' #, :require => 'active_support'
+  gem.add_dependency 'rails', '~>2.3' #, :require => 'active_support'
+  gem.add_dependency 'json'
+  gem.add_development_dependency 'bundler'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'mocha', "~>0.9.8"
+  gem.add_development_dependency 'bourne'
+end

data/test/patella_test.rb

@@ -0,0 +1,144 @@
+require 'test_helper'
+
+class Dummy
+  include Patella::Patella
+  include Patella::SendLater
+
+  attr_accessor :id
+  def initialize id
+    self.id = id
+  end
+
+  def self.find_by_id id
+    new id
+  end
+
+  def foo
+    5
+  end
+  patella_reflex :foo
+
+  def bar(a,b)
+    a+b
+  end
+  patella_reflex :bar
+
+  def baz(add)
+    self.id + add
+  end
+  patella_reflex :baz
+
+  def self.bing
+    3
+  end
+  patella_reflex :bing, :class_method => true
+
+  def no_background_add(a,b)
+    a + b
+  end
+  patella_reflex :no_background_add, :no_backgrounding => true
+end
+
+class PatellaTest < ActiveSupport::TestCase
+
+  def test_patella_basics
+    # foreground
+    f = Dummy.new 6
+    f.stubs :caching_foo => 5
+    assert_equal 5, f.foo
+    assert_received(f, :caching_foo)
+
+    #background
+    with_caching do
+      Patella::SendLaterWorker.stubs :perform_later => 'loading'
+      f1 = Dummy.new 5
+      assert f1.foo.loading?
+      assert_received(Patella::SendLaterWorker, :perform_later) do |ex|
+        ex.once
+        ex.with 'Dummy', f1.id, :caching_foo, []
+      end
+    end
+  end
+
+  def test_turning_off_background
+    #background
+    with_caching do
+      Patella::SendLaterWorker.expects(:perform_later).never
+      Dummy.any_instance.expects('caching_no_background_add').once.returns(9)
+      d = Dummy.new(1)
+      result = d.no_background_add(4,5)
+      assert result.loaded?
+      assert_equal 9, result
+    end
+  end
+
+  def cache_clearing
+    d = Dummy.new(1)
+    result = d.bar(4,5)  #load it by turning caching off
+    assert result.loaded?
+    assert_equal 9, result
+
+    with_caching do
+      result = d.bar(4,5)  #still here
+      assert result.loaded?
+      assert_equal 9, result
+
+      d.clear_bar(4,5)
+      result = d.bar(4,5)  #cleared
+      assert result.loading?
+
+    end
+  end
+
+  def test_patella_for_instance_objs
+    four = Dummy.new 4
+    assert_equal(8, four.baz(4))
+    assert_equal(13, four.baz(9))
+  end
+
+  def test_patella_for_class_methods
+    assert Dummy.bing.loaded?
+    assert_equal(3, Dummy.bing)
+  end
+
+  def test_keys
+    d = Dummy.new 2
+    assert_equal "patella/Dummy/2/foo/#{md5 [].to_json}", d.patella_key(:foo,[])
+    assert_equal "patella/Dummy/2/foo/#{md5 [1].to_json}", d.patella_key(:foo,[1])
+    assert_equal "patella/Dummy/2/foo/#{md5 [1,3].to_json}", d.patella_key(:foo,[1,3])
+    assert_equal "patella/Dummy/2/foo/#{md5 [1,"asdf"].to_json}", d.patella_key(:foo,[1,"asdf"])
+    assert_equal "patella/Dummy/2/foo/#{md5 [1,"asdf"*1000].to_json}", d.patella_key(:foo,[1, ("asdf"*1000)])
+
+    d3 = Dummy.new 3
+    assert_equal "patella/Dummy/3/foo/#{md5 [].to_json}", d3.patella_key(:foo,[])
+    assert_equal "patella/Dummy/3/foo/#{md5 [1].to_json}", d3.patella_key(:foo,[1])
+    assert_equal "patella/Dummy/3/foo/#{md5 [1,3].to_json}", d3.patella_key(:foo,[1,3])
+    assert_equal "patella/Dummy/3/foo/#{md5 [1,"asdf" * 1000].to_json}", d3.patella_key(:foo,[1,"asdf" * 1000])
+  end
+
+  def test_soft_expiration
+    dummy = Dummy.new 1
+    ::Rails.cache.stubs( :fetch => { 'result' => "loads of data", 'soft_expiration' => Time.now-1.minute }.to_json )
+    ::Rails.cache.stubs( :write => true )
+    dummy.stubs :send_later => 'loading'
+    dummy.foo
+    assert_received(Rails.cache, :write) { |ex| ex.once }
+    assert_received(dummy, :send_later) { |ex| ex.once }
+  end
+
+private
+  def md5(str)
+    Digest::MD5.hexdigest(str)
+  end
+
+  def with_caching(&block)
+    #previous_caching = ActionController::Base.perform_caching
+    begin
+      Rails.stubs(:caching? => true)
+      #ActionController::Base.perform_caching = true
+      yield
+    ensure
+      #ActionController::Base.perform_caching = previous_caching
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'bundler/setup'
+
+Bundler.require
+require 'patella'
+require 'test/unit'
+require 'active_support'
+require 'active_support/test_case'
+require 'json'
+require 'mocha'
+require 'bourne'
+
+unless defined?(Rails)
+module Rails
+  class MockCache
+    def fetch(*args)
+      yield
+    end
+    def write(*args)
+    end
+  end
+
+  def self.caching=(value)
+    @caching=value
+  end
+
+  def self.caching?
+    @caching
+  end
+  def self.cache
+    @cache ||= MockCache.new
+  end
+end
+end

metadata

@@ -0,0 +1,189 @@
+--- !ruby/object:Gem::Specification
+name: patella
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jeff Dwyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.8
+- !ruby/object:Gem::Dependency
+  name: bourne
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: It's Memoization into Memcached calculated in the background with Resque.
+email:
+- jdwyer@patientslikeme.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/patella.rb
+- lib/patella/patella.rb
+- lib/patella/send_later.rb
+- lib/patella/send_later_worker.rb
+- lib/patella/version.rb
+- patella.gemspec
+- test/patella_test.rb
+- test/test_helper.rb
+homepage: https://github.com/patientslikeme/patella
+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.24
+signing_key: 
+specification_version: 3
+summary: DSL to add memoization on any method into Memcached calculated in the background
+  with Resque.
+test_files:
+- test/patella_test.rb
+- test/test_helper.rb