dry_ice 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store
+vendor/

data/Gemfile

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+
+gemspec
+
+group :test do
+  gem 'guard'
+  gem 'rspec'
+  gem 'guard-rspec'
+  gem 'activesupport'
+  gem 'webmock'
+  gem 'msgpack'
+end

data/History

@@ -0,0 +1,16 @@
+== 0.0.4 2012-01-03
+* minor enhancements
+  * Update gemspec to depend on HTTParty 0.8.X to fix YAML issues.
+
+== 0.0.3
+* minor enhancements
+  * Remove the output from setting a cache.
+
+== 0.0.2
+* minor enhancements
+  * Return a cached result if network fails. [Andreas Garnæs]
+
+== 0.0.1 
+
+* major enhancements
+  * Initial release.

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2013 Daniel Cooper
+Copyright (c) 2011 Kristoffer Sachse
+
+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,61 @@
+# DryIce - Caching for HTTParty
+
+## Description
+
+Cache responses in HTTParty models. Every response from a resource which has a non 0 max-age header will be cached for the appropriate amount of time in the cache you provide it.
+
+Based off https://github.com/sachse/httparty-icebox
+
+## Installation
+
+### RubyGems
+
+You can install the latest Film Buff gem using RubyGems
+
+    gem install dry_ice
+
+### GitHub
+
+Alternatively you can check out the latest code directly from Github
+
+    git clone http://github.com/homeflow/dry_ice.git
+
+## Usage
+
+Any class which includes the `HTTParty` module can include `HTTParty::DryIce` and get access to a cache class method.
+    
+    class AnAPI
+
+      include HTTParty
+      include HTTParty::DryIce
+      base_uri 'example.com'
+      
+      cache Rails.cache
+
+    end
+
+The `cache` method accepts any instance which quacks like a [ActiveSupport cache](http://api.rubyonrails.org/classes/ActiveSupport/Cache/MemoryStore.html). That means you can use the built in Rails caches, something like [Redis Store](https://github.com/jodosha/redis-store) or your own custom rolled class as long as it responds to the methods: 
+
+   - read
+   - write (taking an option :expires_in => seconds)
+   - exit?
+   - delete
+
+
+## Contribute
+
+Fork the project, implement your changes in it's own branch, and send
+a pull request to me. I'll gladly consider any help or ideas.
+
+### Contributors
+
+- [Daniel Cooper](http://github.com/danielcooper) - For homeflow.co.uk
+
+This project was based off the excellent httparty-icebox gem: https://github.com/sachse/httparty-icebox. It's contributors are listed below.
+
+- [Karel Minarik](http://karmi.cz) (Original creator through [a gist](https://gist.github.com/209521/))
+- [Martyn Loughran](https://github.com/mloughran) - Major parts of this code are based on the architecture of ApiCache.
+- [David Heinemeier Hansson](https://github.com/dhh) - Other parts are inspired by the ActiveSupport::Cache in Ruby On Rails.
+- [Amit Chakradeo](https://github.com/amit) - For pointing out response objects have to be stored marshalled on FS.
+- Marlin Forbes - For pointing out the query parameters have to be included in the cache key.
+- [ramieblatt](https://github.com/ramieblatt) - Original Memcached store.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/dry_ice.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dry_ice/version"
+
+Gem::Specification.new do |s|
+  s.name        = "dry_ice"
+  s.version     = Httparty::DryIce::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Daniel Cooper"]
+  s.email       = ["daniel@14lines.com"]
+  s.homepage    = "https://github.com/homeflow/dry_ice"
+  s.summary     = %q{Caching for HTTParty}
+  s.description = %q{Cache responses in HTTParty models}
+
+  s.add_dependency("httparty", "~> 0.9.0")
+  s.add_dependency("msgpack")
+
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+end

data/lib/dry_ice/version.rb

@@ -0,0 +1,5 @@
+module Httparty
+  module DryIce
+    VERSION = "0.0.1"
+  end
+end

data/lib/dry_ice.rb

@@ -0,0 +1,149 @@
+require 'logger'
+require 'fileutils'
+require 'tmpdir'
+require 'pathname'
+require 'digest/md5'
+
+module HTTParty #:nodoc:
+  # == Caching for HTTParty
+  # See documentation in HTTParty::Icebox::ClassMethods.cache
+  #
+  module DryIce
+
+    module ClassMethods
+
+      # Enable caching and set cache options
+      # Returns memoized cache object
+      #
+      # Following options are available, default values are in []:
+      #
+      # +store+::       Storage mechanism for cached data (memory, filesystem, your own) [memory]
+      # +timeout+::     Cache expiration in seconds [60]
+      # +logger+::      Path to logfile or logger instance [nil, silent]
+      #
+      # Any additional options are passed to the Cache constructor
+      #
+      # Usage:
+      #
+      #   # Enable caching in HTTParty, in memory, for 1 minute
+      #   cache # Use default values
+      #
+      #   # Enable caching in HTTParty, on filesystem (/tmp), for 10 minutes
+      #   cache :store => 'file', :timeout => 600, :location => '/tmp/'
+      #
+      #   # Use your own cache store (see +AbstractStore+ class below)
+      #   cache :store => 'memcached', :timeout => 600, :server => '192.168.1.1:1001'
+      #
+      def cache(cache)
+        return @cache = nil unless cache
+        raise "cache instance must respond_to #read, #write and #delete" unless cache.respond_to?(:read) && cache.respond_to?(:write) && cache.respond_to?(:delete)
+        @cache = IceCache.new(cache)
+      end
+
+      def get_cache
+        @cache || false
+      end
+
+    end
+
+    # When included, extend class with +cache+ method
+    # and redefine +get+ method to use cache
+    #
+    def self.included(receiver) #:nodoc:
+      receiver.extend ClassMethods
+      receiver.class_eval do
+
+        # Get reponse from network
+        #
+        # TODO: Why alias :new :old is not working here? Returns NoMethodError
+        #
+        def self.get_without_caching(path, options={})
+          perform_request Net::HTTP::Get, path, options
+        end
+
+        # Get response from cache, if available
+        #
+        def self.get_with_caching(path, options={})
+          return get_without_caching(path, options) unless get_cache
+          key = path.downcase # this makes a copy of path
+          key << options[:query].to_s if defined? options[:query]
+          if res = get_cache.read(key) 
+            return res
+          else
+            response =  get_without_caching(path, options)
+            if cache_for = self.cache_response?(response)
+              get_cache.write(key,response, :expires_in => cache_for)
+              return response
+            else
+              return response
+            end
+          end
+        end
+
+        #returns falsy if the response should not be cached - otherwise returns the timeout in seconds to cache for
+        def self.cache_response?(response)
+           return false if !response.body
+           return false unless response.code.to_s == "200"
+           timeout = response.headers['cache-control'] && response.headers['cache-control'][/max-age=(\d+)/, 1].to_i()
+           return false unless timeout && timeout != 0
+           return timeout
+        end
+
+        # Redefine original HTTParty +get+ method to use cache
+        #
+        def self.get(path, options={})
+          self.get_with_caching(path, options)
+        end
+
+      end
+    end
+
+    class IceCache
+
+      require 'msgpack'
+
+      def initialize(cache)
+        @cache = cache
+      end
+
+      def write(name, value, options = {})
+        @cache.write(name, serialize_response(value), options)
+      end
+
+
+      def serialize_response(response)
+        headers = response.headers.dup
+        body = response.body.dup
+        [headers,body].to_msgpack 
+      end
+
+      def build_response(serialized_response)
+        res = MessagePack.unpack(serialized_response)
+        CachedHTTPartyResponse.new(res[0], res[1])
+      end
+
+      def read(*args)
+        found = @cache.read(*args)
+        build_response(found) if found
+      end
+
+      def exist?(*args)
+        @cache.exist?(*args)
+      end
+
+
+    end
+
+    class CachedHTTPartyResponse
+
+      attr_accessor :headers, :body
+
+      def initialize(headers, body)
+        @headers, @body = headers, body
+      end
+
+    end
+
+  end
+end
+

data/spec/dry_ice_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper.rb'
+require 'active_support'
+
+
+describe HTTParty::DryIce do
+
+  context "when being set up" do
+
+    it "accepts a cache instance that quacks like a ActiveSupport cache" do
+
+      expect do
+          class MockApi
+            cache(Object.new)
+          end
+      end.to raise_error 
+
+      expect do
+          class MockApi
+            cache(ActiveSupport::Cache::NullStore.new)
+          end
+      end.not_to raise_error
+
+    end
+  end
+
+
+  context "when performing a request" do
+
+
+    it "should not use read to check existance" do
+
+      class MockApi
+        cache(ActiveSupport::Cache::NullStore.new)
+      end
+
+       ActiveSupport::Cache::NullStore.any_instance.should_receive(:read)
+
+       stub_request(:get, "http://example.com/").to_return(:status => 200, :body => "test", :headers => {})     
+      
+       MockApi.get('/')
+
+    end
+ 
+     
+    it "does not cache requests without a cache header" do
+
+      class MockApi
+        cache(nil)
+      end
+
+      stub_request(:get, "http://example.com/").to_return(:status => 200, :body => "test", :headers => {:cache_control => 'max-age=10'})     
+      
+      response = MockApi.get('/')
+
+      expect(MockApi.cache_response?(response)).to be 10
+      
+    end
+
+    
+
+  end
+end
+
+
+describe HTTParty::DryIce::IceCache do
+
+
+  it "should be able to marshel and store a HTTParty request" do
+    stub_request(:get, "http://example.com/").to_return(:status => 200, :body => "hello world", :headers => {:cache_control => 'max-age=0'})     
+    response = MockApi.get('/')
+    cache = HTTParty::DryIce::IceCache.new(ActiveSupport::Cache::NullStore.new)
+
+    serialised = cache.serialize_response(response)
+    res = cache.build_response(serialised)
+
+    res.body.should == response.body
+    res.headers.should == response.headers
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/../lib/dry_ice.rb'
+require 'rspec'
+require 'httparty'
+require 'json'
+require 'webmock/rspec'
+
+class MockApi
+
+  include HTTParty
+  include HTTParty::DryIce
+  base_uri 'example.com'
+
+
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: dry_ice
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Daniel Cooper
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: msgpack
+  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'
+description: Cache responses in HTTParty models
+email:
+- daniel@14lines.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- History
+- LICENSE
+- README.md
+- Rakefile
+- dry_ice.gemspec
+- lib/dry_ice.rb
+- lib/dry_ice/version.rb
+- spec/dry_ice_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/homeflow/dry_ice
+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: Caching for HTTParty
+test_files: []