carbon-copy 0.0.2 → 0.1.0

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,37 @@
+PATH
+  remote: .
+  specs:
+    carbon-copy (0.0.2)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    mime-types (1.19)
+    rack (1.4.1)
+    rack-protection (1.2.0)
+      rack
+    rest-client (1.6.7)
+      mime-types (>= 1.16)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.2)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.2)
+    sinatra (1.3.3)
+      rack (~> 1.3, >= 1.3.6)
+      rack-protection (~> 1.2)
+      tilt (~> 1.3, >= 1.3.3)
+    tilt (1.3.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  carbon-copy!
+  rest-client
+  rspec
+  sinatra

data/README.md

@@ -1,7 +1,7 @@
 # Carbon Copy - Easily cache them REST calls
 
 We created Carbon Copy to allow for quick front end (or back end) development by
-caching REST responses. We also wanted it to be easy and quick.
+caching REST responses.
 
 ### How it works
 

data/bin/carbon-copy

@@ -2,19 +2,17 @@
 require 'optparse'
 require 'carbon-copy'
 
-server = CarbonCopy::CacheServer.new
+cc = CarbonCopy::CarbonCopy.new
 
 opts = OptionParser.new do |opts|
   opts.banner = "Carbon Copy: Cache them RESTs"
   opts.on("-p", "--port Port", "Port to run server") do |v|
-    server.run(v)
+    cc.port = v
+  end
+  opts.on("-l", "--cache Cache", "Cache files location") do |v|
+    cc.request_cacher = CarbonCopy::RequestCacher(v)
   end
 end
 opts.parse!
 
-uri = ARGV.shift
-
-if uri.to_s.strip.empty?
-  puts opts
-  exit 1
-end
+cc.run

data/carbon-copy.gemspec

@@ -14,4 +14,8 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = CarbonCopy::VERSION
   gem.executables   = ['carbon-copy']
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rest-client"
+  gem.add_development_dependency "sinatra"
 end

data/lib/carbon-copy.rb

@@ -1,6 +1,36 @@
 require 'carbon-copy/cache_server'
-require 'carbon-copy/http_cacher'
+require 'carbon-copy/request_cacher'
+
+#### CarbonCopy
+#
+# CarbonCopy is a simple server that sits between your outbound api requests
+# and your file system. It was created in response to a frustration when
+# developing frontend applications on untested backends. CarbonCopy stores your
+# requests locally so if a server stops responding, or is too slow to test on,
+# you can rely on cached data instead of making an http reqest for each
+# refresh.
+#
 
 module CarbonCopy
-  VERSION = '0.0.2'
+  VERSION = '0.1.0'
+
+  # connect all teh pieces
+  class CarbonCopy
+    attr_writer :request_cacher, :port
+
+    def run
+      CacheServer.new(port, request_cacher).run
+    end
+
+    # default to built in request cacher with current path as the request cache
+    # location
+    def request_cacher
+      @request_cacher || RequestCacher.new(Dir.pwd)
+    end
+
+    # default to port 7979
+    def port
+      @port || 7979
+    end
+  end
 end

data/lib/carbon-copy/cache_server.rb

@@ -1,66 +1,29 @@
 require 'socket'
-require 'open-uri'
 require 'openssl'
-require 'carbon-copy/http_cacher'
+require 'carbon-copy/request_cacher'
 
 module CarbonCopy
   class CacheServer
 
-    def run(port)
-      webserver = TCPServer.new('127.0.0.1', port)
-      puts "Running Carbon Copy on localhost port #{port}"
-      while (session = webserver.accept)
-        Thread.new(session, &method(:handle))
-      end
-    end
-
-    def parse_request(session)
-      request = session.readline
-
-      parsed = {}
-      #---  Initial host/uri information  -------------------------------------
-      parsed[:verb]    = request[/^\w+/]
-      parsed[:url]     = request[/^#{parsed[:verb]}\s+\/(\S+)/, 1]
-      parsed[:host]    = request[/^#{parsed[:verb]}\s+\/([^\/ ]+)/, 1]
-      parsed[:version] = request[/HTTP\/(1\.\d)\s*$/, 1]
-      parsed[:uri]     = request[/^#{parsed[:verb]}\s+\/#{parsed[:host]}(\S+)\s+HTTP\/#{parsed[:version]}/, 1] || '/'
-
-      uri = URI::parse(parsed[:uri])
-      parsed[:request_str] = "#{parsed[:verb]} #{uri.path}?#{uri.query} HTTP/#{parsed[:version]}\r"
-
-      #---  Header and final response text  -----------------------------------
-      parsed[:headers] = parse_headers(session)
-      
-      #---  Update header info  -----------------------------------------------
-      parsed[:headers]["Host"]   = parsed[:host]
-
-      parsed[:header_str] = parsed[:headers].map{|a, b| "#{a}: #{b}"}.join("\r\n")
-      parsed[:response] = "#{parsed[:request_str]}\n#{parsed[:header_str]}\r\n\r\n"
-
-      parsed
+    def initialize(port, request_cacher)
+      @port           = port
+      @request_cacher = request_cacher
     end
-    
-    def parse_headers(request)
-      header = {}
-      unless request.eof?
-        loop do
-          line = request.readline
-          if line.strip.empty?
-            break
-          end
 
-          /^(\S+): ([^\r\n]+)/.match(line)
-          header[$1] = $2
-        end
+    def run
+      webserver = TCPServer.new('127.0.0.1', @port)
+      puts "Running Carbon Copy on localhost port #{@port}"
+      while (session = webserver.accept)
+        Thread.new(session, &method(:handle))
       end
-      header
     end
 
     def handle(session)
       begin
-        req = parse_request(session)
-        resp = HTTPCacher.new.connect(req)
-        session.write(resp)
+        request = Request.new(session)
+        request.parse
+        response = @request_cacher.connect(request)
+        session.write(response)
         session.close
       rescue => e
         p e.message

data/lib/carbon-copy/request.rb

@@ -0,0 +1,58 @@
+require 'open-uri'
+
+module CarbonCopy
+  class Request
+    attr_accessor :verb, :host, :port, :path, :version, :url, :uri,
+      :request_str, :headers, :header_str, :request
+
+    def initialize(session)
+      @session = session
+    end
+
+    def parse
+      request = @session.readline
+
+      #---  Initial host/uri information  -------------------------------------
+      @verb    = request.slice!(/^\w+\s/).strip
+      @host    = request.slice!(/^\/[^\/: ]+/)[1..-1]
+      @port    = request.slice!(/^:(\d+)/)
+
+      @port    = ( @port.nil? ) ? '80' : @port[1..-1] # Remove the colon
+
+      @path    = request.slice!(/^(\S)+/)
+      @version = request[/HTTP\/(1\.\d)\s*$/, 1]
+      @url     = "#{@host}#{@path}"
+      @uri     = "#{@path || '/'}"
+
+      uri = URI::parse(@uri)
+      @request_str = "#{@verb} #{uri.path}?#{uri.query} HTTP/#{@version}\r"
+
+      #---  Header and final response text  -----------------------------------
+      @headers = parse_headers(@session)
+      
+      #---  Update header info  -----------------------------------------------
+      @headers["Host"] = @host
+
+      @header_str = @headers.map{|a, b| "#{a}: #{b}"}.join("\r\n")
+      @request = "#{@request_str}\n#{@header_str}\r\n\r\n"
+
+      self
+    end
+
+    def parse_headers(request)
+      header = {}
+      unless request.eof?
+        loop do
+          line = request.readline
+          if line.strip.empty?
+            break
+          end
+
+          /^(\S+): ([^\r\n]+)/.match(line)
+          header[$1] = $2
+        end
+      end
+      header
+    end
+  end
+end

data/lib/carbon-copy/request_cacher.rb

@@ -0,0 +1,85 @@
+require 'digest/md5'
+
+module CarbonCopy
+  class RequestCacher
+    attr_reader :base_dir
+
+    def initialize(base_dir)
+      @base_dir = base_dir
+    end
+
+    # Setup cache directory
+    def cache_dir
+      "#{@base_dir}/.request_cache"
+    end
+
+    # Determine final path
+    def path(request)
+      uri = ( request.uri == '/' ) ? '' : request.uri.gsub("\/", "_")
+      hash = Digest::MD5.new << request.header_str
+      # Cache directory structure
+      """
+        #{cache_dir}/
+          #{request.host}/
+            #{request.verb.downcase}
+            #{uri}_
+            #{hash}
+      """.gsub(/\n|\s/, '')
+    end
+
+    # Ensure cached directories are created
+    def verify_cached_dir(request)
+      Dir.mkdir(cache_dir) unless File.exists?(cache_dir)
+      host_cache = "#{cache_dir}/#{request.host}"
+      Dir.mkdir(host_cache) unless File.exists?(host_cache)
+    end
+
+    def get_response(request)
+      a = TCPSocket.new(request.host, request.port)
+      a.write(request.request)
+
+      # Pull request data
+      content_len = nil
+      buff = ""
+      loop do
+        line = a.readline
+        buff += line
+        if line =~ /^Content-Length:\s+(\d+)\s*$/
+          content_len = $1.to_i
+        end
+        break if line.strip.empty?
+      end
+
+      # Pull response
+      if content_len
+        buff += a.read(content_len)
+      else
+        loop do
+          if a.eof? || line = a.readline || line.strip.empty?
+            break
+          end
+          buff += line
+        end
+      end
+      a.close
+
+      buff
+    end
+
+    def connect(request)
+      verify_cached_dir(request)
+      cached_path = path(request)
+
+      if File.exists?(cached_path) && !File.zero?(cached_path)
+        puts "Getting file #{cached_path} from cache"
+        IO.read( cached_path )
+      else
+        resp = get_response(request)
+        File.open( cached_path, 'w' ) do |f|
+          f.puts resp
+        end
+        resp
+      end
+    end
+  end
+end

data/spec/cache_server_spec.rb

@@ -1,101 +0,0 @@
-require File.expand_path('../../lib/carbon-copy', __FILE__)
-require 'open-uri'
-require 'net/http'
-
-describe CarbonCopy::CacheServer do
-  describe '#parse_headers' do
-    let(:rs) { CarbonCopy::CacheServer.new }
-    
-    it 'should parse easy header strings' do
-      st = StringIO.new
-      st << "TestHeader: Header Result"
-      st << "\r\n\r\n"
-      st.rewind
-      rs.parse_headers(st).should eq({"TestHeader" => "Header Result"})
-    end
-
-    it 'should parse multi-line headers' do
-      st = StringIO.new
-      st << "TestHeader: Header Result\n"
-      st << "TestHeaders: Header Result"
-      st << "\r\n\r\n"
-      st.rewind
-      rs.parse_headers(st).should eq({
-        "TestHeader" => "Header Result",
-        "TestHeaders" => "Header Result"
-      })
-    end
-  end
-
-  describe '#parse_request' do
-    let(:rs) { CarbonCopy::CacheServer.new }
-    let(:req) { rs.parse_request(request) }
-    
-    describe 'host with path' do
-      let(:request) { 
-        req = StringIO.new << "GET /apple.com/google/face/ HTTP/1.1\n"
-        req.rewind 
-        req
-      }
-
-      it 'verb' do
-        req[:verb].should eq("GET")
-      end
-
-      it 'url with path' do
-        req[:url].should eq('apple.com/google/face/')
-      end
-
-      it 'version' do
-        req[:version].should eq('1.1')
-      end
-
-      it 'host' do
-        req[:host].should eq('apple.com')
-      end
-
-      it 'uri' do
-        req[:uri].should eq('/google/face/')
-      end
-
-      it 'request_str' do
-        req[:request_str].should eq("GET /google/face/? HTTP/1.1\r")
-      end
-    end
-
-    describe 'just host' do
-      let(:request) { 
-        req = StringIO.new << "GET /apple.com HTTP/1.1\n"
-        req.rewind 
-        req
-      }
-      it 'host' do
-        req[:host].should eq('apple.com')
-      end
-
-      it 'uri' do
-        req[:uri].should eq('/')
-      end
-    end
-
-  end
-
-  describe '#handle' do
-    before(:all) do
-      Thread.new do
-        CarbonCopy::CacheServer.new.run(7979)
-      end
-    end
-
-    it 'caches google.com simple get request' do
-      url = 'www.apple.com'
-      o_req = get("http://#{url}").body
-      req   = get("http://localhost:7979/#{url}").body
-      req.should eq(o_req)
-    end
-  end
-end
-
-def get(url)
-  Net::HTTP.get_response(URI.parse(url))
-end

data/spec/integration_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'open-uri'
+require 'net/http'
+require 'sinatra/base'
+require 'rest-client'
+
+class TestApp < Sinatra::Base
+  get '/awesome' do
+    'This is an awesome get request!'
+  end
+  
+  options '/awesome' do
+    'This is an awesome options request!'
+  end
+end
+
+module CarbonCopy
+describe CarbonCopy do
+
+  describe '#handle' do
+    before(:all) do
+      @cache_thread = Thread.new do
+        carbon_copy = CarbonCopy.new
+        carbon_copy.request_cacher = RequestCacher.new(support_path)
+        carbon_copy.port = 7979
+        carbon_copy.run
+      end
+
+      @sinatra_thread = Thread.new do
+        TestApp.run! host: 'localhost', port: 9898
+      end
+      sleep 1 # to allow for sinatra to boot
+    end
+
+    after(:all) do
+      @cache_thread.kill
+      @sinatra_thread.kill
+    end
+
+    it 'caches get request' do
+      url = 'localhost:9898/awesome'
+      o_req = RestClient.get("http://#{url}").to_str
+      req =   RestClient.get("http://localhost:7979/#{url}").to_str
+      req.should eq(o_req)
+    end
+
+    it 'caches options request' do
+      url = 'localhost:9898/awesome'
+      o_req = RestClient.options("http://#{url}").to_str
+      req =   RestClient.options("http://localhost:7979/#{url}").to_str
+      req.should eq(o_req)
+    end
+
+    def support_path
+      File.expand_path('../support', __FILE__)
+    end
+  end
+end
+end

data/spec/request_cacher_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'digest/md5'
+require 'ostruct'
+
+module CarbonCopy
+describe RequestCacher do
+  let(:cacher) { RequestCacher.new('') }
+  let(:parsed) {
+    a = OpenStruct.new
+    a.verb = 'GET'
+    a.url = 'gist.github.com/74107'
+    a.host = 'gist.github.com'
+    a.version = '1.1'
+    a.uri = '/74107'
+    a.header_str = 'Test Header = Test Result'
+    a
+  }
+  it 'should have path with url' do
+    hash = Digest::MD5.new << parsed.header_str
+    cacher.path(parsed).should match(/\.request_cache\/gist\.github\.com\/get_74107_#{hash}/)
+  end
+
+  it 'should reflect no path' do
+    hash = Digest::MD5.new << parsed.header_str
+    parsed.url = 'gist.github.com'
+    parsed.uri = '/'
+    cacher.path(parsed).should match(/\.request_cache\/gist\.github\.com\/get_#{hash}/)
+  end
+end
+end

data/spec/request_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'carbon-copy/request'
+
+module CarbonCopy
+describe Request do
+  describe '#parse_headers' do
+    let(:rs) { Request.new(stub.as_null_object) }
+    
+    it 'should parse easy header strings' do
+      st = StringIO.new
+      st << "TestHeader: Header Result"
+      st << "\r\n\r\n"
+      st.rewind
+      rs.parse_headers(st).should eq({"TestHeader" => "Header Result"})
+    end
+
+    it 'should parse multi-line headers' do
+      st = StringIO.new
+      st << "TestHeader: Header Result\n"
+      st << "TestHeaders: Header Result"
+      st << "\r\n\r\n"
+      st.rewind
+      rs.parse_headers(st).should eq({
+        "TestHeader" => "Header Result",
+        "TestHeaders" => "Header Result"
+      })
+    end
+  end
+
+  describe '#parse' do
+    let(:rs) { Request.new(request).parse }
+    
+    describe 'just host' do
+      let(:request) { create_host_IO("GET /apple.com HTTP/1.1\n") }
+
+      specify { rs.host.should eq('apple.com') }
+      specify { rs.uri.should  eq('/') }
+    end
+
+    describe 'host with port' do
+      let(:request) { create_host_IO("GET /apple.com:3000 HTTP/1.1\n") }
+
+      specify { rs.port.should eq('3000') }
+      specify { rs.host.should eq('apple.com') }
+      specify { rs.url.should  eq('apple.com') }
+      specify { rs.uri.should  eq('/') }
+    end
+
+    describe 'host with port and path' do
+      let(:request) { create_host_IO("GET /apple.com:18/awesome HTTP/1.1\n") }
+
+      specify { rs.port.should eq('18') }
+      specify { rs.host.should eq('apple.com') }
+      specify { rs.url.should  eq('apple.com/awesome') }
+      specify { rs.uri.should  eq('/awesome') }
+    end
+
+    describe 'host with get string' do
+      let(:request) { create_host_IO("POST /fazebook.com/google?p=test HTTP/1.1\n") }
+
+      specify { rs.verb.should        eq('POST') }
+      specify { rs.port.should        eq('80') }
+      specify { rs.url.should         eq('fazebook.com/google?p=test') }
+      specify { rs.request_str.should eq("POST /google?p=test HTTP/1.1\r") }
+    end
+
+    describe 'host with path' do
+      let(:request) { create_host_IO("GET /apple.com/google/face/ HTTP/1.1\n") }
+
+      specify { rs.verb.should        eq('GET') }
+      specify { rs.port.should        eq('80') }
+      specify { rs.url.should         eq('apple.com/google/face/') }
+      specify { rs.version.should     eq('1.1') }
+      specify { rs.host.should        eq('apple.com') }
+      specify { rs.uri.should         eq('/google/face/') }
+      specify { rs.request_str.should eq("GET /google/face/? HTTP/1.1\r") }
+    end
+  end
+
+  def create_host_IO(host)
+    req = StringIO.new
+    host.split("\n").each do |host|
+      req << "#{host}\n"
+    end
+    req.rewind
+    req
+  end
+
+end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require File.expand_path('../../lib/carbon-copy', __FILE__)
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: carbon-copy
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,56 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-02 00:00:00.000000000 Z
-dependencies: []
+date: 2012-09-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: easily cache them REST calls
 email:
 - me@kdoubleyou.com
@@ -20,14 +68,21 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
 - README.md
 - bin/carbon-copy
 - carbon-copy.gemspec
 - lib/carbon-copy.rb
 - lib/carbon-copy/cache_server.rb
-- lib/carbon-copy/http_cacher.rb
+- lib/carbon-copy/request.rb
+- lib/carbon-copy/request_cacher.rb
 - spec/cache_server_spec.rb
-- spec/http_cacher_spec.rb
+- spec/integration_spec.rb
+- spec/request_cacher_spec.rb
+- spec/request_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/rabidpraxis/carbon-copy
 licenses: []
 post_install_message: 
@@ -54,5 +109,8 @@ specification_version: 3
 summary: REST cache
 test_files:
 - spec/cache_server_spec.rb
-- spec/http_cacher_spec.rb
+- spec/integration_spec.rb
+- spec/request_cacher_spec.rb
+- spec/request_spec.rb
+- spec/spec_helper.rb
 has_rdoc: 

data/lib/carbon-copy/http_cacher.rb

@@ -1,91 +0,0 @@
-require 'digest/md5'
-
-module CarbonCopy
-  class HTTPCacher
-    attr_reader :base_dir
-
-    def initialize(base_dir = Dir.pwd)
-      @base_dir = base_dir
-    end
-
-    #--------------------------------------------------------------------------
-    # Setup cache directory
-    #--------------------------------------------------------------------------
-    def cache_dir
-      "#{base_dir}/.request_cache"
-    end
-
-    #--------------------------------------------------------------------------
-    # Determine final path
-    #--------------------------------------------------------------------------
-    def path(parsed)
-      uri = ( parsed[:uri] == '/' ) ? '' : parsed[:uri].gsub("\/", "_")
-      hash = Digest::MD5.new << parsed[:header_str]
-      #---  Cache directory structure  ----------------------------------------
-      """
-        #{cache_dir}/
-          #{parsed[:host]}/
-            #{parsed[:verb].downcase}
-            #{uri}_
-            #{hash}
-      """.gsub(/\n|\s/, '')
-    end
-
-    #--------------------------------------------------------------------------
-    # Ensure cached directories are created
-    #--------------------------------------------------------------------------
-    def verify_cached_dir(parsed)
-      Dir.mkdir(cache_dir) unless File.exists?(cache_dir)
-      host_cache = "#{cache_dir}/#{parsed[:host]}"
-      Dir.mkdir(host_cache) unless File.exists?(host_cache)
-    end
-
-    def get_response(parsed)
-      a = TCPSocket.new(parsed[:host], 80)
-      a.write(parsed[:response])
-
-      #---  Pull request data  ------------------------------------------------
-      content_len = nil
-      buff = ""
-      loop do
-        line = a.readline
-        buff += line
-        if line =~ /^Content-Length:\s+(\d+)\s*$/
-          content_len = $1.to_i
-        end
-        break if line.strip.empty?
-      end
-
-      #---  Pull response  ----------------------------------------------------
-      if content_len
-        buff += a.read(content_len)
-      else
-        loop do
-          if a.eof? || line = a.readline || line.strip.empty?
-            break
-          end
-          buff += line
-        end
-      end
-      a.close
-
-      buff
-    end
-
-    def connect(parsed)
-      verify_cached_dir(parsed)
-      cached_path = path(parsed)
-
-      if File.exists?(cached_path) && !File.zero?(cached_path)
-        puts "Getting file #{cached_path} from cache"
-        IO.read( cached_path )
-      else
-        resp = get_response(parsed)
-        File.open( cached_path, 'w' ) do |f|
-          f.puts resp
-        end
-        resp
-      end
-    end
-  end
-end

data/spec/http_cacher_spec.rb

@@ -1,27 +0,0 @@
-require File.expand_path('../../lib/carbon-copy', __FILE__)
-require 'digest/md5'
-
-describe CarbonCopy::HTTPCacher do
-  let(:cacher) { CarbonCopy::HTTPCacher.new }
-  let(:parsed) {
-    {
-      verb: 'GET',
-      url: 'gist.github.com/74107',
-      host: 'gist.github.com',
-      version: '1.1',
-      uri: '/74107',
-      header_str: 'Test Header: Test Result'
-    }
-  }
-  it 'should have path with url' do
-    hash = Digest::MD5.new << parsed[:header_str]
-    cacher.path(parsed).should match(/\.request_cache\/gist\.github\.com\/get_74107_#{hash}/)
-  end
-
-  it 'should reflect no path' do
-    hash = Digest::MD5.new << parsed[:header_str]
-    parsed[:url] = 'gist.github.com'
-    parsed[:uri] = '/'
-    cacher.path(parsed).should match(/\.request_cache\/gist\.github\.com\/get_#{hash}/)
-  end
-end