jsonapi-resources 0.9.12 → 0.10.7

data/lib/jsonapi/resource_controller_metal.rb

@@ -10,6 +10,9 @@ module JSONAPI
       JSONAPI::ActsAsResourceController
     ].compact.freeze
 
+    # Note, the url_helpers are not loaded. This will prevent links from being generated for resources, and warnings
+    # will be emitted. Link support can be added by including `Rails.application.routes.url_helpers`, and links
+    # can be disabled, and warning suppressed, for a resource with `exclude_links :default`
     MODULES.each do |mod|
       include mod
     end

data/lib/jsonapi/resource_fragment.rb

@@ -0,0 +1,47 @@
+module JSONAPI
+
+  # A ResourceFragment holds a ResourceIdentity and associated partial resource data.
+  #
+  # The following partial resource data may be stored
+  # cache - the value of the cache field for the resource instance
+  # related - a hash of arrays of related resource identities, grouped by relationship name
+  # related_from - a set of related resource identities that loaded the fragment
+  #
+  # Todo: optionally use these for faster responses by bypassing model instantiation)
+  # attributes - resource attributes
+
+  class ResourceFragment
+    attr_reader :identity, :attributes, :related_from, :related
+
+    attr_accessor :primary, :cache
+
+    alias :cache_field :cache #ToDo: Rename one or the other
+
+    def initialize(identity)
+      @identity = identity
+      @cache = nil
+      @attributes = {}
+      @related = {}
+      @primary = false
+      @related_from = Set.new
+    end
+
+    def initialize_related(relationship_name)
+      @related ||= {}
+      @related[relationship_name.to_sym] ||= Set.new
+    end
+
+    def add_related_identity(relationship_name, identity)
+      initialize_related(relationship_name)
+      @related[relationship_name.to_sym] << identity
+    end
+
+    def add_related_from(identity)
+      @related_from << identity
+    end
+
+    def add_attribute(name, value)
+      @attributes[name] = value
+    end
+  end
+end

data/lib/jsonapi/resource_id_tree.rb

@@ -0,0 +1,112 @@
+module JSONAPI
+
+  # A tree structure representing the resource structure of the requested resource(s). This is an intermediate structure
+  # used to keep track of the resources, by identity, found at different included relationships. It will be flattened and
+  # the resource instances will be fetched from the cache or the record store.
+  class ResourceIdTree
+
+    attr_reader :fragments, :related_resource_id_trees
+
+    # Gets the related Resource Id Tree for a relationship, and creates it first if it does not exist
+    #
+    # @param relationship [JSONAPI::Relationship]
+    #
+    # @return [JSONAPI::RelatedResourceIdTree] the new or existing resource id tree for the requested relationship
+    def fetch_related_resource_id_tree(relationship)
+      relationship_name = relationship.name.to_sym
+      @related_resource_id_trees[relationship_name] ||= RelatedResourceIdTree.new(relationship, self)
+    end
+
+    private
+
+    def init_included_relationships(fragment, include_related)
+      include_related && include_related.each_key do |relationship_name|
+        fragment.initialize_related(relationship_name)
+      end
+    end
+  end
+
+  class PrimaryResourceIdTree < ResourceIdTree
+
+    # Creates a PrimaryResourceIdTree with no resources and no related ResourceIdTrees
+    def initialize
+      @fragments ||= {}
+      @related_resource_id_trees ||= {}
+    end
+
+    # Adds each Resource Fragment to the Resources hash
+    #
+    # @param fragments [Hash]
+    # @param include_related [Hash]
+    #
+    # @return [null]
+    def add_resource_fragments(fragments, include_related)
+      fragments.each_value do |fragment|
+        add_resource_fragment(fragment, include_related)
+      end
+    end
+
+    # Adds a Resource Fragment to the Resources hash
+    #
+    # @param fragment [JSONAPI::ResourceFragment]
+    # @param include_related [Hash]
+    #
+    # @return [null]
+    def add_resource_fragment(fragment, include_related)
+      fragment.primary = true
+
+      init_included_relationships(fragment, include_related)
+
+      @fragments[fragment.identity] = fragment
+    end
+  end
+
+  class RelatedResourceIdTree < ResourceIdTree
+
+    attr_reader :parent_relationship, :source_resource_id_tree
+
+    # Creates a RelatedResourceIdTree with no resources and no related ResourceIdTrees. A connection to the parent
+    # ResourceIdTree is maintained.
+    #
+    # @param parent_relationship [JSONAPI::Relationship]
+    # @param source_resource_id_tree [JSONAPI::ResourceIdTree]
+    #
+    # @return [JSONAPI::RelatedResourceIdTree] the new or existing resource id tree for the requested relationship
+    def initialize(parent_relationship, source_resource_id_tree)
+      @fragments ||= {}
+      @related_resource_id_trees ||= {}
+
+      @parent_relationship = parent_relationship
+      @parent_relationship_name = parent_relationship.name.to_sym
+      @source_resource_id_tree = source_resource_id_tree
+    end
+
+    # Adds each Resource Fragment to the Resources hash
+    #
+    # @param fragments [Hash]
+    # @param include_related [Hash]
+    #
+    # @return [null]
+    def add_resource_fragments(fragments, include_related)
+      fragments.each_value do |fragment|
+        add_resource_fragment(fragment, include_related)
+      end
+    end
+
+    # Adds a Resource Fragment to the fragments hash
+    #
+    # @param fragment [JSONAPI::ResourceFragment]
+    # @param include_related [Hash]
+    #
+    # @return [null]
+    def add_resource_fragment(fragment, include_related)
+      init_included_relationships(fragment, include_related)
+
+      fragment.related_from.each do |rid|
+        @source_resource_id_tree.fragments[rid].add_related_identity(parent_relationship.name, fragment.identity)
+      end
+
+      @fragments[fragment.identity] = fragment
+    end
+  end
+end

data/lib/jsonapi/resource_identity.rb

@@ -0,0 +1,42 @@
+module JSONAPI
+
+  # ResourceIdentity describes a unique identity of a resource in the system.
+  # This consists of a Resource class and an identifier that is unique within
+  # that Resource class. ResourceIdentities are intended to be used as hash
+  # keys to provide ordered mixing of resource types in result sets.
+  #
+  #
+  # == Creating a ResourceIdentity
+  #
+  # rid = ResourceIdentity.new(PostResource, 12)
+  #
+  class ResourceIdentity
+    attr_reader :resource_klass, :id
+
+    def initialize(resource_klass, id)
+      @resource_klass = resource_klass
+      @id = id
+    end
+
+    def ==(other)
+      # :nocov:
+      eql?(other)
+      # :nocov:
+    end
+
+    def eql?(other)
+      other.is_a?(ResourceIdentity) && other.resource_klass == @resource_klass && other.id == @id
+    end
+
+    def hash
+      [@resource_klass, @id].hash
+    end
+
+    # Creates a string representation of the identifier.
+    def to_s
+      # :nocov:
+      "#{resource_klass}:#{id}"
+      # :nocov:
+    end
+  end
+end