json_api_client 1.23.0 → 1.24.0

data/lib/json_api_client/paginating/nested_param_paginator.rb

@@ -1,140 +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
+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

@@ -1,89 +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
+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/paginating.rb

@@ -1,6 +1,6 @@
-module JsonApiClient
-  module Paginating
-    autoload :Paginator, 'json_api_client/paginating/paginator'
-    autoload :NestedParamPaginator, 'json_api_client/paginating/nested_param_paginator'
-  end
-end
+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/parsers/parser.rb

@@ -1,102 +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
+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