sparkle 0.1.1

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source :gemcutter
+
+# Specify your gem's dependencies in sparkle.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,21 @@
+PATH
+  remote: .
+  specs:
+    sparkle (0.1.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (2.3.11)
+    flexmock (0.8.11)
+    rake (0.8.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (= 2.3.11)
+  bundler (>= 1.0.0)
+  flexmock (= 0.8.11)
+  rake (= 0.8.7)
+  sparkle!

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2011 Evan Petrie
+
+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.rdoc

@@ -0,0 +1,86 @@
+= Sparkle
+
+* http://github.com/kuinak/sparkle
+
+== Description
+
+Cache partials and update them asynchronously after a page renders. Slow
+method calls happen synchronously as the page renders for the first time.
+Subsequent page loads retrieve cached objects and render the page quickly, and
+then Ajax calls can be used to refresh components asynchronously after the
+page loads.
+
+== Usage
+
+Add sparkle to your Gemfile (or whatever if you're not using bundler):
+
+  gem "sparkle"
+
+Include the refreshable module into a class that performs a slow action and
+tell it what method to execute when refreshing:
+
+    class FacebookFeed
+      include Sparkle::Refreshable
+      sparkle_refresh_method :retrieve_feed
+
+      def initialize(access_token)
+        @access_token = access_token
+      end
+
+      def retrieve_feed
+        # go do something slow
+      end
+    end
+
+Get refreshable objects using the fetch method in your controller or helper
+methods. Any cache misses will pass the parameters passed to the initializer
+method of the class:
+
+    @facebook_feed = FacebookFeed.sparkle_fetch("some_access_token")
+
+Change calls from render to render_sparkle for partials you want to be
+refreshed. Note that you cannot use instance variables in any of the
+refreshable partials, all variables used must be passed as locals:
+
+    render_sparkle(:partial => "users/facebook_feed", :locals => { :facebook_feed => @facebook_feed })
+
+When the template is rendered, it will attempt to use a cached version of any
+objects that include Sparkle::Refreshable. If a cached copy of any local
+variable is found, a cache key variable called "sparkle_cache_key" will be
+set. You can use this variable to reference elements of the DOM that should be
+refreshed (below example in Haml):
+
+    - html_options = sparkle_cache_key ? {:id => sparkle_cache_key, :class => "refreshable"} : {}
+    %div { html_options }
+      - facebook_feed.each do |item|
+        ...
+
+Add some javascripts to bind the refresh action to DOM elements that need to
+be refreshed:
+
+    $(document).ready(function(){
+      $(".refreshable").each(function(index, e) {
+        var id = $(e).attr("id");
+        $.ajax({
+          url: "/sparkle/fetch/" + id,
+          success: function(html) {
+            $(e).replaceWith(html);
+          }
+        });
+      });
+    });
+
+Include the controller module into an existing controller in your application:
+
+    class ApplicationController < ActionController::Base
+      include Sparkle::Controller
+      ...
+
+Add a route to config/routes.rb to the fetch action in the controller you
+included the Sparkle::Controller module in:
+
+    map.connect "/sparkle/fetch/:key", :controller => "application", :action => "fetch"
+
+== License
+
+The MIT License, see LICENSE

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+require 'rake'
+require 'rake/testtask'
+
+Bundler::GemHelper.install_tasks
+
+Rake::TestTask.new("test") { |t|
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+  t.warning = true
+}

data/lib/sparkle.rb

@@ -0,0 +1,9 @@
+module Sparkle
+
+  require "sparkle/refreshable"
+  require "sparkle/helper"
+  require "sparkle/controller"
+
+  ActionView::Base.send(:include, Sparkle::Helper)
+
+end

data/lib/sparkle/controller.rb

@@ -0,0 +1,18 @@
+module Sparkle
+  module Controller
+
+    def fetch
+      cache_entry = Rails.cache.read(params[:key])
+      partial = cache_entry[:partial]
+      locals = cache_entry[:locals]
+      begin
+        locals.values.each { |value| value._sparkle_refresh! if value.class.include?(Refreshable) }
+      rescue Exception => e
+        session[:sparkle_exception] = e
+      end
+      render :partial => partial, :locals => locals.merge(:sparkle_cache_key => nil)
+      raise session.delete(:sparkle_exception) if session[:sparkle_exception]
+    end
+
+  end
+end

data/lib/sparkle/helper.rb

@@ -0,0 +1,17 @@
+module Sparkle
+  module Helper
+
+    def render_sparkle options
+      key = rand(2**128).to_s(36)
+      Rails.cache.write(key, options)
+      if options[:locals].values.any? { |value| value._sparkle_cached_ if value.class.include?(Refreshable) }
+        options[:locals][:sparkle_cache_key] = key
+      else
+        options[:locals][:sparkle_cache_key] = nil
+      end
+      render options
+    end
+
+  end
+end
+

data/lib/sparkle/refreshable.rb

@@ -0,0 +1,51 @@
+module Sparkle
+  module Refreshable
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_eval do
+        class_inheritable_accessor :_sparkle_cache_refresh_method
+        attr_accessor :_sparkle_cached_
+        attr_accessor :_sparkle_cache_key_
+      end
+    end
+
+    def _sparkle_refresh!
+      self.send self.class._sparkle_cache_refresh_method
+      Rails.cache.write(self._sparkle_cache_key_, self)
+    end
+
+    module ClassMethods
+
+      def sparkle_refresh_method method_name
+        self._sparkle_cache_refresh_method = method_name.to_sym
+      end
+
+      def sparkle_fetch(*args)
+        key = _sparkle_cache_key(*args)
+        if object = Rails.cache.read(key)
+          begin
+            object._sparkle_cached_ = true
+          rescue TypeError => e
+            object = object.dup
+            object._sparkle_cached_ = true
+          end
+        else
+          object = new(*args)
+          object.send object.class._sparkle_cache_refresh_method
+          object._sparkle_cached_ = false
+          object._sparkle_cache_key_ = key
+          Rails.cache.write(key, object)
+        end
+        object
+      end
+
+      private
+
+      def _sparkle_cache_key(*args)
+        Digest::SHA1.hexdigest("#{name}:#{args.join('|')}")
+      end
+
+    end
+  end
+end

data/lib/sparkle/version.rb

@@ -0,0 +1,3 @@
+module Sparkle
+  VERSION = "0.1.1"
+end

data/sparkle.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/sparkle/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "sparkle"
+  s.version     = Sparkle::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Evan Petrie"]
+  s.email       = ["ejp@yahoo.com"]
+  s.homepage    = "http://rubygems.org/gems/sparkle"
+  s.summary     = "Asyncronous partial caching"
+  s.description = "Cache partials and update them asynchronously after a page renders. Slow method calls happen synchronously as the page renders for the first time. Subsequent page loads retrieve cached objects and render the page quickly, and then Ajax calls can be used to refresh components asynchronously after the page loads."
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "sparkle"
+
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "rake", "0.8.7"
+  s.add_development_dependency "flexmock", "0.8.11"
+  s.add_development_dependency "activesupport", "2.3.11"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+end

data/test/controller_test.rb

@@ -0,0 +1,40 @@
+require "test/unit"
+require "flexmock/test_unit"
+require "sparkle/controller"
+require "test/test_helper"
+
+class TestController < Test::Unit::TestCase
+
+  include Sparkle::Controller
+
+  def params
+    @params ||= {}
+  end
+
+  def session
+    @session ||= {}
+  end
+
+  def test_fetch
+    local = RefreshMe.new
+    flexmock(local).should_receive(:_sparkle_refresh!).once
+    Rails.cache.write(:foo, {:partial => "partial", :locals => {:local => local}})
+    params[:key] = :foo
+    flexmock(self).should_receive(:render).with(:partial => "partial", :locals => {:sparkle_cache_key => nil, :local => local}).once
+    fetch
+    assert_nil session[:sparkle_exception]
+  end
+
+  def test_fetch_with_exception
+    local = RefreshMe.new
+    flexmock(local).should_receive(:_sparkle_refresh!).once.and_raise(RuntimeError.new)
+    Rails.cache.write(:foo, {:partial => "partial", :locals => {:local => local}})
+    params[:key] = :foo
+    flexmock(self).should_receive(:render).with(:partial => "partial", :locals => {:sparkle_cache_key => nil, :local => local}).once
+    assert_raise RuntimeError do
+      fetch
+    end
+    assert_nil session[:sparkle_exception]
+  end
+
+end

data/test/helper_test.rb

@@ -0,0 +1,25 @@
+require "test/unit"
+require "flexmock/test_unit"
+require "sparkle/helper"
+require "test/test_helper"
+
+class TestHelper < Test::Unit::TestCase
+
+  include Sparkle::Helper
+
+  def rand(limit); 1; end
+
+  def test_render_sparkle
+    local = RefreshMe.new
+    flexmock(self).should_receive(:render).with(:locals => {:local => local, :sparkle_cache_key => nil}).once
+    render_sparkle(:locals => {:local => local})
+  end
+
+  def test_render_sparkle_with_cached_local
+    local = RefreshMe.new
+    flexmock(local).should_receive(:_sparkle_cached_).and_return(true).once
+    flexmock(self).should_receive(:render).with(:locals => {:local => local, :sparkle_cache_key => "1"}).once
+    render_sparkle(:locals => {:local => local})
+  end
+
+end

data/test/refreshable_test.rb

@@ -0,0 +1,31 @@
+require "test/unit"
+require "flexmock/test_unit"
+require "sparkle/helper"
+require "test/test_helper"
+
+class RefreshableTest < Test::Unit::TestCase
+
+  def setup
+    Rails.cache.clear
+  end
+
+  def test_sparkle_refresh
+    flexmock(RefreshMe).should_receive(:_sparkle_cache_key).and_return("cache_key")
+    refreshable = RefreshMe.sparkle_fetch
+    flexmock(refreshable).should_receive(:slow_method).once
+    refreshable._sparkle_refresh!
+    assert_equal refreshable, Rails.cache.read("cache_key")
+  end
+
+  def test_sparkle_fetch
+    flexmock(RefreshMe).should_receive(:_sparkle_cache_key).and_return("cache_key")
+    assert_nil Rails.cache.read("cache_key")
+    refreshable = RefreshMe.sparkle_fetch
+    assert_equal refreshable, Rails.cache.read("cache_key")
+    assert_equal false, refreshable._sparkle_cached_
+    refreshable = RefreshMe.sparkle_fetch
+    assert_equal refreshable, Rails.cache.read("cache_key")
+    assert_equal true, refreshable._sparkle_cached_
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,40 @@
+require "sparkle/refreshable"
+require "active_support"
+
+class Rails
+
+  class Cache
+
+    def read(key)
+      @cache ||= {}
+      @cache[key]
+    end
+
+    def write(key, value)
+      @cache ||= {}
+      @cache[key] = value
+    end
+
+    def clear
+      @cache = {}
+    end
+
+  end
+
+  def self.cache
+    @cache ||= Cache.new
+  end
+
+end
+
+class RefreshMe
+
+  include ClassInheritableAttributes
+  include Sparkle::Refreshable
+
+  sparkle_refresh_method :slow_method
+
+  def slow_method
+  end
+
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification 
+name: sparkle
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Evan Petrie
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-23 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 8
+        - 7
+        version: 0.8.7
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: flexmock
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 8
+        - 11
+        version: 0.8.11
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 3
+        - 11
+        version: 2.3.11
+  type: :development
+  version_requirements: *id004
+description: Cache partials and update them asynchronously after a page renders. Slow method calls happen synchronously as the page renders for the first time. Subsequent page loads retrieve cached objects and render the page quickly, and then Ajax calls can be used to refresh components asynchronously after the page loads.
+email: 
+- ejp@yahoo.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.rdoc
+- Rakefile
+- lib/sparkle.rb
+- lib/sparkle/controller.rb
+- lib/sparkle/helper.rb
+- lib/sparkle/refreshable.rb
+- lib/sparkle/version.rb
+- sparkle.gemspec
+- test/controller_test.rb
+- test/helper_test.rb
+- test/refreshable_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/sparkle
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: sparkle
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Asyncronous partial caching
+test_files: []
+