Place the dot on the line with the receiver

.rubocop.yml

@@ -37,7 +37,7 @@ Style/Documentation:
   Enabled: false
 
 Style/DotPosition:
-  EnforcedStyle: leading
+  EnforcedStyle: trailing
 
 Style/DoubleNegation:
   Enabled: false

lib/http/cache/headers.rb

@@ -69,9 +69,9 @@ def matches?(pattern)
       # ---
       # Some servers send a "Expire: -1" header which must be treated as expired
       def seconds_til_expires
-        get("Expires")
-          .map { |e| http_date_to_ttl(e) }
-          .max
+        get("Expires").
+          map { |e| http_date_to_ttl(e) }.
+          max
       end
 
       def http_date_to_ttl(t_str)
@@ -89,11 +89,11 @@ def to_time_or_epoch(t_str)
 
       # @return [Numeric] the value of the max-age component of cache control
       def explicit_max_age
-        get("Cache-Control")
-          .map { |v| (/max-age=(\d+)/i).match(v) }
-          .compact
-          .map { |m| m[1].to_i }
-          .max
+        get("Cache-Control").
+          map { |v| (/max-age=(\d+)/i).match(v) }.
+          compact.
+          map { |m| m[1].to_i }.
+          max
       end
     end
   end

lib/http/options.rb

@@ -118,9 +118,9 @@ def merge(other)
     end
 
     def to_hash
-      hash_pairs = self.class
-                   .defined_options
-                   .flat_map { |opt_name| [opt_name, self[opt_name]] }
+      hash_pairs = self.class.
+                   defined_options.
+                   flat_map { |opt_name| [opt_name, self[opt_name]] }
       Hash[*hash_pairs]
     end
 

lib/http/request/caching.rb

@@ -80,11 +80,11 @@ def env
       def conditional_headers_for(cached_response)
         headers = HTTP::Headers.new
 
-        cached_response.headers.get("Etag")
-          .each { |etag| headers.add("If-None-Match", etag) }
+        cached_response.headers.get("Etag").
+          each { |etag| headers.add("If-None-Match", etag) }
 
-        cached_response.headers.get("Last-Modified")
-          .each { |last_mod| headers.add("If-Modified-Since", last_mod) }
+        cached_response.headers.get("Last-Modified").
+          each { |last_mod| headers.add("If-Modified-Since", last_mod) }
 
         headers.add("Cache-Control", "max-age=0") if cache_headers.forces_revalidation?
 

lib/http/response/caching.rb

@@ -123,9 +123,9 @@ def vary
 
       # @return [Time] the time at which the server generated this response.
       def server_response_time
-        headers.get("Date")
-          .map(&method(:to_time_or_epoch))
-          .max || begin
+        headers.get("Date").
+          map(&method(:to_time_or_epoch)).
+          max || begin
                     # set it if it is not already set
                     headers["Date"] = received_at.httpdate
                     received_at

spec/lib/http/cache_spec.rb

@@ -6,8 +6,8 @@
     subject { described_class }
 
     it "allows metastore and entitystore" do
-      expect(subject.new(:metastore => "heap:/", :entitystore => "heap:/"))
-        .to be_kind_of HTTP::Cache
+      expect(subject.new(:metastore => "heap:/", :entitystore => "heap:/")).
+        to be_kind_of HTTP::Cache
     end
   end
 
@@ -151,10 +151,10 @@
 
     it "makes request with conditional request headers" do
       subject.perform(request, opts) do |actual_request, _|
-        expect(actual_request.headers["If-None-Match"])
-          .to eq cached_response.headers["Etag"]
-        expect(actual_request.headers["If-Modified-Since"])
-          .to eq cached_response.headers["Last-Modified"]
+        expect(actual_request.headers["If-None-Match"]).
+          to eq cached_response.headers["Etag"]
+        expect(actual_request.headers["If-Modified-Since"]).
+          to eq cached_response.headers["Last-Modified"]
 
         origin_response
       end

spec/lib/http/client_spec.rb

@@ -60,8 +60,8 @@ def simple_response(body, status = 200)
         "http://example.com/" => redirect_response("/")
       )
 
-      expect { client.get("http://example.com/") }
-        .to raise_error(HTTP::Redirector::EndlessRedirectError)
+      expect { client.get("http://example.com/") }.
+        to raise_error(HTTP::Redirector::EndlessRedirectError)
     end
 
     it "fails if max amount of hops reached" do
@@ -75,8 +75,8 @@ def simple_response(body, status = 200)
         "http://example.com/6" => simple_response("OK")
       )
 
-      expect { client.get("http://example.com/") }
-        .to raise_error(HTTP::Redirector::TooManyRedirectsError)
+      expect { client.get("http://example.com/") }.
+        to raise_error(HTTP::Redirector::TooManyRedirectsError)
     end
 
     context "with non-ASCII URLs" do
@@ -103,17 +103,17 @@ def simple_response(body, status = 200)
     it "returns cached responses if they exist" do
       cached_response = simple_response("cached").caching
       StubbedClient.new(:cache =>
-                        HTTP::Cache.new(:metastore => "heap:/", :entitystore => "heap:/"))
-        .stub("http://example.com/#{sn}" => cached_response)
-        .get("http://example.com/#{sn}")
+                        HTTP::Cache.new(:metastore => "heap:/", :entitystore => "heap:/")).
+        stub("http://example.com/#{sn}" => cached_response).
+        get("http://example.com/#{sn}")
 
       # cache is now warm
 
-      client = StubbedClient.new(:cache => HTTP::Cache.new(:metastore => "heap:/", :entitystore => "heap:/"))
-               .stub("http://example.com/#{sn}" => simple_response("OK"))
+      client = StubbedClient.new(:cache => HTTP::Cache.new(:metastore => "heap:/", :entitystore => "heap:/")).
+               stub("http://example.com/#{sn}" => simple_response("OK"))
 
-      expect(client.get("http://example.com/#{sn}").body.to_s)
-        .to eq cached_response.body.to_s
+      expect(client.get("http://example.com/#{sn}").body.to_s).
+        to eq cached_response.body.to_s
     end
   end
 
@@ -226,8 +226,8 @@ def simple_response(body, status = 200)
     end
 
     it "fails with OpenSSL::SSL::SSLError if host mismatch" do
-      expect { client.get(dummy_ssl.endpoint.gsub("127.0.0.1", "localhost")) }
-        .to raise_error(OpenSSL::SSL::SSLError, /does not match/)
+      expect { client.get(dummy_ssl.endpoint.gsub("127.0.0.1", "localhost")) }.
+        to raise_error(OpenSSL::SSL::SSLError, /does not match/)
     end
 
     context "with SSL options instead of a context" do

spec/lib/http/headers_spec.rb

@@ -29,13 +29,13 @@
     end
 
     it "fails with empty header name" do
-      expect { headers.set "", "foo bar" }
-        .to raise_error HTTP::InvalidHeaderNameError
+      expect { headers.set "", "foo bar" }.
+        to raise_error HTTP::InvalidHeaderNameError
     end
 
     it "fails with invalid header name" do
-      expect { headers.set "foo bar", "baz" }
-        .to raise_error HTTP::InvalidHeaderNameError
+      expect { headers.set "foo bar", "baz" }.
+        to raise_error HTTP::InvalidHeaderNameError
     end
   end
 
@@ -77,13 +77,13 @@
     end
 
     it "fails with empty header name" do
-      expect { headers.delete "" }
-        .to raise_error HTTP::InvalidHeaderNameError
+      expect { headers.delete "" }.
+        to raise_error HTTP::InvalidHeaderNameError
     end
 
     it "fails with invalid header name" do
-      expect { headers.delete "foo bar" }
-        .to raise_error HTTP::InvalidHeaderNameError
+      expect { headers.delete "foo bar" }.
+        to raise_error HTTP::InvalidHeaderNameError
     end
   end
 
@@ -111,13 +111,13 @@
     end
 
     it "fails with empty header name" do
-      expect { headers.add "", "foobar" }
-        .to raise_error HTTP::InvalidHeaderNameError
+      expect { headers.add "", "foobar" }.
+        to raise_error HTTP::InvalidHeaderNameError
     end
 
     it "fails with invalid header name" do
-      expect { headers.add "foo bar", "baz" }
-        .to raise_error HTTP::InvalidHeaderNameError
+      expect { headers.add "foo bar", "baz" }.
+        to raise_error HTTP::InvalidHeaderNameError
     end
   end
 
@@ -139,13 +139,13 @@
     end
 
     it "fails with empty header name" do
-      expect { headers.get "" }
-        .to raise_error HTTP::InvalidHeaderNameError
+      expect { headers.get "" }.
+        to raise_error HTTP::InvalidHeaderNameError
     end
 
     it "fails with invalid header name" do
-      expect { headers.get "foo bar" }
-        .to raise_error HTTP::InvalidHeaderNameError
+      expect { headers.get "foo bar" }.
+        to raise_error HTTP::InvalidHeaderNameError
     end
   end
 

spec/lib/http/redirector_spec.rb

@@ -33,24 +33,24 @@ def redirect_response(status, location)
       req = HTTP::Request.new :head, "http://example.com"
       res = proc { |prev_req| redirect_response(301, "#{prev_req.uri}/1") }
 
-      expect { redirector.perform(req, res.call(req), &res) }
-        .to raise_error HTTP::Redirector::TooManyRedirectsError
+      expect { redirector.perform(req, res.call(req), &res) }.
+        to raise_error HTTP::Redirector::TooManyRedirectsError
     end
 
     it "fails with EndlessRedirectError if endless loop detected" do
       req = HTTP::Request.new :head, "http://example.com"
       res = redirect_response(301, req.uri)
 
-      expect { redirector.perform(req, res) { res } }
-        .to raise_error HTTP::Redirector::EndlessRedirectError
+      expect { redirector.perform(req, res) { res } }.
+        to raise_error HTTP::Redirector::EndlessRedirectError
     end
 
     it "fails with StateError if there were no Location header" do
       req = HTTP::Request.new :head, "http://example.com"
       res = simple_response(301)
 
-      expect { |b| redirector.perform(req, res, &b) }
-        .to raise_error HTTP::StateError
+      expect { |b| redirector.perform(req, res, &b) }.
+        to raise_error HTTP::StateError
     end
 
     it "returns first non-redirect response" do
@@ -86,24 +86,24 @@ def redirect_response(status, location)
           req = HTTP::Request.new :put, "http://example.com"
           res = redirect_response 300, "http://example.com/1"
 
-          expect { redirector.perform(req, res) { simple_response 200 } }
-            .to raise_error HTTP::StateError
+          expect { redirector.perform(req, res) { simple_response 200 } }.
+            to raise_error HTTP::StateError
         end
 
         it "raises StateError if original request was POST" do
           req = HTTP::Request.new :post, "http://example.com"
           res = redirect_response 300, "http://example.com/1"
 
-          expect { redirector.perform(req, res) { simple_response 200 } }
-            .to raise_error HTTP::StateError
+          expect { redirector.perform(req, res) { simple_response 200 } }.
+            to raise_error HTTP::StateError
         end
 
         it "raises StateError if original request was DELETE" do
           req = HTTP::Request.new :delete, "http://example.com"
           res = redirect_response 300, "http://example.com/1"
 
-          expect { redirector.perform(req, res) { simple_response 200 } }
-            .to raise_error HTTP::StateError
+          expect { redirector.perform(req, res) { simple_response 200 } }.
+            to raise_error HTTP::StateError
         end
       end
 
@@ -170,24 +170,24 @@ def redirect_response(status, location)
           req = HTTP::Request.new :put, "http://example.com"
           res = redirect_response 301, "http://example.com/1"
 
-          expect { redirector.perform(req, res) { simple_response 200 } }
-            .to raise_error HTTP::StateError
+          expect { redirector.perform(req, res) { simple_response 200 } }.
+            to raise_error HTTP::StateError
         end
 
         it "raises StateError if original request was POST" do
           req = HTTP::Request.new :post, "http://example.com"
           res = redirect_response 301, "http://example.com/1"
 
-          expect { redirector.perform(req, res) { simple_response 200 } }
-            .to raise_error HTTP::StateError
+          expect { redirector.perform(req, res) { simple_response 200 } }.
+            to raise_error HTTP::StateError
         end
 
         it "raises StateError if original request was DELETE" do
           req = HTTP::Request.new :delete, "http://example.com"
           res = redirect_response 301, "http://example.com/1"
 
-          expect { redirector.perform(req, res) { simple_response 200 } }
-            .to raise_error HTTP::StateError
+          expect { redirector.perform(req, res) { simple_response 200 } }.
+            to raise_error HTTP::StateError
         end
       end
 
@@ -254,24 +254,24 @@ def redirect_response(status, location)
           req = HTTP::Request.new :put, "http://example.com"
           res = redirect_response 302, "http://example.com/1"
 
-          expect { redirector.perform(req, res) { simple_response 200 } }
-            .to raise_error HTTP::StateError
+          expect { redirector.perform(req, res) { simple_response 200 } }.
+            to raise_error HTTP::StateError
         end
 
         it "raises StateError if original request was POST" do
           req = HTTP::Request.new :post, "http://example.com"
           res = redirect_response 302, "http://example.com/1"
 
-          expect { redirector.perform(req, res) { simple_response 200 } }
-            .to raise_error HTTP::StateError
+          expect { redirector.perform(req, res) { simple_response 200 } }.
+            to raise_error HTTP::StateError
         end
 
         it "raises StateError if original request was DELETE" do
           req = HTTP::Request.new :delete, "http://example.com"
           res = redirect_response 302, "http://example.com/1"
 
-          expect { redirector.perform(req, res) { simple_response 200 } }
-            .to raise_error HTTP::StateError
+          expect { redirector.perform(req, res) { simple_response 200 } }.
+            to raise_error HTTP::StateError
         end
       end
 

spec/lib/http/response_spec.rb

@@ -105,8 +105,8 @@
       body      = double :to_s => "foobar"
       response  = HTTP::Response.new(200, "1.1", headers, body)
 
-      expect(response.inspect)
-        .to eq '#<HTTP::Response/1.1 200 OK {"Content-Type"=>"text/plain"}>'
+      expect(response.inspect).
+        to eq '#<HTTP::Response/1.1 200 OK {"Content-Type"=>"text/plain"}>'
     end
   end
 

spec/lib/http_spec.rb

@@ -185,8 +185,8 @@
 
     it "sets Authorization header with proper BasicAuth value" do
       client = HTTP.basic_auth :user => "foo", :pass => "bar"
-      expect(client.default_headers[:authorization])
-        .to match(%r{^Basic [A-Za-z0-9+/]+=*$})
+      expect(client.default_headers[:authorization]).
+        to match(%r{^Basic [A-Za-z0-9+/]+=*$})
     end
   end
 

spec/support/http_handling_shared.rb

@@ -82,8 +82,8 @@
       end
 
       it "errors if reading takes too long" do
-        expect { client.get("#{server.endpoint}/sleep").body.to_s }
-          .to raise_error(HTTP::TimeoutError, /Timed out/)
+        expect { client.get("#{server.endpoint}/sleep").body.to_s }.
+          to raise_error(HTTP::TimeoutError, /Timed out/)
       end
     end
   end