net-http-not_modified_cache 0.0.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Einstein Industries
+
+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,12 @@
+= net-http-not_modified_cache - {<img src="https://secure.travis-ci.org/einstein/net-http-not_modified_cache.png" />}[http://travis-ci.org/einstein/net-http-not_modified_cache]
+
+Caches responses for requests that respond with "304 - Not Modified" and adds "if-modified-since" or "if-none-match" headers to future requests
+
+== Installation
+
+  gem install net-http-not_modified_cache
+
+
+== Usage
+
+Instructions

data/lib/net-http-not_modified_cache.rb

@@ -0,0 +1,127 @@
+require 'active_support/cache'
+require 'net/http'
+require 'rack/utils'
+require 'time'
+
+module Net
+  class HTTP
+    module NotModifiedCache
+      def cache_entry(response)
+        last_modified_at = Time.parse(response['last-modified'] || response['date']) rescue Time.now
+        Entry.new(response.body, response['etag'], last_modified_at)
+      end
+
+      def cache_key(request)
+        [address, request.path].join
+      end
+
+      def cache_request(request)
+        cache_request!(request) if cacheable_request?(request)
+      end
+
+      def cache_request!(request)
+        key = cache_key(request)
+        unless request['if-modified-since'] || request['if-none-match']
+          if entry = NotModifiedCache.store.read(key)
+            request['if-modified-since'] = entry.last_modified_at.httpdate
+            request['if-none-match'] = entry.etag
+          end
+        end
+        key
+      end
+
+      def cacheable_request?(request)
+        NotModifiedCache.enabled? && request.is_a?(Get)
+      end
+
+      def cache_response(response, key)
+        cache_response!(response, key) if cacheable_response?(response)
+      end
+
+      def cache_response!(response, key)
+        if response.code == '200'
+          NotModifiedCache.store.write(key, cache_entry(response))
+        elsif response.code == '304' && entry = NotModifiedCache.store.read(key)
+          response.instance_variable_set('@body', entry.body)
+        end
+      end
+
+      def cacheable_response?(response)
+        NotModifiedCache.enabled? && %w(200 304).include?(response.code)
+      end
+
+      def request_with_not_modified_cache(request, body = nil, &block)
+        key = cache_request(request)
+        response = request_without_not_modified_cache(request, body, &block)
+        cache_response(response, key) if key
+        response
+      end
+
+      class << self
+        attr_writer :root, :store
+
+        def disable!
+          @enabled = false
+        end
+
+        def enable!
+          @enabled = true
+        end
+
+        def enabled?
+          @enabled
+        end
+
+        def included(base)
+          base.class_eval do
+            alias_method :request_without_not_modified_cache, :request
+            alias_method :request, :request_with_not_modified_cache
+          end
+        end
+
+        def root
+          @root ||= '/tmp/net-http-not_modified_cache'
+        end
+
+        def store
+          @store ||= ActiveSupport::Cache.lookup_store(:file_store, root, :compress => true)
+        end
+
+        def version
+          @version ||= '0.0.0'
+        end
+
+        def while_disabled(&block)
+          while_enabled_is(false, &block)
+        end
+
+        def while_enabled(&block)
+          while_enabled_is(true, &block)
+        end
+
+        def while_enabled_is(boolean)
+          old_enabled = @enabled
+          @enabled = boolean
+          yield
+        ensure
+          @enabled = old_enabled
+        end
+
+        def with_store(store)
+          old_store = self.store
+          self.store = store
+          yield
+        ensure
+          self.store = old_store
+        end
+      end
+
+      enable!
+
+      class Entry < Struct.new(:body, :etag, :last_modified_at)
+      end
+    end
+  end
+end
+
+Net::HTTP.send(:include, Net::HTTP::NotModifiedCache)

data/spec/net-http-not_modified_cache_spec.rb

@@ -0,0 +1,253 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Net::HTTP::NotModifiedCache do
+  let(:nmc) { Net::HTTP::NotModifiedCache }
+
+  context 'when included in Net::HTTP' do
+    subject { Net::HTTP.new(url.host) }
+
+    let(:found) do
+      instance = response.dup
+      instance.instance_variable_set('@body', 'test')
+      instance.stub!(:code).and_return('200')
+      instance
+    end
+    let(:not_modified) do
+      instance = response.dup
+      instance.stub!(:code).and_return('304')
+      instance
+    end
+    let(:response) do
+      instance = Net::HTTPResponse.allocate
+      instance.instance_variable_set('@body', '')
+      instance.instance_variable_set('@header', {})
+      instance.instance_variable_set('@read', true)
+      instance
+    end
+
+    let(:get) { Net::HTTP::Get.allocate }
+    let(:post) { Net::HTTP::Post.allocate }
+    let(:request) { Net::HTTP::Get.new(url.path) }
+
+    let(:key) { subject.cache_key(get) }
+    let(:url) { URI.parse('http://fakeweb.test/index.html') }
+
+    context '#cache_entry' do
+      it 'should return an Entry instance' do
+        subject.cache_entry(found).should be_an_instance_of(nmc::Entry)
+      end
+
+      it 'should set body to the response body' do
+        subject.cache_entry(found).body.should == found.body
+      end
+
+      it 'should set etag header if it exists' do
+        subject.cache_entry(found).etag.should be_nil
+
+        found['etag'] = 'test'
+        subject.cache_entry(found).etag.should == 'test'
+      end
+
+      it 'should set last_modified_at to last-modified header if it exists' do
+        time = Time.now - 100
+        found['last-modified'] = time.httpdate
+        found['date'] = (time - 100).httpdate
+        subject.cache_entry(found).last_modified_at.httpdate.should == time.httpdate
+      end
+
+      it 'should set last_modified_at to date header if it exists and last-modified header is not specified' do
+        time = Time.now - 200
+        found['date'] = time.httpdate
+        subject.cache_entry(found).last_modified_at.httpdate.should == time.httpdate
+      end
+
+      it 'should set last_modified_at to Time.now if both last-modified and date headers are not specified' do
+        Timecop.freeze(Time.now - 500) { subject.cache_entry(found).last_modified_at.httpdate.should == Time.now.httpdate }
+      end
+    end
+
+    context '#cache_key' do
+      it 'should join the address and request path' do
+        subject.cache_key(request).should == [subject.address, request.path].join
+      end
+    end
+
+    context '#cache_request' do
+      it 'should only call #cache_request! if request is cacheable' do
+        subject.should_receive(:cache_request!)
+        subject.cache_request(get)
+
+        subject.should_not_receive(:cache_request!)
+        subject.cache_request(post)
+      end
+    end
+
+    context '#cache_request!' do
+      it 'should not add if-modified-since or if-none-match header if either already exists' do
+        nmc.store.should_not_receive(:read)
+
+        request['if-none-match'] = 'etag'
+        subject.cache_request!(request)
+
+        request['if-none-match'] = nil
+        request['if-modified-since'] = Time.now.httpdate
+        subject.cache_request!(request)
+      end
+
+      it 'should search for cached entry' do
+        nmc.store.should_receive(:read)
+        subject.cache_request!(request)
+      end
+
+      it 'should set etag and if-modified-since headers' do
+        entry = nmc::Entry.new('testing', 'test', Time.now)
+        nmc.store.should_receive(:read).with(subject.cache_key(request)).and_return(entry)
+        subject.cache_request!(request)
+
+        request['if-none-match'].should == entry.etag
+        request['if-modified-since'].should == entry.last_modified_at.httpdate
+      end
+    end
+
+    context '#cacheable_request?' do
+      it 'should only return true if enabled' do
+        nmc.disable!
+        subject.cacheable_request?(get).should be_false
+        nmc.enable!
+        subject.cacheable_request?(get).should be_true
+      end
+
+      it 'should only return true if request is a Net::HTTP::Get' do
+        subject.cacheable_request?(get).should be_true
+        subject.cacheable_request?(post).should be_false
+      end
+    end
+
+    context '#cache_response' do
+      it 'should only be called if request is cacheable' do
+        subject.stub(:request_without_not_modified_cache)
+        subject.should_not_receive(:cache_response)
+        subject.request(post)
+      end
+
+      it 'should only call #cache_response! if response is cacheable' do
+        subject.should_receive(:cache_response!)
+        subject.cache_response(found, 'test')
+
+        subject.should_not_receive(:cache_response!)
+        subject.cache_response(response, 'test')
+      end
+    end
+
+    context '#cache_response!' do
+      it 'should cache entry if response is a 200' do
+        nmc.store.should_receive(:write)
+        subject.cache_response!(found, key)
+      end
+
+      it 'should set cached body if response is a 304' do
+        entry = nmc::Entry.new('testing', nil, Time.now)
+        nmc.store.should_receive(:read).with(key).and_return(entry)
+        subject.cache_response!(not_modified, key)
+        not_modified.body.should == entry.body
+      end
+    end
+
+    context '#cacheable_response?' do
+      it 'should only return true if enabled' do
+        nmc.disable!
+        subject.cacheable_response?(found).should be_false
+        nmc.enable!
+        subject.cacheable_response?(found).should be_true
+      end
+
+      it 'should only return true if response code is a 200 or 304' do
+        subject.cacheable_response?(response).should be_false
+        subject.cacheable_response?(found).should be_true
+        subject.cacheable_response?(not_modified).should be_true
+      end
+    end
+
+    context '#request_with_not_modified_cache' do
+      it 'should run fakeweb tests'
+    end
+  end
+
+  context '.enabled?' do
+    it 'should be toggleable and true by default' do
+      subject.enabled?.should be_true
+      subject.disable!
+      subject.enabled?.should be_false
+      subject.enable!
+      subject.enabled?.should be_true
+    end
+  end
+
+  context '.root' do
+    it 'should be /tmp/net-http-not_modified_cache by default' do
+      subject.root.should == '/tmp/net-http-not_modified_cache'
+    end
+  end
+
+  context '.store' do
+    it 'should be an ActiveSupport::Cache::FileStore by default' do
+      subject.store.should be_an_instance_of(ActiveSupport::Cache::FileStore)
+    end
+
+    it 'should use root as cache root' do
+      subject.store.cache_path.should == subject.root
+    end
+  end
+
+  context '.version' do
+    it 'should return a version string' do
+      subject.version.should match(/^\d+\.\d+\.\d+(\.[^\.]+)?$/)
+    end
+  end
+
+  context '.while_disabled' do
+    it 'should set enabled? to false for the duration of the block' do
+      subject.while_disabled { subject.enabled?.should be_false }
+      subject.enabled?.should be_true
+    end
+  end
+
+  context '.while_enabled' do
+    it 'should set enabled? to true for the duration of the block' do
+      subject.disable!
+      subject.while_enabled { subject.enabled?.should be_true }
+      subject.enabled?.should be_false
+    end
+  end
+
+  context '.while_enabled_is' do
+    it 'should set enabled? and return it back to its previous value after evaluating the block' do
+      subject.while_enabled_is(false) { subject.enabled?.should be_false }
+      subject.enabled?.should be_true
+
+      subject.disable!
+      subject.while_enabled_is(true) { subject.enabled?.should be_true }
+      subject.enabled?.should be_false
+    end
+  end
+
+  context '.with_store' do
+    let(:store) { ActiveSupport::Cache.lookup_store(:file_store, '/tmp/test') }
+
+    it 'should switch lookup store when yielding' do
+      current_store = subject.store
+      subject.with_store(store) { subject.store.should_not == current_store }
+      subject.store.should == current_store
+    end
+  end
+
+  context '::Entry' do
+    subject { nmc::Entry.new }
+
+    it 'should respond to :body, :etag, and :last_modified_at' do
+      subject.should respond_to(:body)
+      subject.should respond_to(:etag)
+      subject.should respond_to(:last_modified_at)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'bundler/setup'
+
+# [TODO] why do specs fail without this?
+# [TODO] why doesn't "gem 'timecop', :require => 'timecop/timecop'" work?
+require 'timecop/timecop'
+
+spec_root = File.dirname(__FILE__)
+$:.unshift(File.join(spec_root, '..', 'lib'))
+$:.unshift(spec_root)
+require 'net-http-not_modified_cache'
+
+RSpec.configure do |config|
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+
+  config.before { Net::HTTP::NotModifiedCache.enable! }
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: net-http-not_modified_cache
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Sean Huber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-17 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70308578689380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70308578689380
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: &70308578688740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70308578688740
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &70308578688120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70308578688120
+description: Caches responses for requests that respond with "304 - Not Modified"
+  and adds "if-modified-since" or "if-none-match" headers to future requests
+email: shuber@einsteinindustries.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/net-http-not_modified_cache.rb
+- MIT-LICENSE
+- README.rdoc
+- spec/net-http-not_modified_cache_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/einstein/net-http-not_modified_cache
+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.10
+signing_key: 
+specification_version: 3
+summary: Caches responses for requests that respond with "304 - Not Modified"
+test_files:
+- spec/net-http-not_modified_cache_spec.rb
+- spec/spec_helper.rb