memflash 1.0.0

data/.gitignore

@@ -0,0 +1,2 @@
+test/rails/log/*.log
+pkg

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 [name of plugin creator]
+
+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.markdown

@@ -0,0 +1,53 @@
+Memflash
+========
+
+Memflash is a gem which enables storing really long values in the Rails FlashHash
+without writing them to the session. Instead, it transparently uses `Rails.cache`, thus
+enabling the flash in your actions to contain large values, and still fit in a cookie-based
+session store.
+
+How do I use it?
+================
+
+Memflash is completely transparent -- requiring the gem automatically enhances FlashHash
+with caching-enabled reads and writes.
+
+By default, any message that is over 300 characters long, will be saved in Rails.cache,
+and a pointer to it stored in the flash. You can change this anywhere in your app by:
+
+    Memflash.threshold = #{length-at-which-writing-to-the-cache-is-trigerred}
+
+How does it work?
+=================
+
+Memflash ties into the [] and []= methods of Rails's FlashHash. On writes, if the value
+being written has a length over Memflash.threshold, Memflash generates a pseudo-random
+key for it, writes the pseudo-random key and original value to `Rails.cache`, and stores
+the original key and pseudo-random key in the flash. Conceptually, when you write
+`flash[:error] = "some message"`, this is equivalent to:
+
+    if "some message".length >=  Memflash.threshold
+      # generate a psedudo-random key, memflash_key
+      # write memflash_key, "some message" to Rails.cache
+      # write :error, memflash_key to the flash
+    else
+      # write :error, "some message" to the flash, as usual
+    end
+
+On the flip side, reading from the flash, `flash[:error]` is conceptually equivalent to:
+
+    if the value for :error stored in the flash is a memflash key
+      # read the original (large) value from Rails.cache
+      # return the original (large) value
+    else
+      # return the value stored in the flash, as usual
+    end
+
+Anything else?
+==============
+
+We'd love to hear from you!
+
+Authored by [Vladimir Andrijevik](mailto:vladimir@zendesk.com)
+
+Copyright (c) 2010 Zendesk, released under the MIT license

data/Rakefile

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "memflash"
+    gem.summary = "Memflash is a gem which enables storing really long values in the Rails FlashHash without writing them to the session"
+    gem.description = "Memflash is a gem which enables storing really long values in the Rails FlashHash without writing them to the session. Instead, it transparently uses `Rails.cache`, thus enabling the flash in your actions to contain large values, and still fit in a cookie-based session store"
+    gem.email = "vladimir@zendesk.com"
+    gem.homepage = "http://github.com/zendesk/memflash"
+    gem.authors = ["Vladimir Andrijevik"]
+    gem.version = "1.0.0"
+    gem.add_dependency "actionpack", "~> 2.3.5"
+    gem.add_development_dependency "rails", "~> 2.3.5"
+    gem.add_development_dependency "shoulda", "~> 2.11.0"
+    
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/lib/memflash.rb

@@ -0,0 +1,43 @@
+module Memflash
+  mattr_accessor :threshold
+  self.threshold = 300 # Messages longer than this will be stored in Rails.cache
+
+  def self.included(base)
+    base.class_eval do
+      include InstanceMethods
+      alias_method_chain :[]=, :caching
+      alias_method_chain :[], :caching
+    end
+  end
+
+  module InstanceMethods
+    define_method "[]_with_caching=" do |key, value|
+      value_for_hash = value
+
+      if value.kind_of?(String) && value.length >= Memflash.threshold
+        value_for_hash = memflash_key(key)
+        Rails.cache.write(value_for_hash, value)
+      end
+
+      send("[]_without_caching=", key, value_for_hash)
+    end
+
+    define_method "[]_with_caching" do |key|
+      value_in_hash = send("[]_without_caching", key)
+      memflashed?(key, value_in_hash) ? Rails.cache.read(value_in_hash) : value_in_hash
+    end
+
+    private
+      def memflash_key(hash_key)
+        "Memflash-#{hash_key}-#{Time.now.to_f}-#{Kernel.rand}"
+      end
+
+      def memflashed?(key, value)
+        !!(value =~ /^Memflash-#{key}/)
+      end
+  end # InstanceMethods
+end # Memflash
+
+require 'action_pack'
+require 'action_controller'
+ActionController::Flash::FlashHash.class_eval { include Memflash }

data/memflash.gemspec

@@ -0,0 +1,67 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{memflash}
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Vladimir Andrijevik"]
+  s.date = %q{2010-09-14}
+  s.description = %q{Memflash is a gem which enables storing really long values in the Rails FlashHash without writing them to the session. Instead, it transparently uses `Rails.cache`, thus enabling the flash in your actions to contain large values, and still fit in a cookie-based session store}
+  s.email = %q{vladimir@zendesk.com}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    ".gitignore",
+     "MIT-LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "lib/memflash.rb",
+     "memflash.gemspec",
+     "test/memflash_test.rb",
+     "test/rails/app/controllers/application.rb",
+     "test/rails/config/boot.rb",
+     "test/rails/config/environment.rb",
+     "test/rails/config/environments/test.rb",
+     "test/rails/config/routes.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/zendesk/memflash}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Memflash is a gem which enables storing really long values in the Rails FlashHash without writing them to the session}
+  s.test_files = [
+    "test/memflash_test.rb",
+     "test/rails/app/controllers/application.rb",
+     "test/rails/config/boot.rb",
+     "test/rails/config/environment.rb",
+     "test/rails/config/environments/test.rb",
+     "test/rails/config/routes.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<actionpack>, ["~> 2.3.5"])
+      s.add_development_dependency(%q<rails>, ["~> 2.3.5"])
+      s.add_development_dependency(%q<shoulda>, ["~> 2.11.0"])
+    else
+      s.add_dependency(%q<actionpack>, ["~> 2.3.5"])
+      s.add_dependency(%q<rails>, ["~> 2.3.5"])
+      s.add_dependency(%q<shoulda>, ["~> 2.11.0"])
+    end
+  else
+    s.add_dependency(%q<actionpack>, ["~> 2.3.5"])
+    s.add_dependency(%q<rails>, ["~> 2.3.5"])
+    s.add_dependency(%q<shoulda>, ["~> 2.11.0"])
+  end
+end
+

data/test/memflash_test.rb

@@ -0,0 +1,117 @@
+require "test_helper"
+
+class MemflashTest < Test::Unit::TestCase
+  class EnhancedHash < Hash
+    include Memflash
+  end
+  
+  def setup
+    @hash = EnhancedHash.new
+  end
+  
+  context "A memflash-enhanced Hash" do
+    should "have a caching-enabled []" do
+      assert @hash.respond_to?("[]_with_caching")
+    end
+    
+    should "have a caching-enabled []=" do
+      assert @hash.respond_to?("[]_with_caching=")
+    end
+  end # A memflash-enhanced Hash
+  
+  context "In a memflash-enhanced Hash, storing a value" do
+    context "that is a String" do
+      context "shorter than Memflash.threshold" do
+        should "not affect the cache" do
+          Rails.cache.expects(:write).never
+          
+          @hash[:hello] = "a" * (Memflash.threshold - 1)
+        end # not affect the cache
+      end # shorter than Memflash.threshold
+      
+      context "at least as long as Memflash.threshold" do
+        setup do
+          @key = "a-sample-key"
+          @value = "a" * (Memflash.threshold)
+        end
+        
+        should "call memflash_key with the key" do
+          @hash.expects(:memflash_key).with(@key)
+          
+          @hash[@key] = @value
+        end # call memflash_key with the key
+        
+        should "write the memflash_key and value to Rails.cache" do
+          # Stubbing out memflash_key is necessary so we can set a proper expectation below.
+          # Without it, the key generated when setting the expectation and the one during
+          # the actual write are different, so the assertion fails
+          @hash.stubs(:memflash_key).with(@key).returns("a-memflash-key")
+          
+          Rails.cache.expects(:write).with("a-memflash-key", @value)
+          
+          @hash[@key] = @value
+        end # write the memflash_key and value to Rails.cache
+        
+        should "store the memflash_key in place of the original value" do
+          # Stubbing out memflash_key is necessary so we can assert against the value
+          # in the hash below. Without it, we don't know the memflash key that is generated,
+          # so we cannot test whether it's in the hash or not.
+          @hash.stubs(:memflash_key).with(@key).returns("a-memflash-key")
+          @hash[@key] = @value
+          
+          assert_equal "a-memflash-key", @hash[@key]
+        end # store the memflash_key in place of the original value
+      end # at least as long as Memflash.threshold
+    end # that is a String
+    
+    context "that is not a String" do
+      should "not affect the cache" do
+        Rails.cache.expects(:write).never
+        
+        @hash[:time] = Time.now.to_i
+      end # not affect the cache
+    end # that is not a String
+  end # In a memflash-enhanced Hash, storing a value
+
+  context "From a memflash-enhanced Hash, reading by a key" do
+    should "check whether the value in the hash was memflashed" do
+      @hash[:hello] = "world"
+      
+      @hash.expects(:memflashed?).with(:hello, "world")
+      
+      @hash[:hello]
+    end
+    
+    context "whose value was memflashed" do
+      setup do
+        @hash.stubs(:memflashed?).returns(true)
+      end
+      
+      should "retrieve the original value from Rails.cache" do
+        key = "a-sample-memflashed-key"
+        @hash[key] = "key-to-look-up-in-rails-cache"
+        Rails.cache.expects(:read).with("key-to-look-up-in-rails-cache")
+        
+        @hash[key]
+      end # retrieve the original value from Rails.cache
+    end # whose value was memflashed
+    
+    context "whose value was not memflashed" do
+      setup do
+        @hash.stubs(:memflashed?).returns(false)
+      end
+      
+      should "not read from Rails.cache" do
+        Rails.cache.expects(:read).never
+        
+        @hash["a-non-memflashed-key"]
+      end # not read from Rails.cache
+    end # whose value was not memflashed
+  end # From a memflash-enhanced Hash, reading a value
+  
+  context "ActionController::Flash::FlashHash" do
+    should "be automatically cache-enhanced" do
+      assert ActionController::Flash::FlashHash.ancestors.include?(Memflash)
+    end
+  end # ActionController::Flash::FlashHash
+end

data/test/rails/config/boot.rb

@@ -0,0 +1,109 @@
+# Don't change this file!
+# Configure your app in config/environment.rb and config/environments/*.rb
+
+RAILS_ROOT = "#{File.dirname(__FILE__)}/.." unless defined?(RAILS_ROOT)
+
+module Rails
+  class << self
+    def boot!
+      unless booted?
+        preinitialize
+        pick_boot.run
+      end
+    end
+
+    def booted?
+      defined? Rails::Initializer
+    end
+
+    def pick_boot
+      (vendor_rails? ? VendorBoot : GemBoot).new
+    end
+
+    def vendor_rails?
+      File.exist?("#{RAILS_ROOT}/vendor/rails")
+    end
+
+    def preinitialize
+      load(preinitializer_path) if File.exist?(preinitializer_path)
+    end
+
+    def preinitializer_path
+      "#{RAILS_ROOT}/config/preinitializer.rb"
+    end
+  end
+
+  class Boot
+    def run
+      load_initializer
+      Rails::Initializer.run(:set_load_path)
+    end
+  end
+
+  class VendorBoot < Boot
+    def load_initializer
+      require "#{RAILS_ROOT}/vendor/rails/railties/lib/initializer"
+      Rails::Initializer.run(:install_gem_spec_stubs)
+    end
+  end
+
+  class GemBoot < Boot
+    def load_initializer
+      self.class.load_rubygems
+      load_rails_gem
+      require 'initializer'
+    end
+
+    def load_rails_gem
+      if version = self.class.gem_version
+        gem 'rails', version
+      else
+        gem 'rails'
+      end
+    rescue Gem::LoadError => load_error
+      $stderr.puts %(Missing the Rails #{version} gem. Please `gem install -v=#{version} rails`, update your RAILS_GEM_VERSION setting in config/environment.rb for the Rails version you do have installed, or comment out RAILS_GEM_VERSION to use the latest version installed.)
+      exit 1
+    end
+
+    class << self
+      def rubygems_version
+        Gem::RubyGemsVersion if defined? Gem::RubyGemsVersion
+      end
+
+      def gem_version
+        if defined? RAILS_GEM_VERSION
+          RAILS_GEM_VERSION
+        elsif ENV.include?('RAILS_GEM_VERSION')
+          ENV['RAILS_GEM_VERSION']
+        else
+          parse_gem_version(read_environment_rb)
+        end
+      end
+
+      def load_rubygems
+        require 'rubygems'
+
+        unless rubygems_version >= '0.9.4'
+          $stderr.puts %(Rails requires RubyGems >= 0.9.4 (you have #{rubygems_version}). Please `gem update --system` and try again.)
+          exit 1
+        end
+
+      rescue LoadError
+        $stderr.puts %(Rails requires RubyGems >= 0.9.4. Please install RubyGems and try again: http://rubygems.rubyforge.org)
+        exit 1
+      end
+
+      def parse_gem_version(text)
+        $1 if text =~ /^[^#]*RAILS_GEM_VERSION\s*=\s*["']([!~<>=]*\s*[\d.]+)["']/
+      end
+
+      private
+        def read_environment_rb
+          File.read("#{RAILS_ROOT}/config/environment.rb")
+        end
+    end
+  end
+end
+
+# All that for this:
+Rails.boot!

data/test/rails/config/environment.rb

@@ -0,0 +1,9 @@
+# Bootstrap the Rails environment, frameworks, and default configuration
+require File.join(File.dirname(__FILE__), 'boot')
+ 
+Rails::Initializer.run do |config|
+  config.frameworks -= [ :active_record ]
+  config.action_controller.session = { :key => "_memflash_session", :secret => "ac0dcc5b4d9eef497e671126a845c3c5" }
+  
+  config.gem 'shoulda', :lib => 'shoulda/rails'
+end

data/test/rails/config/environments/test.rb

@@ -0,0 +1,19 @@
+# Settings specified here will take precedence over those in config/environment.rb
+ 
+# The test environment is used exclusively to run your application's
+# test suite.  You never need to work with it otherwise.  Remember that
+# your test database is "scratch space" for the test suite and is wiped
+# and recreated between test runs.  Don't rely on the data there!
+config.cache_classes = true
+ 
+# Log error messages when you accidentally call methods on nil.
+config.whiny_nils = true
+ 
+# Show full error reports and disable caching
+config.action_controller.consider_all_requests_local = true
+config.action_controller.perform_caching             = false
+ 
+# Tell ActionMailer not to deliver emails to the real world.
+# The :test delivery method accumulates sent emails in the
+# ActionMailer::Base.deliveries array.
+config.action_mailer.delivery_method = :test

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.join(File.dirname(__FILE__), "rails", "config", "environment"))
+
+require 'rubygems'
+require 'active_support/test_case'
+require "memflash"

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification 
+name: memflash
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Vladimir Andrijevik
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-14 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: actionpack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 2
+        - 3
+        - 5
+        version: 2.3.5
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 2
+        - 3
+        - 5
+        version: 2.3.5
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 35
+        segments: 
+        - 2
+        - 11
+        - 0
+        version: 2.11.0
+  type: :development
+  version_requirements: *id003
+description: Memflash is a gem which enables storing really long values in the Rails FlashHash without writing them to the session. Instead, it transparently uses `Rails.cache`, thus enabling the flash in your actions to contain large values, and still fit in a cookie-based session store
+email: vladimir@zendesk.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- .gitignore
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- lib/memflash.rb
+- memflash.gemspec
+- test/memflash_test.rb
+- test/rails/app/controllers/application.rb
+- test/rails/config/boot.rb
+- test/rails/config/environment.rb
+- test/rails/config/environments/test.rb
+- test/rails/config/routes.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/zendesk/memflash
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Memflash is a gem which enables storing really long values in the Rails FlashHash without writing them to the session
+test_files: 
+- test/memflash_test.rb
+- test/rails/app/controllers/application.rb
+- test/rails/config/boot.rb
+- test/rails/config/environment.rb
+- test/rails/config/environments/test.rb
+- test/rails/config/routes.rb
+- test/test_helper.rb