json_api_client 1.5.2 → 1.22.0

data/lib/json_api_client/helpers/associatable.rb

@@ -0,0 +1,88 @@
+module JsonApiClient
+  module Helpers
+    module Associatable
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :associations, instance_accessor: false
+        self.associations = []
+        attr_accessor :__cached_associations
+        attr_accessor :__belongs_to_params
+      end
+
+      module ClassMethods
+        def _define_association(attr_name, association_klass, options = {})
+          attr_name = attr_name.to_sym
+          association = association_klass.new(attr_name, self, options)
+          self.associations += [association]
+        end
+
+        def _define_relationship_methods(attr_name)
+          attr_name = attr_name.to_sym
+
+          define_method(attr_name) do
+            _cached_relationship(attr_name) do
+              relationship_definition = relationship_definition_for(attr_name)
+              return unless relationship_definition
+              relationship_data_for(attr_name, relationship_definition)
+            end
+          end
+
+          define_method("#{attr_name}=") do |value|
+            _clear_cached_relationship(attr_name)
+            relationships.public_send("#{attr_name}=", value)
+          end
+        end
+
+        def belongs_to(attr_name, options = {})
+          _define_association(attr_name, JsonApiClient::Associations::BelongsTo::Association, options)
+
+          param = associations.last.param
+          define_method(param) do
+            _belongs_to_params[param]
+          end
+
+          define_method(:"#{param}=") do |value|
+            _belongs_to_params[param] = value
+          end
+        end
+
+        def has_many(attr_name, options = {})
+          _define_association(attr_name, JsonApiClient::Associations::HasMany::Association, options)
+          _define_relationship_methods(attr_name)
+        end
+
+        def has_one(attr_name, options = {})
+          _define_association(attr_name, JsonApiClient::Associations::HasOne::Association, options)
+          _define_relationship_methods(attr_name)
+        end
+      end
+
+      def _belongs_to_params
+        self.__belongs_to_params ||= {}
+      end
+
+      def _clear_belongs_to_params
+        self.__belongs_to_params = {}
+      end
+
+      def _cached_associations
+        self.__cached_associations ||= {}
+      end
+
+      def _clear_cached_relationships
+        self.__cached_associations = {}
+      end
+
+      def _clear_cached_relationship(attr_name)
+        _cached_associations.delete(attr_name)
+      end
+
+      def _cached_relationship(attr_name)
+        return _cached_associations[attr_name] if _cached_associations.has_key?(attr_name)
+        _cached_associations[attr_name] = yield
+      end
+
+    end
+  end
+end

data/lib/json_api_client/helpers/dirty.rb

@@ -18,6 +18,10 @@ module JsonApiClient
         @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
       end
 
+      def forget_change!(attr)
+        @changed_attributes.delete(attr.to_s)
+      end
+
       def set_all_attributes_dirty
         attributes.each do |k, v|
           set_attribute_was(k, v)
@@ -68,4 +72,4 @@ module JsonApiClient
 
     end
   end
-end
+end

data/lib/json_api_client/helpers/dynamic_attributes.rb

@@ -24,7 +24,7 @@ module JsonApiClient
       end
 
       def respond_to_missing?(method, include_private = false)
-        if (method.to_s =~ /^(.*)=$/) || has_attribute?(method)
+        if has_attribute?(method) || method.to_s.end_with?('=')
           true
         else
           super
@@ -38,16 +38,14 @@ module JsonApiClient
       protected
 
       def method_missing(method, *args, &block)
-        normalized_method = if key_formatter
-                              key_formatter.unformat(method.to_s)
-                            else
-                              method.to_s
-                            end
-
-        if normalized_method =~ /^(.*)=$/
-          set_attribute($1, args.first)
-        elsif has_attribute?(method)
-          attributes[method]
+        if has_attribute?(method)
+          return attributes[method]
+        end
+
+        normalized_method = safe_key_formatter.unformat(method.to_s)
+
+        if normalized_method.end_with?('=')
+          set_attribute(normalized_method[0..-2], args.first)
         else
           super
         end
@@ -61,10 +59,20 @@ module JsonApiClient
         attributes[name] = value
       end
 
+      def safe_key_formatter
+        @safe_key_formatter ||= (key_formatter || DefaultKeyFormatter.new)
+      end
+
       def key_formatter
         self.class.respond_to?(:key_formatter) && self.class.key_formatter
       end
 
+      class DefaultKeyFormatter
+        def unformat(method)
+          method.to_s
+        end
+      end
+
     end
   end
 end

data/lib/json_api_client/helpers.rb

@@ -4,5 +4,6 @@ module JsonApiClient
     autoload :Dirty, 'json_api_client/helpers/dirty'
     autoload :DynamicAttributes, 'json_api_client/helpers/dynamic_attributes'
     autoload :URI, 'json_api_client/helpers/uri'
+    autoload :Associatable, 'json_api_client/helpers/associatable'
   end
 end

data/lib/json_api_client/included_data.rb

@@ -5,16 +5,29 @@ module JsonApiClient
     def initialize(result_set, data)
       record_class = result_set.record_class
       grouped_data = data.group_by{|datum| datum["type"]}
-      @data = grouped_data.inject({}) do |h, (type, records)|
+      grouped_included_set = grouped_data.each_with_object({}) do |(type, records), h|
         klass = Utils.compute_type(record_class, record_class.key_formatter.unformat(type).singularize.classify)
-        h[type] = records.map do |datum|
-          params = klass.parser.parameters_from_resource(datum)
-          resource = klass.load(params)
-          resource.last_result_set = result_set
-          resource
-        end.index_by(&:id)
-        h
+        h[type] = records.map do |record|
+          params = klass.parser.parameters_from_resource(record)
+          klass.load(params).tap do |resource|
+            resource.last_result_set = result_set
+          end
+        end
+      end
+
+      if record_class.search_included_in_result_set
+        # deep_merge overrides the nested Arrays o_O
+        # {a: [1,2]}.deep_merge(a: [3,4]) # => {a: [3,4]}
+        grouped_included_set.merge!(result_set.group_by(&:type)) do |_, resources1, resources2|
+          resources1 + resources2
+        end
       end
+
+      grouped_included_set.each do |type, resources|
+        grouped_included_set[type] = resources.index_by { |resource| resource.attributes[:id] }
+      end
+
+      @data = grouped_included_set
     end
 
     def data_for(method_name, definition)
@@ -23,9 +36,7 @@ module JsonApiClient
 
       if data.is_a?(Array)
         # has_many link
-        data.map do |link_def|
-          record_for(link_def)
-        end
+        data.map(&method(:record_for)).compact
       else
         # has_one link
         record_for(data)
@@ -40,7 +51,8 @@ module JsonApiClient
 
     # should return a resource record of some type for this linked document
     def record_for(link_def)
-      data[link_def["type"]][link_def["id"]]
+      record = data[link_def["type"]]
+      record[link_def["id"]] if record
     end
   end
 end

data/lib/json_api_client/middleware/json_request.rb

@@ -2,10 +2,25 @@ 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"] = '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/status.rb

@@ -1,6 +1,11 @@
 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)
@@ -11,13 +16,20 @@ module JsonApiClient
             handle_status(code, env)
           end
         end
-      rescue Faraday::ConnectionFailed, Faraday::TimeoutError
-        raise Errors::ConnectionError, environment
+      rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e
+        raise Errors::ConnectionError.new environment, e.to_s
       end
 
-      protected
+      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
@@ -25,12 +37,26 @@ module JsonApiClient
         when 403
           raise Errors::AccessDenied, env
         when 404
-          raise Errors::NotFound, env[:url]
+          raise Errors::NotFound, env
+        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
-          # some other error
-        when 500..599
+          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])

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

@@ -82,7 +82,7 @@ module JsonApiClient
       def params_for_uri(uri)
         return {} unless uri
         uri = Addressable::URI.parse(uri)
-        uri.query_values || {}
+        ( uri.query_values || {} ).with_indifferent_access
       end
     end
   end

data/lib/json_api_client/paginating.rb

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

data/lib/json_api_client/query/builder.rb

@@ -1,3 +1,5 @@
+require 'active_support/all'
+
 module JsonApiClient
   module Query
     class Builder
@@ -5,60 +7,55 @@ module JsonApiClient
       attr_reader :klass
       delegate :key_formatter, to: :klass
 
-      def initialize(klass)
-        @klass = klass
-        @primary_key = nil
-        @pagination_params = {}
-        @path_params = {}
-        @additional_params = {}
-        @filters = {}
-        @includes = []
-        @orders = []
-        @fields = []
+      def initialize(klass, opts = {})
+        @klass             = klass
+        @primary_key       = opts.fetch( :primary_key, nil )
+        @pagination_params = opts.fetch( :pagination_params, {} )
+        @path_params       = opts.fetch( :path_params, {} )
+        @additional_params = opts.fetch( :additional_params, {} )
+        @filters           = opts.fetch( :filters, {} )
+        @includes          = opts.fetch( :includes, [] )
+        @orders            = opts.fetch( :orders, [] )
+        @fields            = opts.fetch( :fields, [] )
       end
 
       def where(conditions = {})
         # pull out any path params here
-        @path_params.merge!(conditions.slice(*klass.prefix_params))
-        @filters.merge!(conditions.except(*klass.prefix_params))
-        self
+        path_conditions = conditions.slice(*klass.prefix_params)
+        unpathed_conditions = conditions.except(*klass.prefix_params)
+
+        _new_scope( path_params: path_conditions, filters: unpathed_conditions )
       end
 
       def order(*args)
-        @orders += parse_orders(*args)
-        self
+        _new_scope( orders: parse_orders(*args) )
       end
 
       def includes(*tables)
-        @includes += parse_related_links(*tables)
-        self
+        _new_scope( includes: parse_related_links(*tables) )
       end
 
       def select(*fields)
-        @fields += parse_fields(*fields)
-        self
+        _new_scope( fields: parse_fields(*fields) )
       end
 
       def paginate(conditions = {})
-        scope = self
+        scope = _new_scope
         scope = scope.page(conditions[:page]) if conditions[:page]
         scope = scope.per(conditions[:per_page]) if conditions[:per_page]
         scope
       end
 
       def page(number)
-        @pagination_params[:number] = number
-        self
+        _new_scope( pagination_params: { klass.paginator.page_param => number || 1 } )
       end
 
       def per(size)
-        @pagination_params[:size] = size
-        self
+        _new_scope( pagination_params: { klass.paginator.per_page_param => size } )
       end
 
       def with_params(more_params)
-        @additional_params.merge!(more_params)
-        self
+        _new_scope( additional_params: more_params )
       end
 
       def first
@@ -69,8 +66,12 @@ module JsonApiClient
         paginate(page: 1, per_page: 1).pages.last.to_a.last
       end
 
-      def build
-        klass.new(params)
+      def build(attrs = {})
+        klass.new @path_params.merge(attrs.with_indifferent_access)
+      end
+
+      def create(attrs = {})
+        klass.create @path_params.merge(attrs.with_indifferent_access)
       end
 
       def params
@@ -85,27 +86,63 @@ module JsonApiClient
       end
 
       def to_a
-        @to_a ||= find
+        @to_a ||= _fetch
       end
       alias all to_a
 
       def find(args = {})
+        if klass.raise_on_blank_find_param && args.blank?
+          raise Errors::NotFound, nil, 'blank .find param'
+        end
+
         case args
         when Hash
-          where(args)
+          scope = where(args)
         else
-          @primary_key = args
+          scope = _new_scope( primary_key: args )
         end
 
-        klass.requestor.get(params)
+        scope._fetch
       end
 
       def method_missing(method_name, *args, &block)
         to_a.send(method_name, *args, &block)
       end
 
+      def hash
+        [
+          klass,
+          params
+        ].hash
+      end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)
+
+        hash == other.hash
+      end
+      alias_method :eql?, :==
+
+      protected
+
+      def _fetch
+        klass.requestor.get(params)
+      end
+
       private
 
+      def _new_scope( opts = {} )
+        self.class.new( @klass,
+             primary_key:       opts.fetch( :primary_key, @primary_key ),
+             pagination_params: @pagination_params.merge( opts.fetch( :pagination_params, {} ) ),
+             path_params:       @path_params.merge( opts.fetch( :path_params, {} ) ),
+             additional_params: @additional_params.deep_merge( opts.fetch( :additional_params, {} ) ),
+             filters:           @filters.merge( opts.fetch( :filters, {} ) ),
+             includes:          @includes + opts.fetch( :includes, [] ),
+             orders:            @orders + opts.fetch( :orders, [] ),
+             fields:            @fields + opts.fetch( :fields, [] ) )
+      end
+
       def path_params
         @path_params.empty? ? {} : {path: @path_params}
       end
@@ -123,7 +160,13 @@ module JsonApiClient
       end
 
       def pagination_params
-        @pagination_params.empty? ? {} : {page: @pagination_params}
+        if klass.paginator.ancestors.include?(Paginating::Paginator)
+          # Original Paginator inconsistently wraps pagination params here. Keeping
+          # default behavior for now so as not to break backward compatibility.
+          @pagination_params.empty? ? {} : {page: @pagination_params}
+        else
+          @pagination_params
+        end
       end
 
       def includes_params
@@ -159,22 +202,7 @@ module JsonApiClient
       end
 
       def parse_related_links(*tables)
-        tables.map do |table|
-          case table
-          when Hash
-            table.map do |k, v|
-              parse_related_links(*v).map do |sub|
-                "#{k}.#{sub}"
-              end
-            end
-          when Array
-            table.map do |v|
-              parse_related_links(*v)
-            end
-          else
-            key_formatter.format(table)
-          end
-        end.flatten
+        Utils.parse_includes(klass, *tables)
       end
 
       def parse_orders(*args)