carwow-json_api_client 1.19.0

data/lib/json_api_client/middleware.rb

@@ -0,0 +1,7 @@
+module JsonApiClient
+  module Middleware
+    autoload :JsonRequest, 'json_api_client/middleware/json_request'
+    autoload :ParseJson, 'json_api_client/middleware/parse_json'
+    autoload :Status, 'json_api_client/middleware/status'
+  end
+end

data/lib/json_api_client/middleware/json_request.rb

@@ -0,0 +1,26 @@
+module JsonApiClient
+  module Middleware
+    class JsonRequest < Faraday::Middleware
+      def call(environment)
+        accept_header = update_accept_header(environment[:request_headers])
+
+        environment[:request_headers]["Content-Type"] = 'application/vnd.api+json'
+        environment[:request_headers]["Accept"] = accept_header
+        @app.call(environment)
+      end
+
+      private
+
+      def update_accept_header(headers)
+        return 'application/vnd.api+json' if headers["Accept"].nil?
+        accept_params = headers["Accept"].split(",")
+
+        unless accept_params.include?('application/vnd.api+json')
+          accept_params.unshift('application/vnd.api+json')
+        end
+
+        accept_params.join(",")
+      end
+    end
+  end
+end

data/lib/json_api_client/middleware/parse_json.rb

@@ -0,0 +1,31 @@
+module JsonApiClient
+  module Middleware
+    class ParseJson < Faraday::Middleware
+
+      def call(environment)
+        @app.call(environment).on_complete do |env|
+          if process_response_type?(response_type(env))
+            env[:raw_body] = env[:body]
+            env[:body] = parse(env[:body])
+          end
+        end
+      end
+
+      private
+
+      def parse(body)
+        ::JSON.parse(body) unless body.strip.empty?
+      end
+
+      def response_type(env)
+        type = env[:response_headers]['Content-Type'].to_s
+        type = type.split(';', 2).first if type.index(';')
+        type
+      end
+
+      def process_response_type?(type)
+        !!type.match(/\bjson$/)
+      end
+    end
+  end
+end

data/lib/json_api_client/middleware/status.rb

@@ -0,0 +1,67 @@
+module JsonApiClient
+  module Middleware
+    class Status < Faraday::Middleware
+      def initialize(app, options)
+        super(app)
+        @options = options
+      end
+
+      def call(environment)
+        @app.call(environment).on_complete do |env|
+          handle_status(env[:status], env)
+
+          # look for meta[:status]
+          if env[:body].is_a?(Hash)
+            code = env[:body].fetch("meta", {}).fetch("status", 200).to_i
+            handle_status(code, env)
+          end
+        end
+      rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e
+        raise Errors::ConnectionError.new environment, e.to_s
+      end
+
+      private
+
+      def custom_handler_for(code)
+        @options.fetch(:custom_handlers, {})[code]
+      end
+
+      def handle_status(code, env)
+        custom_handler = custom_handler_for(code)
+        return custom_handler.call(env) if custom_handler.present?
+
+        case code
+        when 200..399
+        when 401
+          raise Errors::NotAuthorized, env
+        when 403
+          raise Errors::AccessDenied, env
+        when 404
+          raise Errors::NotFound, env[:url]
+        when 408
+          raise Errors::RequestTimeout, env
+        when 409
+          raise Errors::Conflict, env
+        when 422
+          # Allow to proceed as resource errors will be populated
+        when 429
+          raise Errors::TooManyRequests, env
+        when 400..499
+          raise Errors::ClientError, env
+        when 500
+          raise Errors::InternalServerError, env
+        when 502
+          raise Errors::BadGateway, env
+        when 503
+          raise Errors::ServiceUnavailable, env
+        when 504
+          raise Errors::GatewayTimeout, env
+        when 501..599
+          raise Errors::ServerError, env
+        else
+          raise Errors::UnexpectedStatus.new(code, env[:url])
+        end
+      end
+    end
+  end
+end

data/lib/json_api_client/paginating.rb

@@ -0,0 +1,6 @@
+module JsonApiClient
+  module Paginating
+    autoload :Paginator, 'json_api_client/paginating/paginator'
+    autoload :NestedParamPaginator, 'json_api_client/paginating/nested_param_paginator'
+  end
+end

data/lib/json_api_client/paginating/nested_param_paginator.rb

@@ -0,0 +1,140 @@
+module JsonApiClient
+  module Paginating
+    # An alternate, more consistent Paginator that always wraps
+    # pagination query string params in a top-level wrapper_name,
+    # e.g. page[offset]=2, page[limit]=10.
+    class NestedParamPaginator
+      DEFAULT_WRAPPER_NAME = "page".freeze
+      DEFAULT_PAGE_PARAM = "page".freeze
+      DEFAULT_PER_PAGE_PARAM = "per_page".freeze
+
+      # Define class accessors as methods to enforce standard way
+      # of defining pagination related query string params.
+      class << self
+
+        def wrapper_name
+          @_wrapper_name ||= DEFAULT_WRAPPER_NAME
+        end
+
+        def wrapper_name=(param = DEFAULT_WRAPPER_NAME)
+          raise ArgumentError, "don't wrap wrapper_name" unless valid_param?(param)
+
+          @_wrapper_name = param.to_s
+        end
+
+        def page_param
+          @_page_param ||= DEFAULT_PAGE_PARAM
+          "#{wrapper_name}[#{@_page_param}]"
+        end
+
+        def page_param=(param = DEFAULT_PAGE_PARAM)
+          raise ArgumentError, "don't wrap page_param" unless valid_param?(param)
+
+          @_page_param = param.to_s
+        end
+
+        def per_page_param
+          @_per_page_param ||= DEFAULT_PER_PAGE_PARAM
+          "#{wrapper_name}[#{@_per_page_param}]"
+        end
+
+        def per_page_param=(param = DEFAULT_PER_PAGE_PARAM)
+          raise ArgumentError, "don't wrap per_page_param" unless valid_param?(param)
+
+          @_per_page_param = param
+        end
+
+        private
+
+        def valid_param?(param)
+          !(param.nil? || param.to_s.include?("[") || param.to_s.include?("]"))
+        end
+
+      end
+
+      attr_reader :params, :result_set, :links
+
+      def initialize(result_set, data)
+        @params = params_for_uri(result_set.uri)
+        @result_set = result_set
+        @links = data["links"]
+      end
+
+      def next
+        result_set.links.fetch_link("next")
+      end
+
+      def prev
+        result_set.links.fetch_link("prev")
+      end
+
+      def first
+        result_set.links.fetch_link("first")
+      end
+
+      def last
+        result_set.links.fetch_link("last")
+      end
+
+      def total_pages
+        if links["last"]
+          uri = result_set.links.link_url_for("last")
+          last_params = params_for_uri(uri)
+          last_params.fetch(page_param, &method(:current_page)).to_i
+        else
+          current_page
+        end
+      end
+
+      # this is an estimate, not necessarily an exact count
+      def total_entries
+        per_page * total_pages
+      end
+      def total_count; total_entries; end
+
+      def offset
+        per_page * (current_page - 1)
+      end
+
+      def per_page
+        params.fetch(per_page_param) do
+          result_set.length
+        end.to_i
+      end
+
+      def current_page
+        params.fetch(page_param, 1).to_i
+      end
+
+      def out_of_bounds?
+        current_page > total_pages
+      end
+
+      def previous_page
+        current_page > 1 ? (current_page - 1) : nil
+      end
+
+      def next_page
+        current_page < total_pages ? (current_page + 1) : nil
+      end
+
+      def page_param
+        self.class.page_param
+      end
+
+      def per_page_param
+        self.class.per_page_param
+      end
+
+      alias limit_value per_page
+
+      protected
+
+      def params_for_uri(uri)
+        return {} unless uri
+        uri = Addressable::URI.parse(uri)
+        ( uri.query_values || {} ).with_indifferent_access
+      end
+    end
+  end
+end

data/lib/json_api_client/paginating/paginator.rb

@@ -0,0 +1,89 @@
+module JsonApiClient
+  module Paginating
+    class Paginator
+      class_attribute :page_param,
+                      :per_page_param
+
+      self.page_param = "page"
+      self.per_page_param = "per_page"
+
+      attr_reader :params, :result_set, :links
+
+      def initialize(result_set, data)
+        @params = params_for_uri(result_set.uri)
+        @result_set = result_set
+        @links = data["links"]
+      end
+
+      def next
+        result_set.links.fetch_link("next")
+      end
+
+      def prev
+        result_set.links.fetch_link("prev")
+      end
+
+      def first
+        result_set.links.fetch_link("first")
+      end
+
+      def last
+        result_set.links.fetch_link("last")
+      end
+
+      def total_pages
+        if links["last"]
+          uri = result_set.links.link_url_for("last")
+          last_params = params_for_uri(uri)
+          last_params.fetch(page_param) do
+            current_page
+          end.to_i
+        else
+          current_page
+        end
+      end
+
+      # this number may be off
+      def total_entries
+        per_page * total_pages
+      end
+      def total_count; total_entries; end
+
+      def offset
+        per_page * (current_page - 1)
+      end
+
+      def per_page
+        params.fetch(per_page_param) do
+          result_set.length
+        end.to_i
+      end
+
+      def current_page
+        params.fetch(page_param, 1).to_i
+      end
+
+      def out_of_bounds?
+        current_page > total_pages
+      end
+
+      def previous_page
+        current_page > 1 ? (current_page - 1) : nil
+      end
+
+      def next_page
+        current_page < total_pages ? (current_page + 1) : nil
+      end
+
+      alias limit_value per_page
+
+      protected
+
+      def params_for_uri(uri)
+        return {} unless uri
+        uri = Addressable::URI.parse(uri)
+        ( uri.query_values || {} ).with_indifferent_access
+      end
+    end
+  end
+end

data/lib/json_api_client/parsers.rb

@@ -0,0 +1,5 @@
+module JsonApiClient
+  module Parsers
+    autoload :Parser, 'json_api_client/parsers/parser'
+  end
+end

data/lib/json_api_client/parsers/parser.rb

@@ -0,0 +1,102 @@
+module JsonApiClient
+  module Parsers
+    class Parser
+      class << self
+        def parse(klass, response)
+          data = response.body.present? ? response.body : {}
+
+          ResultSet.new.tap do |result_set|
+            result_set.record_class = klass
+            result_set.uri = response.env[:url]
+            handle_json_api(result_set, data)
+            handle_data(result_set, data)
+            handle_errors(result_set, data)
+            handle_meta(result_set, data)
+            handle_links(result_set, data)
+            handle_relationships(result_set, data)
+            handle_pagination(result_set, data)
+            handle_included(result_set, data)
+          end
+        end
+
+        #
+        # Given a resource hash, returns a Resource.new friendly hash
+        # which flattens the attributes in w/ id and type.
+        #
+        # Example:
+        #
+        # Given:
+        #  {
+        #    id: 1.
+        #    type: 'person',
+        #    attributes: {
+        #      first_name: 'Jeff',
+        #      last_name: 'Ching'
+        #    },
+        #    links: {...},
+        #    relationships: {...}
+        #  }
+        #
+        # Returns:
+        #  {
+        #    id: 1,
+        #    type: 'person',
+        #    first_name: 'Jeff',
+        #    last_name: 'Ching'
+        #    links: {...},
+        #    relationships: {...}
+        #  }
+        #
+        #
+        def parameters_from_resource(params)
+          attrs = params.slice('id', 'links', 'meta', 'type', 'relationships')
+          attrs.merge(params.fetch('attributes', {}))
+        end
+
+        private
+
+        def handle_json_api(result_set, data)
+          result_set.implementation = Implementation.new(data.fetch("jsonapi", {}))
+        end
+
+        def handle_data(result_set, data)
+          # all data lives under the "data" attribute
+          results = data.fetch("data", [])
+
+          # we will treat everything as an Array
+          results = [results] unless results.is_a?(Array)
+          resources = results.compact.map do |res|
+            resource = result_set.record_class.load(parameters_from_resource(res))
+            resource.last_result_set = result_set
+            resource
+          end
+          result_set.concat(resources)
+        end
+
+        def handle_errors(result_set, data)
+          result_set.errors = ErrorCollector.new(data.fetch("errors", []))
+        end
+
+        def handle_meta(result_set, data)
+          result_set.meta = MetaData.new(data.fetch("meta", {}), result_set.record_class)
+        end
+
+        def handle_links(result_set, data)
+          result_set.links = Linking::TopLevelLinks.new(result_set.record_class, data.fetch("links", {}))
+        end
+
+        def handle_relationships(result_set, data)
+          result_set.relationships = Relationships::TopLevelRelations.new(result_set.record_class, data.fetch("relationships", {}))
+        end
+
+        def handle_pagination(result_set, data)
+          result_set.pages = result_set.record_class.paginator.new(result_set, data)
+        end
+
+        def handle_included(result_set, data)
+          result_set.included = IncludedData.new(result_set, data.fetch("included", []))
+        end
+      end
+    end
+  end
+end