BREAKING: remove compress option

This change removes the `compress` option from the client entirely.

We use the default faraday adapter, which is `net/http` from stdlib. If
you read [the documentation for that module][net-http-docs], you'll come
across this:

> `Net::HTTP` automatically adds Accept-Encoding for compression of
> response bodies and automatically decompresses gzip and deflate
> responses unless a Range header was sent.

In other words, by default, ruby's net/http module will request gzipped
content and automatically uncompress it if that's what the response
contains.

If instead one sets the `Accept-Encoding` header on a request that's
made with `net/http`, that default behavior is ignored and we're left to
deal with unpacking hte response ourselves as was done in the
`FaradayMiddleware` class.

In other words, whether the `compress` option is used or not, the
behavior has been that we're asking for compressed responses and the
option is effectively ignored. I went back to ruby 1.9.2 and the same
behavior existed there. Given that, I'm confident this option has always
been either ignored or redundant.

[net-http-docs]: https://ruby-doc.org/stdlib-3.0.0/libdoc/net/http/rdoc/Net/HTTP.html#class-Net::HTTP-label-Compression

Author: bhornseth

CHANGELOG

@@ -4,6 +4,8 @@ v2.0.0
  - Require minimum version of faraday 2.0
  - Disabled request/response logging by default. Old behavior can be restored
    by setting a new `verbose` configuration option to true
+ - BREAKING: remove `compress` from configuration. gzip compression is now
+   always enabled
 
 v1.6.3
  - Add support for sending end user ip address in request headers

lib/spark_api/configuration.rb

@@ -11,7 +11,7 @@ module Configuration
     # valid configuration options
     VALID_OPTION_KEYS = [:api_key, :api_secret, :api_user, :endpoint,
       :user_agent, :version, :ssl, :ssl_verify, :oauth2_provider, :authentication_mode,
-      :auth_endpoint, :callback, :compress, :timeout, :middleware, :dictionary_version, :request_id_chain, :user_ip_address, :verbose].freeze
+      :auth_endpoint, :callback, :timeout, :middleware, :dictionary_version, :request_id_chain, :user_ip_address, :verbose].freeze
     OAUTH2_KEYS = [:authorization_uri, :access_uri, :client_id, :client_secret,
       # Requirements for authorization_code grant type
       :redirect_uri,  
@@ -41,7 +41,6 @@ module Configuration
     DEFAULT_SSL = true
     DEFAULT_SSL_VERIFY = true
     DEFAULT_OAUTH2 = nil
-    DEFAULT_COMPRESS = false
     DEFAULT_TIMEOUT = 5 # seconds
     DEFAULT_MIDDLEWARE = 'spark_api'
     DEFAULT_DICTIONARY_VERSION = nil
@@ -80,7 +79,6 @@ def reset_configuration
       self.ssl         = DEFAULT_SSL
       self.ssl_verify  = DEFAULT_SSL_VERIFY
       self.version     = DEFAULT_VERSION
-      self.compress    = DEFAULT_COMPRESS
       self.timeout     = DEFAULT_TIMEOUT
       self.middleware = DEFAULT_MIDDLEWARE
       self.dictionary_version = DEFAULT_DICTIONARY_VERSION

lib/spark_api/connection.rb

@@ -10,7 +10,6 @@ module Connection
     HTTP_SCHEME = 'http:'
     HTTPS_SCHEME = 'https:'
     ACCEPT_ENCODING = 'Accept-Encoding'
-    COMPRESS_ACCEPT_ENCODING = 'gzip, deflate'
     X_REQUEST_ID_CHAIN = 'X-Request-Id-Chain'
     MIME_JSON = 'application/json'
     MIME_RESO = 'application/json, application/xml'
@@ -27,10 +26,6 @@ def connection(force_ssl = false)
         opts[:url] = @endpoint.sub REG_HTTPS, HTTP_SCHEME
       end
 
-      if self.compress
-        opts[:headers][ACCEPT_ENCODING] = COMPRESS_ACCEPT_ENCODING
-      end
-
       if request_id_chain
         opts[:headers][X_REQUEST_ID_CHAIN] = request_id_chain
       end

lib/spark_api/faraday_middleware.rb

@@ -15,8 +15,6 @@ def initialize(app)
     # Handles pretty much all the api response parsing and error handling.  All responses that
     # indicate a failure will raise a SparkApi::ClientError exception
     def on_complete(env)
-      env[:body] = decompress_body(env)
-
       body = MultiJson.decode(env[:body])
       if SparkApi.verbose
         SparkApi.logger.debug{ "Response Body: #{body.inspect}" }
@@ -82,18 +80,6 @@ def on_complete(env)
       env[:body] = results
     end
 
-    def decompress_body(env)
-      encoding = env[:response_headers]['content-encoding'].to_s.downcase
-
-      if encoding == 'gzip'
-        env[:body] = Zlib::GzipReader.new(StringIO.new(env[:body])).read
-      elsif encoding == 'deflate'
-        env[:body] = Zlib::Inflate.inflate(env[:body])
-      end
-
-      env[:body]
-    end
-
     private
 
     def http_method_override_request?(env)

lib/spark_api/reso_faraday_middleware.rb

@@ -1,12 +1,7 @@
 
 module SparkApi
-
   class ResoFaradayMiddleware < FaradayMiddleware
-
     def on_complete(env)
-
-      body = decompress_body(env)
-
       begin
         body = MultiJson.decode(body)
 
@@ -21,9 +16,7 @@ def on_complete(env)
         # some minor format verification
         raise e if body.strip[/\A<\?xml/].nil?
       end
-
     end
-
   end
 
   Faraday::Response.register_middleware :reso_api => ResoFaradayMiddleware

spec/unit/spark_api/configuration_spec.rb

@@ -228,12 +228,6 @@
       expect(c.connection.headers["Accept-Encoding"]).to be_nil
     end
 
-    it "should set gzip header if compress option is set" do
-      c = SparkApi::Client.new(:endpoint => "https://api.sparkapi.com",
-        :compress => true) 
-      expect(c.connection.headers["Accept-Encoding"]).to eq("gzip, deflate")
-    end
-
     it "should set default timeout of 5 seconds" do
       c = SparkApi::Client.new(:endpoint => "https://sparkapi.com")
       expect(c.connection.options[:timeout]).to eq(5)

spec/unit/spark_api/faraday_middleware_spec.rb

@@ -97,55 +97,6 @@
         expect(e.errors).to eq("Some errors and stuff.")
       }
     end
-
-  end
-
-  describe "#decompress_body" do
-    let(:middleware) do
-      SparkApi::FaradayMiddleware.new(SparkApi)
-    end
-
-    it "should leave the body along if content-encoding not set" do
-      env = {
-        :body => "UNCOMPRESSED",
-        :response_headers => {}
-      }
-
-      expect(middleware.decompress_body(env)).to eq("UNCOMPRESSED")
-    end
-
-    it "should unzip gzipped data" do
-      bod = "OUTPUT BODY"
-
-      out = StringIO.new
-      gz = Zlib::GzipWriter.new(out)
-      gz.write bod
-      gz.close
-
-      env = {
-        :body => out.string,
-        :response_headers => {
-          'content-encoding' => 'gzip'
-        }
-      }
-
-      expect(middleware.decompress_body(env)).to eq(bod)
-    end
-
-    it "should inflate deflated data" do
-      bod = "INFLATED BODY"
-      deflated_bod = Zlib::Deflate.deflate(bod)
-
-      env = {
-        :body => deflated_bod,
-        :response_headers => {
-          'content-encoding' => 'deflate'
-        }
-      }
-
-      expect(middleware.decompress_body(env)).to eq(bod)
-    end
   end
-  
 end