carwow-json_api_client 1.19.0

data/lib/json_api_client/helpers.rb

@@ -0,0 +1,9 @@
+module JsonApiClient
+  module Helpers
+    autoload :Callbacks, 'json_api_client/helpers/callbacks'
+    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/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/callbacks.rb

@@ -0,0 +1,27 @@
+module JsonApiClient
+  module Helpers
+    module Callbacks
+      extend ActiveSupport::Concern
+
+      included do
+        extend ActiveModel::Callbacks
+        define_model_callbacks :save, :destroy, :create, :update
+      end
+
+      def save
+        run_callbacks :save do
+          run_callbacks (persisted? ? :update : :create) do
+            super
+          end
+        end
+      end
+
+      def destroy
+        run_callbacks :destroy do
+          super
+        end
+      end
+
+    end
+  end
+end

data/lib/json_api_client/helpers/dirty.rb

@@ -0,0 +1,75 @@
+module JsonApiClient
+  module Helpers
+    module Dirty
+
+      def changed?
+        changed_attributes.present?
+      end
+
+      def changed
+        changed_attributes.keys
+      end
+
+      def changed_attributes
+        @changed_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
+      end
+
+      def clear_changes_information
+        @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)
+        end
+      end
+
+      def attribute_will_change!(attr)
+        return if attribute_changed?(attr)
+        set_attribute_was(attr, attributes[attr])
+      end
+
+      def set_attribute_was(attr, value)
+        begin
+          value = value.duplicable? ? value.clone : value
+          changed_attributes[attr] = value
+        rescue TypeError, NoMethodError
+        end
+      end
+
+      def attribute_was(attr) # :nodoc:
+        attribute_changed?(attr) ? changed_attributes[attr] : attributes[attr]
+      end
+
+      def attribute_changed?(attr)
+        changed.include?(attr.to_s)
+      end
+
+      def attribute_change(attr)
+        [changed_attributes[attr], attributes[attr]] if attribute_changed?(attr)
+      end
+
+      protected
+
+      def method_missing(method, *args, &block)
+        if method.to_s =~ /^(.*)_changed\?$/
+          has_attribute?($1) ? attribute_changed?($1) : nil
+        elsif method.to_s =~ /^(.*)_was$/
+          has_attribute?($1) ? attribute_was($1) : nil
+        else
+          super
+        end
+      end
+
+      def set_attribute(name, value)
+        attribute_will_change!(name) if value != attributes[name] || !attributes.has_key?(name)
+        super
+      end
+
+    end
+  end
+end

data/lib/json_api_client/helpers/dynamic_attributes.rb

@@ -0,0 +1,78 @@
+module JsonApiClient
+  module Helpers
+    module DynamicAttributes
+
+      def attributes
+        @attributes
+      end
+
+      def attributes=(attrs = {})
+        @attributes ||= ActiveSupport::HashWithIndifferentAccess.new
+
+        return @attributes unless attrs.present?
+        attrs.each do |key, value|
+          send("#{key}=", value)
+        end
+      end
+
+      def [](key)
+        read_attribute(key)
+      end
+
+      def []=(key, value)
+        set_attribute(key, value)
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        if has_attribute?(method) || method.to_s.end_with?('=')
+          true
+        else
+          super
+        end
+      end
+
+      def has_attribute?(attr_name)
+        attributes.has_key?(attr_name)
+      end
+
+      protected
+
+      def method_missing(method, *args, &block)
+        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
+      end
+
+      def read_attribute(name)
+        attributes.fetch(name, nil)
+      end
+
+      def set_attribute(name, value)
+        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/uri.rb

@@ -0,0 +1,9 @@
+module JsonApiClient
+  module Helpers
+    module URI
+      def encode_part(part)
+        Addressable::URI.encode_component(part, Addressable::URI::CharacterClasses::UNRESERVED)
+      end
+    end
+  end
+end

data/lib/json_api_client/implementation.rb

@@ -0,0 +1,12 @@
+module JsonApiClient
+  class Implementation
+    attr_reader :version, :meta
+
+    def initialize(data)
+      # If the version member is not present, clients should assume the server implements at least version 1.0 of the specification.
+      @version = data.fetch("version", "1.0")
+
+      @meta = MetaData.new(data.fetch("meta", {}))
+    end
+  end
+end

data/lib/json_api_client/included_data.rb

@@ -0,0 +1,58 @@
+module JsonApiClient
+  class IncludedData
+    attr_reader :data
+
+    def initialize(result_set, data)
+      record_class = result_set.record_class
+      grouped_data = data.group_by{|datum| datum["type"]}
+      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 |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(&:id)
+      end
+
+      @data = grouped_included_set
+    end
+
+    def data_for(method_name, definition)
+      # If data is defined, pull the record from the included data
+      return nil unless data = definition["data"]
+
+      if data.is_a?(Array)
+        # has_many link
+        data.map(&method(:record_for)).compact
+      else
+        # has_one link
+        record_for(data)
+      end
+    end
+
+    def has_link?(name)
+      data.has_key?(name.to_s)
+    end
+
+    private
+
+    # should return a resource record of some type for this linked document
+    def record_for(link_def)
+      record = data[link_def["type"]]
+      record[link_def["id"]] if record
+    end
+  end
+end

data/lib/json_api_client/linking.rb

@@ -0,0 +1,6 @@
+module JsonApiClient
+  module Linking
+    autoload :Links, "json_api_client/linking/links"
+    autoload :TopLevelLinks, "json_api_client/linking/top_level_links"
+  end
+end

data/lib/json_api_client/linking/links.rb

@@ -0,0 +1,22 @@
+module JsonApiClient
+  module Linking
+    class Links
+      include Helpers::DynamicAttributes
+
+      def initialize(links)
+        self.attributes = links
+      end
+
+      def present?
+        attributes.present?
+      end
+
+      protected
+
+      def set_attribute(name, value)
+        attributes[name] = value
+      end
+
+    end
+  end
+end

data/lib/json_api_client/linking/top_level_links.rb

@@ -0,0 +1,39 @@
+module JsonApiClient
+  module Linking
+    class TopLevelLinks
+
+      attr_reader :links, :record_class
+
+      def initialize(record_class, links)
+        @links = links
+        @record_class = record_class
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        links.has_key?(method.to_s) || super
+      end
+
+      def method_missing(method, *args)
+        if respond_to_missing?(method)
+          fetch_link(method)
+        else
+          super
+        end
+      end
+
+      def link_url_for(link_name)
+        link_definition = links.fetch(link_name.to_s)
+        if link_definition.is_a?(Hash)
+          link_definition["href"]
+        else
+          link_definition
+        end
+      end
+
+      def fetch_link(link_name)
+        return unless respond_to_missing?(link_name)
+        record_class.requestor.linked(link_url_for(link_name))
+      end
+    end
+  end
+end

data/lib/json_api_client/meta_data.rb

@@ -0,0 +1,19 @@
+module JsonApiClient
+  class MetaData
+    include Helpers::DynamicAttributes
+
+    attr_accessor :record_class
+
+    def initialize(data, record_class = nil)
+      self.record_class = record_class
+      self.attributes = data
+    end
+
+    protected
+
+    def key_formatter
+      record_class && record_class.key_formatter
+    end
+
+  end
+end