web 0.0.1

data/lib/web.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/web/ext/net_http'
+require File.dirname(__FILE__) + '/web/faker'
+
+module Web
+
+  # The adapters
+  autoload :RedisCache, File.dirname(__FILE__) + '/web/cache/redis_cache'
+  autoload :MemcachedCache, File.dirname(__FILE__) + '/web/cache/memcached_cache'
+  autoload :MemoryCache, File.dirname(__FILE__) + '/web/cache/memory_cache'
+
+  class << self
+
+    attr_writer :cache
+
+    # register a url to cache
+    def register(regex, options = {})
+      options[:regex] = regex
+      registered << options
+    end
+
+    # an array of registrations
+    def registered
+      @registered ||= []
+    end
+
+    # Get the cache we're using
+    def cache
+      @cache ||= RedisCache.new
+    end
+
+  end
+
+end

data/lib/web/cache/memcached_cache.rb

@@ -0,0 +1,23 @@
+require 'dalli'
+
+module Web
+
+  # a basic cache interface, implemented with memcached
+
+  class MemcachedCache
+  
+    def initialize(client = nil)
+      @client = client || Dalli::Client.new
+    end
+
+    def get(key)
+      @client.get(key)
+    end
+
+    def set(key, value, expires = nil)
+      expires ? @client.set(key, value, expires) : @client.set(key, value)
+    end
+
+  end
+
+end

data/lib/web/cache/memory_cache.rb

@@ -0,0 +1,20 @@
+module Web
+
+  class MemoryCache
+
+    def initialize
+      @hash = {}
+    end
+
+    def get(key)
+      @hash[key]
+    end
+
+    def set(key, value, expires = nil)
+      raise 'MemoryCache does not support key expiration' if expires
+      @hash[key] = value
+    end
+
+  end
+
+end

data/lib/web/cache/redis_cache.rb

@@ -0,0 +1,24 @@
+require 'redis'
+
+module Web
+
+  # A basic cache interface, implemented with Redis
+
+  class RedisCache
+
+    def initialize(client = nil)
+      @redis = client || Redis.new
+    end
+
+    def get(key)
+      @redis.get key
+    end
+
+    def set(key, value, expires = nil)
+      @redis.set key, value
+      @redis.expire key, expires if expires
+    end
+
+  end
+
+end

data/lib/web/ext/net_http.rb

@@ -0,0 +1,113 @@
+require 'net/http'
+require 'net/https'
+require 'stringio'
+
+require File.dirname(__FILE__) + '/../status_codes'
+require File.dirname(__FILE__) + '/../http_response'
+
+module Net
+
+  class BufferedIO
+
+    # Catch the socket
+    # This method was largely influenced by FakeWeb
+    def initialize_with_web(io, debug_output = nil)
+      @read_timeout = 60
+      @rbuf = ''
+      @debug_output = debug_output
+      # If io is a socket, use it directly
+      # If io is a string that represents a file path, open the file
+      # Otherwise, open a StringIO so we can stream
+      @io = case io
+      when Socket, OpenSSL::SSL::SSLSocket, IO
+        io
+      when String
+        if !io.include?("\0") && File.exists?(io) && !File.directory?(io)
+          File.open(io, 'r')
+        else
+          StringIO.new(io)
+        end
+      end
+      # make sure we have the stream open
+      raise 'Unable to create local socket' unless @io
+    end
+
+    alias_method :initialize_without_web, :initialize
+    alias_method :initialize, :initialize_with_web
+
+  end
+
+  class HTTP
+
+    class << self
+
+      def socket_type_with_web
+        Web::StubSocket
+      end
+
+      alias_method :socket_type_without_web, :socket_type
+      alias_method :socket_type, :socket_type_with_web
+
+    end
+
+    def request_with_web(request, body = nil, &block)
+      connect
+      # get a faker
+      headers = {}
+      request.each do |key, value|
+        headers[key] = value
+      end
+      web = Web::Faker.new request.method.downcase.to_sym, request_uri_as_string(request), body, headers
+      if web.desired? && web_response = web.response_for
+        # turn the web response into a Net::HTTPResponse
+        response = Net::HTTPResponse.send(:response_class, web_response.code.to_s).new('1.0', web_response.code.to_s, HTTP_STATUS_CODES[web_response.code])
+        web_response.headers.each do |name, value|
+          if value.respond_to?(:each)
+            value.each { |val| response.add_field(name, val) }
+          else
+            response[name] = value
+          end
+        end
+        response.extend Web::HTTPResponse
+        response.instance_variable_set(:@body, web_response.body)
+        response.instance_variable_set(:@read, true)
+        yield response if block_given?
+        # respond cached
+        response.instance_variable_set(:@cached, true)
+        response
+      else
+        # get the  response and store it if its desirable
+        if web.desired?
+          response = request_without_web(request, body)
+          headers = {}
+          response.each do |key, value|
+            headers[key] = value
+          end
+          response.extend Web::HTTPResponse
+          web.record response.code.to_i, response.body, headers
+          yield response if block_given?
+          response
+        else
+          response = request_without_web(request, body, &block)
+          response.extend Web::HTTPResponse
+          response
+        end
+      end
+    end
+
+    alias_method :request_without_web, :request
+    alias_method :request, :request_with_web
+
+    private
+
+    def request_uri_as_string(request)
+      protocol = use_ssl? ? 'https' : 'http'
+      path = request.path
+      path = URI.parse(request.path).request_uri if request.path =~ /^http/
+      # TODO handle basic auth
+      "#{protocol}://#{address}:#{port}#{path}"
+    end
+
+  end
+
+end

data/lib/web/faker.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/response'
+
+module Web
+
+  # A class for representing one faked response
+  class Faker
+
+    attr_reader :cache, :key
+
+    def initialize(method, url, body, headers)
+      @key = "#{method}:#{url}"
+      @cache = Web.cache
+      # keep these around
+      @url = url
+    end
+
+    # whether or not this is a key we want
+    def desired?
+      @match = Web.registered.detect do |opt|
+        opt[:regex] =~ @url
+      end
+    end
+
+    # Given a response, marshall down and record in redis
+    def record(code, body, headers)
+      # save and return the response
+      res = Web::Response.new code, body, headers
+      # Allow expireation to be set
+      expires = @match.has_key?(:expire) ? @match[:expire].to_i : nil
+      cache.set(key, res.dump, expires)
+      res
+    end
+
+    # Get the mashalled form from redis and reconstruct
+    # into a Web::Response
+    def response_for
+      if data = cache.get(key)
+        Web::Response.load(data)
+      else
+        nil
+      end
+    end
+
+  end
+
+end

data/lib/web/http_response.rb

@@ -0,0 +1,16 @@
+module Web
+
+  module HTTPResponse
+
+    def read_body(dist = nil, &block)
+      yield @body if block_given?
+      @body
+    end
+
+    def cached?
+      !!@cached
+    end
+
+  end
+
+end

data/lib/web/response.rb

@@ -0,0 +1,27 @@
+require 'json'
+
+module Web
+
+  # A class which represents data from a response
+  class Response
+
+    attr_reader :code, :headers, :body
+
+    def dump
+      { :code => @code, :headers => @headers, :body => @body }.to_json
+    end
+
+    def self.load(data)
+      data = JSON::parse(data)
+      self.new(data['code'], data['body'], data['headers'])
+    end
+
+    def initialize(code, body, headers)
+      @code = code
+      @body = body
+      @headers = headers || {}
+    end
+
+  end
+
+end

data/lib/web/status_codes.rb

@@ -0,0 +1,53 @@
+HTTP_STATUS_CODES = {
+  100  => 'Continue',
+  101  => 'Switching Protocols',
+  102  => 'Processing',
+  200  => 'OK',
+  201  => 'Created',
+  202  => 'Accepted',
+  203  => 'Non-Authoritative Information',
+  204  => 'No Content',
+  205  => 'Reset Content',
+  206  => 'Partial Content',
+  207  => 'Multi-Status',
+  226  => 'IM Used',
+  300  => 'Multiple Choices',
+  301  => 'Moved Permanently',
+  302  => 'Found',
+  303  => 'See Other',
+  304  => 'Not Modified',
+  305  => 'Use Proxy',
+  306  => 'Reserved',
+  307  => 'Temporary Redirect',
+  400  => 'Bad Request',
+  401  => 'Unauthorized',
+  402  => 'Payment Required',
+  403  => 'Forbidden',
+  404  => 'Not Found',
+  405  => 'Method Not Allowed',
+  406  => 'Not Acceptable',
+  407  => 'Proxy Authentication Required',
+  408  => 'Request Timeout',
+  409  => 'Conflict',
+  410  => 'Gone',
+  411  => 'Length Required',
+  412  => 'Precondition Failed',
+  413  => 'Request Entity Too Large',
+  414  => 'Request-URI Too Long',
+  415  => 'Unsupported Media Type',
+  416  => 'Requested Range Not Satisfiable',
+  417  => 'Expectation Failed',
+  422  => 'Unprocessable Entity',
+  423  => 'Locked',
+  424  => 'Failed Dependency',
+  426  => 'Upgrade Required',
+  500  => 'Internal Server Error',
+  501  => 'Not Implemented',
+  502  => 'Bad Gateway',
+  503  => 'Service Unavailable',
+  504  => 'Gateway Timeout',
+  505  => 'HTTP Version Not Supported',
+  506  => 'Variant Also Negotiates',
+  507  => 'Insufficient Storage',
+  510  => 'Not Extended'
+}

data/lib/web/version.rb

@@ -0,0 +1,5 @@
+module Web
+
+  VERSION = '0.0.1'
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/../lib/web'

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: web
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- John Crepezzi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-21 00:00:00.000000000 -04:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2154079540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2154079540
+description: web is a library for caching HTTP responses
+email: john.crepezzi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/web/cache/memcached_cache.rb
+- lib/web/cache/memory_cache.rb
+- lib/web/cache/redis_cache.rb
+- lib/web/ext/net_http.rb
+- lib/web/faker.rb
+- lib/web/http_response.rb
+- lib/web/response.rb
+- lib/web/status_codes.rb
+- lib/web/version.rb
+- lib/web.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://seejohnrun.github.com/web/
+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: web
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: cache HTTP responses
+test_files:
+- spec/spec_helper.rb