web_fetch 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b70b780490a40e97db81d2843d57a0fbd94c03540f163c9649290e2f99683013
-  data.tar.gz: a706bcccffa4689c056fdcbe2d6d0097727c23d4adfc4283fd1a0db324413a41
+  metadata.gz: 19518942fe1e37355b4cf571590fb7d844c0eded61b035c036bb923a114e0aa4
+  data.tar.gz: ba143ee2c1244b5c37459f1057beaba210945f310c4d8174b0253d9cec90d0f0
 SHA512:
-  metadata.gz: 3af281a4323e50eb8e825bb363e11a6139c8863ad55ca7d5a5cb6129f5a77ff69643d2dd3e58b1b66505fce5298425dd68f8a1befb117bdd92fd822ca3d66977
-  data.tar.gz: 2adb96356952a638e9e118485b097fab6e697a70dbc20c852be059713569e36fd61dc00d8cff67a18564c3426591157ee4884ce15f37a7970977989c49b93464
+  metadata.gz: f37dcd9cca372a63f47737ff619a996cfa68494038d1746d3f28445f7ad7fd8c9651e43f284e2ece92696b9883a28295bedc9e8d55789fe91aeb4d60032a342e
+  data.tar.gz: 0542a7735cda7d6eddaee2a94df7b5143934184a4902d3c21c2546dd2361d74226916efd783f635828db73d0eec49e10400d50594cab82aa094faf83a63a6231

data/.gitignore

@@ -17,3 +17,5 @@
 bin/*.pid
 web_fetch-*.gem
 Gemfile.lock
+
+docker/.build

data/Makefile

@@ -0,0 +1,6 @@
+.PHONY: docker
+
+docker:
+	mkdir -p docker/.build
+	git archive --format tar.gz -o docker/.build/web_fetch.tar.gz master
+	docker build -t webfetch/webfetch docker

data/README.md

@@ -1,9 +1,8 @@
 # WebFetch
 
 ```
-And it turns out she's got everything I want
-All rolled into one
-                                --Nickelback
+Better all together than just one at a time
+                               --Nickelback
 ```
 
 ## Overview
@@ -66,7 +65,7 @@ end
 
 Only `url` is required. The default HTTP method is `GET`.
 
-Anything assigned to `custom` will be returned with the final result (available by calling `#custom` on the result). This may be useful if you need to tag each request with your own custom identifier, for example. Anything you assign here will have no bearing whatsoever on the HTTP request.
+Anything assigned to `custom` will be returned with the final response (available by calling `#custom` on the response). This may be useful if you need to tag each request with your own custom identifier, for example. Anything you assign here will have no bearing whatsoever on the HTTP request.
 
 If you prefer to build a request from a hash, you can call `WebFetch::Request.from_hash`
 
@@ -91,37 +90,38 @@ promises = client.gather([request])
 
 `WebFetch::Client#gather` accepts an array of `WebFetch::Request` objects and immediately returns an array of `WebFetch::Promise` objects. WebFetch will process all requests in the background concurrently.
 
-To retrieve the result of a request, call `WebFetch::Promise#fetch`
+To retrieve the response of a request, call `WebFetch::Promise#fetch`
 
 ``` ruby
-result = promises.first.fetch
+response = promises.first.fetch
 
 # Available methods:
-result.body
-result.headers
-result.status # HTTP status code
-result.success? # False if a network error (not HTTP error) occurred
-result.error # Underlying network error if applicable
-result.response_time
+response.body
+response.headers
+response.status # HTTP status code
+response.success? # False if a network error (not HTTP error) occurred
+response.error # Underlying network error if applicable
+response.response_time
+response.request # The original request, provided as a `WebFetch::Request` object
 ```
 
-Note that `WebFech::Promise#fetch` will block until the result is complete by default. If you want to continue executing other code if the result is not ready (e.g. to see if any other results are ready), you can pass `wait: false`
+Note that `WebFech::Promise#fetch` will block until the response is complete by default. If you want to continue executing other code if the response is not ready (e.g. to see if any other responses are ready), you can pass `wait: false`
 
 ``` ruby
-result = promises.first.fetch(wait: false)
+response = promises.first.fetch(wait: false)
 ```
 
-A special value `:pending` will be returned if the result is still processing.
+If the response has not yet returned, `response.pending?` will be `true`.
 
 Alternatively, you can call `WebFetch::Promise#complete?` to check if a request has finished before waiting for the response:
 
 ``` ruby
-result = promises.first.fetch if promises.first.complete?
+response = promises.first.fetch if promises.first.complete?
 ```
 
-### Fetching results later
+### Fetching responses later
 
-In some cases you may need to fetch the result of a request in a different context to which you initiated it. A unique ID is available for each *Promise* which can be used to fetch the result from a separate *Client* instance:
+In some cases you may need to fetch the response of a request in a different context to which you initiated it. A unique ID is available for each *Promise* which can be used to fetch the response from a separate *Client* instance:
 
 ``` ruby
 client = WebFetch::Client.new('localhost', 8077)
@@ -132,7 +132,7 @@ uid = promises.first.uid
 
 # Later ...
 client = WebFetch::Client.new('localhost', 8077)
-result = client.fetch(uid)
+response = client.fetch(uid)
 ```
 
 This can be useful if your web application initiates requests in one controller action and fetches them in another; the `uid` can be stored in a database and used to fetch the request later on.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/doc/examples/blocking_requests.rb

@@ -21,9 +21,9 @@ def blocking_requests
   promises = client.gather(requests)
 
   promises.each do |promise|
-    result = promise.fetch(wait: true) # Will block (default behaviour)
-    puts result.body[0..100]
-    puts "Success: #{result.success?}"
+    response = promise.fetch(wait: true) # Will block (default behaviour)
+    puts response.body[0..100]
+    puts "Success: #{response.success?}"
   end
 
   client.stop

data/doc/examples/non_blocking_requests.rb

@@ -22,8 +22,8 @@ def non_blocking_requests
 
   while promises.any? { |promise| !promise.complete? }
     promises.each do |promise|
-      result = promise.fetch(wait: false) # Will not block
-      puts result.body[0..100] unless result == :pending
+      response = promise.fetch(wait: false) # Will not block
+      puts response.body[0..100] unless response == :pending
     end
   end
 

data/doc/examples/use_uid_for_request.rb

@@ -15,11 +15,11 @@ def use_uid_for_request
   promises = client.gather([request])
   uid = promises.first.uid
   while true
-    result = client.fetch(uid, wait: false)
-    break unless result == :pending
+    response = client.fetch(uid, wait: false)
+    break unless response == :pending
   end
 
-  puts result.body[0..100]
+  puts response.body[0..100]
 
   client.stop
 end

data/docker/Dockerfile

@@ -1,3 +1,5 @@
 FROM library/ruby
-RUN gem install web_fetch
+ADD .build/web_fetch.tar.gz .
+WORKDIR web_fetch
+RUN bundle && bundle exec rake install
 CMD ["web_fetch_control", "run", "--", "--port", "8077", "--host", "0.0.0.0"]

data/lib/web_fetch.rb

@@ -39,6 +39,6 @@ require 'web_fetch/retriever'
 require 'web_fetch/client'
 require 'web_fetch/request'
 require 'web_fetch/promise'
-require 'web_fetch/result'
+require 'web_fetch/response'
 require 'web_fetch/errors'
 require 'web_fetch/version'

data/lib/web_fetch/client.rb

@@ -57,9 +57,7 @@ module WebFetch
       outcome = block ? retrieve_by_uid(uid) : find_by_uid(uid)
       no_request_error(uid) if outcome.nil?
 
-      return :pending if outcome[:pending]
-
-      new_result(outcome)
+      new_response(outcome)
     end
 
     def retrieve_by_uid(uid)
@@ -104,20 +102,22 @@ module WebFetch
       raise RequestNotFoundError, [I18n.t('no_request', uid: uid)]
     end
 
-    def new_result(outcome)
-      response = outcome[:response]
-      # FIXME: This is sort-of duplicated from `Promise#new_result` but we
+    def new_response(outcome)
+      response = outcome[:response] || {}
+      # FIXME: This is sort-of duplicated from `Promise#new_response` but we
       # build it very slightly differently. This means we have to update in
       # both places if we change the structure. Not quite sure how to unify
       # this and ensure the same structure in both places.
-      Result.new(
+      Response.new(
+        pending: outcome[:pending],
         body: response[:body],
         headers: response[:headers],
         status: response[:status],
         success: response[:success],
         error: response[:error],
         uid: outcome[:uid],
-        response_time: response[:response_time]
+        response_time: response[:response_time],
+        request: outcome[:request]
       )
     end
 

data/lib/web_fetch/concerns/http_helpers.rb

@@ -61,6 +61,7 @@ module WebFetch
         status: result.response_header.status,
         response_time: request[:response_time]
       },
+        request: request[:request],
         uid: request[:uid] }
     end
 
@@ -81,6 +82,7 @@ module WebFetch
         response_time: request[:response_time],
         error: (result.error&.inspect)
       },
+        request: request[:request],
         uid: request[:uid] }
     end
 

data/lib/web_fetch/promise.rb

@@ -2,7 +2,7 @@
 
 module WebFetch
   class Promise
-    attr_reader :uid, :request, :result
+    attr_reader :uid, :request, :response
 
     def initialize(client, options = {})
       @client = client
@@ -11,11 +11,10 @@ module WebFetch
     end
 
     def fetch(options = {})
-      return @result if complete?
+      return @response if complete?
 
-      block = options.fetch(:wait, true)
-      @raw_result = find_or_retrieve(block)
-      (@result = build_result)
+      wait = options.fetch(:wait, true)
+      (@response = @client.fetch(@uid, wait: wait))
     end
 
     def custom
@@ -23,56 +22,25 @@ module WebFetch
     end
 
     def complete?
-      return false if @result.nil?
-      return false if pending?
-      return true if @result
+      return false if @response.nil?
 
-      false
+      @response.complete?
     end
 
     def pending?
-      return false if @result.nil?
+      return false if @response.nil?
 
-      @result == :pending
+      @response.pending?
     end
 
     def success?
-      complete? && @raw_result[:response][:success]
+      complete? && @response.success?
     end
 
     def error
       return nil unless complete?
 
-      @raw_result[:response][:error]
-    end
-
-    private
-
-    def find_or_retrieve(block)
-      block ? @client.retrieve_by_uid(@uid) : @client.find_by_uid(@uid)
-    end
-
-    def build_result
-      return nil if @raw_result.nil?
-      return :pending if @raw_result[:pending]
-      return nil unless @raw_result[:response]
-
-      response = @raw_result[:response]
-      new_result(response)
-    end
-
-    def new_result(response)
-      # XXX: Any changes to this structure need to be reflected by
-      # `Client#new_result`
-      Result.new(
-        body: response[:body],
-        headers: response[:headers],
-        status: response[:status],
-        success: @raw_result[:response][:success],
-        error: @raw_result[:response][:error],
-        uid: @uid,
-        response_time: @raw_result[:response_time]
-      )
+      @response.error
     end
   end
 end

data/lib/web_fetch/{result.rb → response.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module WebFetch
-  class Result
-    attr_reader :body, :headers, :status, :error, :uid, :response_time
+  class Response
+    attr_reader :request, :body, :headers, :status, :error, :uid, :response_time
 
     def initialize(options = {})
       @pending = options.fetch(:pending, false)
@@ -11,6 +11,7 @@ module WebFetch
       @body = options.fetch(:body)
       @headers = options.fetch(:headers)
       @status = options.fetch(:status)
+      @request = Request.from_hash(options.fetch(:request))
       @success = options.fetch(:success)
       @error = options.fetch(:error)
       @uid = options.fetch(:uid)
@@ -18,6 +19,8 @@ module WebFetch
     end
 
     def pending?
+      return false if @pending.nil?
+
       @pending
     end
 

data/lib/web_fetch/server.rb

@@ -32,6 +32,7 @@ module WebFetch
         http = request_async(target)
         request = { uid: target[:uid],
                     start_time: target[:start_time],
+                    request: target[:request],
                     deferred: http }
         apply_callbacks(request)
         @storage.store(target[:uid], request)

data/lib/web_fetch/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module WebFetch
-  VERSION = '0.3.1'
+  VERSION = '0.4.0'
 end

data/spec/client_spec.rb

@@ -33,10 +33,11 @@ describe WebFetch::Client do
     end
 
     it 'makes `gather` requests to a running server' do
-      result = client.gather([web_request])
-      expect(result.first).to be_a WebFetch::Promise
-      expect(result.first.uid).to_not be_nil
-      expect(result.first.custom).to eql(my_key: 'my_value')
+      response = client.gather([web_request])
+      expect(response.first).to be_a WebFetch::Promise
+      expect(response.first.uid).to_not be_nil
+      expect(response.first.custom).to eql(my_key: 'my_value')
+      expect(response.first.request).to be_a WebFetch::Request
     end
 
     it 'passes any WebFetch server errors back to the user' do
@@ -62,7 +63,7 @@ describe WebFetch::Client do
 
     subject { client.fetch(responses.first.uid) }
 
-    it { is_expected.to be_a WebFetch::Result }
+    it { is_expected.to be_a WebFetch::Response }
 
     context 'no matching request found' do
       subject { proc { client.fetch('not-found') } }
@@ -75,8 +76,8 @@ describe WebFetch::Client do
 
   describe '#retrieve_by_uid' do
     it 'retrieves a gathered item' do
-      result = client.gather([{ url: 'http://blah.blah/success' }])
-      uid = result.first.uid
+      response = client.gather([{ url: 'http://blah.blah/success' }])
+      uid = response.first.uid
 
       retrieved = client.retrieve_by_uid(uid)
       expect(retrieved[:response][:status]).to eql 200
@@ -96,8 +97,8 @@ describe WebFetch::Client do
   describe '#find_by_uid' do
     it 'returns a ready status when has been fetched' do
       pending 'Find a good way to create a slow response without locking EM'
-      result = client.gather([{ url: 'http://blah.blah/slow_success' }])
-      uid = result.first[:uid]
+      response = client.gather([{ url: 'http://blah.blah/slow_success' }])
+      uid = response.first[:uid]
 
       found = client.find_by_uid(uid)
       expect(found[:pending]).to be true

data/spec/gatherer_spec.rb

@@ -50,9 +50,9 @@ describe WebFetch::Gatherer do
 
   describe '#start' do
     it 'returns a hash containing sha1 hashes of requests' do
-      result = described_class.new(server, valid_params).start
+      response = described_class.new(server, valid_params).start
       hash = Digest::SHA1.new.digest(JSON.dump(valid_params[:requests].first))
-      expect(result[:requests].first[:hash]).to eql Digest.hexencode(hash)
+      expect(response[:requests].first[:hash]).to eql Digest.hexencode(hash)
     end
 
     it 'respects url, headers, http method and query when calculating sha1' do
@@ -67,17 +67,17 @@ describe WebFetch::Gatherer do
       req5 = { url: 'http://blah', query_string: 'a=1',
                headers: { 'Content-Type' => 'hello' },
                method: 'PUT' }
-      results = [req1, req2, req3, req4, req5].map do |req|
+      responses = [req1, req2, req3, req4, req5].map do |req|
         described_class.new(server, requests: [req], _server: server).start
       end
-      hashes = results.map { |res| res[:requests].first[:hash] }
+      hashes = responses.map { |res| res[:requests].first[:hash] }
       expect(hashes.uniq.length).to eql 5
     end
 
     it 'returns a hash containing unique IDs for requests' do
-      result = described_class.new(server, valid_params).start
-      uid1 = result[:requests][0][:uid]
-      uid2 = result[:requests][1][:uid]
+      response = described_class.new(server, valid_params).start
+      uid1 = response[:requests][0][:uid]
+      uid2 = response[:requests][1][:uid]
       expect(uid1).to_not eql uid2
     end
 
@@ -87,8 +87,8 @@ describe WebFetch::Gatherer do
         # the uid of the delegated request
         params = { requests: [url: '-', bob: 'hello'],
                    _server: server }
-        result = described_class.new(server, params).start
-        expect(result[:requests].first[:request][:bob]).to eql 'hello'
+        response = described_class.new(server, params).start
+        expect(response[:requests].first[:request][:bob]).to eql 'hello'
       end
 
       it 'does not affect request hash' do
@@ -97,12 +97,12 @@ describe WebFetch::Gatherer do
         # otherwise duplicate requests
         params1 = { requests: [url: 'http://blah', bob: 'hello'],
                     _server: server }
-        result1 = described_class.new(server, params1).start
+        response1 = described_class.new(server, params1).start
 
         params2 = { requests: [url: 'http://blah', not_bob: 'good bye'],
                     _server: server }
-        result2 = described_class.new(server, params2).start
-        expect(result1[:requests][0][:hash]).to eql result2[:requests][0][:hash]
+        response2 = described_class.new(server, params2).start
+        expect(response1[:requests][0][:hash]).to eql response2[:requests][0][:hash]
       end
     end
   end

data/spec/promise_spec.rb

@@ -5,37 +5,42 @@ RSpec.describe WebFetch::Promise do
   let(:request) { { url: 'http://blah', custom: { my_key: 'my_value' } } }
   let(:options) { { uid: uid, request: request } }
   let(:client) { WebFetch::Client.new('test-host', 8080) }
-  let(:response) { described_class.new(client, options) }
   let(:retrieve_url) { "http://#{client.host}:#{client.port}/retrieve/#{uid}" }
   let(:find_url) { "http://#{client.host}:#{client.port}/find/#{uid}" }
 
   let(:client_success) do
-    double(retrieve_by_uid: { response: { success: true } })
+    double(fetch: double('success',
+      complete?: true, pending?: false, success?: true, error: nil
+    ))
   end
 
   let(:client_failure) do
-    double(retrieve_by_uid: { response: { success: false, error: 'foo' } })
+    double(fetch: double('failure',
+      complete?: true, pending?: false, success?: false, error: 'foo'
+    ))
   end
 
   let(:client_pending) do
-    double(retrieve_by_uid: { pending: true })
+    double(fetch: double('pending',
+      complete?: false, pending?: true, error: nil
+    ))
   end
 
   let(:client_not_started) do
-    double(retrieve_by_uid: nil)
+    double('not started', fetch: nil)
   end
 
-  subject { response }
+  subject(:promise) { described_class.new(client, options) }
 
   it { is_expected.to be_a described_class }
 
   describe '#fetch' do
     before do
-      stub_request(:get, retrieve_url).to_return(body: {}.to_json)
-      stub_request(:get, find_url).to_return(body: {}.to_json)
+      stub_request(:get, retrieve_url).to_return(body: { request: {} }.to_json)
+      stub_request(:get, find_url).to_return(body: { request: {} }.to_json)
     end
 
-    subject { response.fetch(fetch_options) }
+    subject { promise.fetch(fetch_options) }
 
     context 'blocking call' do
       let(:fetch_options) { { wait: true } }
@@ -48,29 +53,31 @@ RSpec.describe WebFetch::Promise do
     end
 
     context 'default (blocking)' do
-      subject { response.fetch }
+      subject { promise.fetch }
       it { is_expected.to have_requested(:get, retrieve_url) }
     end
   end
 
-  describe '#result' do
+  describe '#response' do
     before do
       stub_request(:get, retrieve_url)
         .to_return(
-          body: { response: { success: true, body: 'abc123' } }.to_json
+          body: {
+            response: { success: true, body: 'abc123' }, request: {}
+          }.to_json
         )
-      response.fetch
+      promise.fetch
     end
 
-    subject { response.result }
-    it { is_expected.to be_a WebFetch::Result }
+    subject { promise.response }
+    it { is_expected.to be_a WebFetch::Response }
     its(:body) { is_expected.to eql 'abc123' }
   end
 
   describe '#complete?, #success?, #pending?, #error' do
-    before { response.fetch }
+    before { promise.fetch }
 
-    subject { response }
+    subject { promise }
 
     context 'request succeeded' do
       let(:client) { client_success }
@@ -106,14 +113,14 @@ RSpec.describe WebFetch::Promise do
   end
 
   describe '#request' do
-    subject { response.request }
+    subject { promise.request }
     it { is_expected.to be_a WebFetch::Request }
     its(:custom) { is_expected.to eql(my_key: 'my_value') }
   end
 
   describe '#custom' do
-    # I think it's good to expose this directly on the response even though its
-    # accessible on as `response.request.custom`
+    # I think it's good to expose this directly on the promise even though it's
+    # accessible as `response.request.custom`
     its(:custom) { is_expected.to eql(my_key: 'my_value') }
   end
 end

data/spec/resources_spec.rb

@@ -11,47 +11,47 @@ describe WebFetch::Resources do
   end
 
   describe '.gather' do
-    let(:result) do
+    let(:response) do
       described_class.gather(server, requests: [{ url: 'http://google.com' }])
     end
 
     it 'provides a `gather` resource' do
-      expect(result[:status]).to eql 200
+      expect(response[:status]).to eql 200
     end
 
     it 'responds with hash' do
-      expect(result[:payload]).to be_a Hash
+      expect(response[:payload]).to be_a Hash
     end
   end
 
   describe '.retrieve' do
     it 'gives 404 not found when unrecognised uid requested' do
-      result = described_class.retrieve(server, uid: '123')
-      expect(result[:status]).to eql 404
-      error = result[:payload][:error]
+      response = described_class.retrieve(server, uid: '123')
+      expect(response[:status]).to eql 404
+      error = response[:payload][:error]
       expect(error).to eql I18n.t(:uid_not_found)
     end
 
     it 'gives 404 not found when unrecognised hash requested' do
-      result = described_class.retrieve(server, hash: 'abc')
-      expect(result[:status]).to eql 404
-      error = result[:payload][:error]
+      response = described_class.retrieve(server, hash: 'abc')
+      expect(response[:status]).to eql 404
+      error = response[:payload][:error]
       expect(error).to eql I18n.t(:hash_not_found)
     end
   end
 
   describe '.find' do
     it 'gives 404 not found when unrecognised uid requested' do
-      result = described_class.find(server, uid: '123')
-      expect(result[:status]).to eql 404
-      error = result[:payload][:error]
+      response = described_class.find(server, uid: '123')
+      expect(response[:status]).to eql 404
+      error = response[:payload][:error]
       expect(error).to eql I18n.t(:uid_not_found)
     end
 
     it 'gives 404 not found when unrecognised hash requested' do
-      result = described_class.find(server, hash: 'abc')
-      expect(result[:status]).to eql 404
-      error = result[:payload][:error]
+      response = described_class.find(server, hash: 'abc')
+      expect(response[:status]).to eql 404
+      error = response[:payload][:error]
       expect(error).to eql I18n.t(:hash_not_found)
     end
   end

data/spec/{result_spec.rb → response_spec.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-RSpec.describe WebFetch::Result do
-  let(:result) do
+RSpec.describe WebFetch::Response do
+  let(:response) do
     described_class.new(
       body: 'abc123',
       headers: { 'Foo' => 'Bar' },
@@ -9,12 +9,13 @@ RSpec.describe WebFetch::Result do
       pending: false,
       success: false,
       error: 'foo error happened',
+      request: { url: 'http://blah/' },
       uid: 'uid123',
       response_time: 123.45
     )
   end
 
-  subject { result }
+  subject { response }
 
   it { is_expected.to be_a described_class }
   its(:body) { is_expected.to eql 'abc123' }
@@ -26,4 +27,10 @@ RSpec.describe WebFetch::Result do
   its(:error) { is_expected.to eql 'foo error happened' }
   its(:uid) { is_expected.to eql 'uid123' }
   its(:response_time) { is_expected.to eql 123.45 }
+  its(:request) { is_expected.to be_a WebFetch::Request }
+
+  describe '#request' do
+    subject { response.request }
+    its(:url) { is_expected.to eql 'http://blah/' }
+  end
 end

data/spec/router_spec.rb

@@ -38,11 +38,11 @@ describe WebFetch::Router do
     end
 
     it 'returns appropriate response when invaid json provided' do
-      result = router.route('/gather',
+      response = router.route('/gather',
                             method: 'POST',
                             query_string: 'json=uh oh :(',
                             server: nil)
-      expect(result).to eql(status: 400, payload: I18n.t(:bad_json))
+      expect(response).to eql(status: 400, payload: I18n.t(:bad_json))
     end
   end
 end

data/web_fetch.gemspec

@@ -34,6 +34,7 @@ Gem::Specification.new do |s|
   s.add_dependency 'subprocess', '~> 1.3'
 
   s.add_development_dependency 'byebug', '~> 9.0'
+  s.add_development_dependency 'rake', '~> 12.3'
   s.add_development_dependency 'rspec', '~> 3.5'
   s.add_development_dependency 'rspec-its', '~> 1.2'
   s.add_development_dependency 'rubocop', '~> 0.59.2'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: web_fetch
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Bob Farrell
@@ -192,6 +192,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -262,7 +276,9 @@ files:
 - ".ruby-version"
 - Gemfile
 - LICENSE
+- Makefile
 - README.md
+- Rakefile
 - TODO
 - bin/rspec
 - bin/rubocop
@@ -287,7 +303,7 @@ files:
 - lib/web_fetch/promise.rb
 - lib/web_fetch/request.rb
 - lib/web_fetch/resources.rb
-- lib/web_fetch/result.rb
+- lib/web_fetch/response.rb
 - lib/web_fetch/retriever.rb
 - lib/web_fetch/router.rb
 - lib/web_fetch/server.rb
@@ -302,7 +318,7 @@ files:
 - spec/promise_spec.rb
 - spec/request_spec.rb
 - spec/resources_spec.rb
-- spec/result_spec.rb
+- spec/response_spec.rb
 - spec/retriever_spec.rb
 - spec/router_spec.rb
 - spec/server_spec.rb