Start factoring out http query building from execution.

Author: beauby

lib/jsonapi/client.rb

@@ -9,17 +9,20 @@ class Client
     def initialize(base_url: nil, headers: {})
       @base_url = base_url
       @headers = {
-        'Content-Type' => 'application/vnd.api+json',
-        'Accept' => 'application/vnd.api+json'
+        :'Content-Type' => 'application/vnd.api+json',
+        :Accept => 'application/vnd.api+json'
       }.merge!(headers)
     end
 
     def [](endpoint)
       request(@base_url, endpoint)
     end
 
-    def request(base_url, endpoint, headers = {})
-      Request.new(base_url, endpoint, @headers.merge(headers))
+    def request(base_url, endpoint)
+      req = Request.new(base_url, endpoint)
+      req.headers(@headers) if @headers.any?
+
+      req
     end
   end
 end

lib/jsonapi/client/request.rb

@@ -6,90 +6,104 @@
 module JSONAPI
   class Client
     class Request
-      METHOD_CLASS = {
-        get: Net::HTTP::Get,
-        post: Net::HTTP::Post,
-        patch: Net::HTTP::Patch,
-        delete: Net::HTTP::Delete
-      }.freeze
-
-      def initialize(base_url, endpoint, headers)
+      def initialize(base_url, endpoint = nil)
         @base_url = base_url
         @endpoint = endpoint
-        @params = []
-        @headers = headers
+        @params = {}
+        @headers = {}
       end
 
       def list
-        request(:get, uri)
-      end
-
-      def request(method, uri, data = {})
-        uri = URI(uri)
-        req = METHOD_CLASS[method].new(uri, @headers)
-        req.body = data if data
-
-        http_res = Net::HTTP.start(uri.host, uri.port) do |http|
-          http.request(req)
-        end
-
-        Response.new(http_res)
+        @method = :get
+        @uri = uri
+        self
       end
 
       def find(id)
-        request(:get, uri(id))
+        @method = :get
+        @uri = uri(id)
+        self
       end
 
       def create(hash)
         hash[:type] ||= @endpoint
-        request(:post, uri, hash)
+        @method = :post
+        @uri = uri
+        @data = hash
+        self
       end
 
       def update(id, hash)
         hash[:type] ||= @endpoint
-        request(:patch, uri(id), hash)
+        @method = :patch
+        @uri = uri(id)
+        @data = hash
+        self
       end
 
       def delete(id)
-        request(:delete, uri(id))
+        @method = :delete
+        @uri = uri(id)
+        self
       end
 
-      def headers(hash)
-        @params.merge!(hash)
+      def include(hash)
+        include = JSONAPI::IncludeDirective.new(hash).to_string
+        @params[:include] = include
         self
       end
 
-      def params(hash)
-        @params <<
-          if hash.is_a?(String)
-            hash
-          elsif hash.is_a?(Hash)
-            hash.map { |k, v| "#{k}=#{v}" }
-          end
+      def fields(hash)
+        hash = { @endpoint => hash } if hash.is_a?(Array)
+        hash.each do |k, v|
+          @params["fields[#{k}]".to_sym] = v.join(',')
+        end
         self
       end
 
-      def include(hash)
-        include = JSONAPI::IncludeDirective.new(hash).to_string
-        @params << "include=#{include}"
+      def params(hash)
+        @params.merge!(hash)
         self
       end
 
-      def fields(hash)
-        hash = { @endpoint => hash } if hash.is_a?(Array)
-        @params += hash.map { |k, v| "fields[#{k}]=#{v.join(',')}" }
+      def headers(hash)
+        @headers.merge!(hash)
         self
       end
 
+      def to_h
+        {
+          method: @method,
+          uri: full_uri,
+          base_uri: @uri,
+          data: @data,
+          params: @params,
+          headers: @headers
+        }
+      end
+
       private
 
+      def query
+        @params.map { |k, v| "#{k}=#{v}" }.join('&')
+      end
+
       def uri(id = nil)
-        uri = "#{@base_url}/#{@endpoint}"
+        uri = @base_url
+        uri += "/#{@endpoint}" unless @endpoint.nil?
         uri += "/#{id}" if id
-        uri += "?#{@params.join('&')}" if @params.any?
 
         uri
       end
+
+      def full_uri
+        full_uri = @uri
+        query.tap do |q|
+          full_uri += "?#{q}" unless q.empty?
+        end
+
+        full_uri
+      end
     end
   end
 end