simple_jsonapi 1.0.0

data/lib/simple_jsonapi/helpers/serializer_methods.rb

@@ -0,0 +1,36 @@
+module SimpleJsonapi::SerializerMethods
+  # @!visibility private
+  def self.included(base)
+    class << base
+      # @return [Definition::Resource,Definition::Error]
+      attr_accessor :definition
+
+      def inherited(subclass)
+        subclass.definition = definition&.dup
+      end
+    end
+  end
+
+  # @return [Definition::Resource,Definition::Error]
+  def definition
+    self.class.definition
+  end
+
+  # Adds the provided data values to the serializer as instance variables for the duration of the block.
+  # @param data [Hash{Symbol => Object}]
+  def with(**data)
+    ivar_data = data.transform_keys { |key| :"@#{key}" }
+
+    existing_keys = ivar_data.each_key.select { |key| instance_variable_defined?(key) }
+    if existing_keys.any?
+      raise ArgumentError, "Cannot override existing instance variables #{existing_keys.to_sentence}."
+    end
+
+    begin
+      ivar_data.each { |k, v| instance_variable_set(k, v) }
+      yield
+    ensure
+      ivar_data.each_key { |k| remove_instance_variable(k) }
+    end
+  end
+end

data/lib/simple_jsonapi/node/attributes.rb

@@ -0,0 +1,51 @@
+module SimpleJsonapi::Node
+  # Represents a resource's +attributes+ object.
+  #
+  # @!attribute [r] resource
+  #   @return [Object]
+  # @!attribute [r] resource_type
+  #   @return [String]
+  # @!attribute [r] attribute_definitions
+  #   @return [Hash{Symbol => Definition::Attribute}]
+  class Attributes < Base
+    attr_reader :resource, :resource_type, :attribute_definitions
+
+    # @param resource [Object]
+    # @param resource_type [String]
+    # @param attribute_definitions [Hash{Symbol => Definition::Attribute}]
+    # @param options see {Node::Base#initialize} for additional parameters
+    def initialize(resource:, resource_type:, attribute_definitions:, **options)
+      super(options)
+
+      @resource = resource
+      @resource_type = resource_type
+      @attribute_definitions = attribute_definitions
+    end
+
+    # @return [Hash{Symbol => Hash}]
+    def as_jsonapi
+      if attribute_definitions_to_render.any?
+        json = {}
+        attribute_definitions_to_render.each do |name, defn|
+          json[name] = evaluate(defn.value_proc, resource)
+        end
+        { attributes: json }
+      else
+        {}
+      end
+    end
+
+    private
+
+    def attribute_definitions_to_render
+      @attribute_definitions_to_render ||= begin
+        include_all_fields = fields_spec.all_fields?(resource_type)
+        explicit_fields = fields_spec[resource_type]
+
+        attribute_definitions
+          .select { |name, _| include_all_fields || explicit_fields.include?(name) }
+          .select { |_, defn| render?(defn, resource) }
+      end
+    end
+  end
+end

data/lib/simple_jsonapi/node/base.rb

@@ -0,0 +1,91 @@
+module SimpleJsonapi::Node
+  # Represents a node in the JSONAPI document. See {file:README.md} for more
+  # details.
+  #
+  # {include:file:doc/node_hierarchy.md}
+  # @abstract
+  # @!attribute [r] root_node
+  #   @return [Node::Base]
+  # @!attribute [r] serializer_inferrer
+  #   @return [SerializerInferrer]
+  # @!attribute [r] serializer
+  #   @return [Serializer,ErrorSerializer]
+  # @!attribute [r] fields_spec
+  #   @return [Parameters::FieldsSpec]
+  # @!attribute [r] include_spec
+  #   @return [Parameters::IncludeSpec]
+  # @!attribute [r] sort_spec
+  #   @return [Parameters::SortSpec]
+  # @!attribute [r] extras
+  #   @return [Hash{Symbol => Object}]
+  class Base
+    attr_reader :root_node, :serializer_inferrer, :serializer, :fields_spec, :include_spec, :sort_spec, :extras
+
+    # @param root_node [Node::Base]
+    # @param serializer_inferrer [SerializerInferrer]
+    # @param serializer [Serializer,ErrorSerializer]
+    # @param fields [Parameters::FieldsSpec]
+    # @param include [Parameters::IncludeSpec]
+    # @param sort_related [Parameters::SortSpec]
+    # @param extras [Hash{Symbol => Object}]
+    def initialize(
+      root_node:,
+      serializer_inferrer: nil,
+      serializer: nil,
+      fields: nil,
+      include: nil,
+      sort_related: nil,
+      extras: {},
+      **_options
+    )
+      @root_node = root_node
+      @serializer_inferrer = SimpleJsonapi::SerializerInferrer.wrap(serializer_inferrer)
+      @serializer = serializer
+      @fields_spec = SimpleJsonapi::Parameters::FieldsSpec.wrap(fields)
+      @include_spec = SimpleJsonapi::Parameters::IncludeSpec.wrap(include)
+      @sort_spec = SimpleJsonapi::Parameters::SortSpec.wrap(sort_related)
+      @extras = extras
+    end
+
+    # @abstract
+    # @return [Hash{Symbol => Hash}]
+    def as_jsonapi
+      raise NotImplementedError, "Implement #{__method__} in each subclass."
+    end
+
+    private
+
+    def build_child_node(node_class, **options)
+      defaults = {
+        root_node: root_node,
+        serializer_inferrer: serializer_inferrer,
+        serializer: serializer,
+        fields: fields_spec,
+        include: include_spec,
+        sort_related: sort_spec,
+        extras: extras,
+      }
+
+      node_class.new(defaults.merge(options))
+    end
+
+    def evaluate(callable, object, **data)
+      serializer.with(data.merge(extras)) do
+        serializer.instance_exec(object, &callable)
+      end
+    end
+
+    def render?(definition, object)
+      if_proc = definition.if_predicate
+      unless_proc = definition.unless_predicate
+
+      if if_proc && !evaluate(if_proc, object)
+        false
+      elsif unless_proc && evaluate(unless_proc, object)
+        false
+      else
+        true
+      end
+    end
+  end
+end

data/lib/simple_jsonapi/node/data/collection.rb

@@ -0,0 +1,25 @@
+# Represents a root +data+ node that contains a collection of resources.
+module SimpleJsonapi::Node::Data
+  # @!attribute [r] resources
+  #   @return [Array<Object>]
+  class Collection < SimpleJsonapi::Node::Base
+    attr_reader :resources
+
+    # @param resources [Array<Object>]
+    # @param options see {Node::Base#initialize} for additional parameters
+    def initialize(resources:, **options)
+      super(options)
+
+      @resources = Array.wrap(resources)
+
+      @resource_nodes = @resources.map do |resource|
+        build_child_node(SimpleJsonapi::Node::Resource::Full, resource: resource)
+      end
+    end
+
+    # @return [Hash{Symbol => Hash}]
+    def as_jsonapi
+      { data: @resource_nodes.map(&:as_jsonapi) }
+    end
+  end
+end

data/lib/simple_jsonapi/node/data/singular.rb

@@ -0,0 +1,26 @@
+# Represents a root +data+ node that contains a single resource.
+module SimpleJsonapi::Node::Data
+  # @!attribute [r] resource
+  #   @return [Object]
+  class Singular < SimpleJsonapi::Node::Base
+    attr_reader :resource
+
+    # @param resource [Object]
+    # @param options see {Node::Base#initialize} for additional parameters
+    def initialize(resource:, **options)
+      super(options)
+
+      @resource = resource
+      @resource_node = build_child_node(SimpleJsonapi::Node::Resource::Full, resource: @resource) unless @resource.nil?
+    end
+
+    # @return [Hash{Symbol => Hash}]
+    def as_jsonapi
+      if resource.nil?
+        { data: nil }
+      else
+        { data: @resource_node.as_jsonapi }
+      end
+    end
+  end
+end

data/lib/simple_jsonapi/node/document/base.rb

@@ -0,0 +1,62 @@
+module SimpleJsonapi::Node::Document
+  # Represents a JSONAPI document.
+  # @abstract
+  class Base < SimpleJsonapi::Node::Base
+    # @param links [Hash{Symbol => String,Hash}]
+    # @param meta [Hash{Symbol => Object}]
+    # @param options see {Node::Base#initialize} for additional parameters
+    def initialize(links: nil, meta: nil, **options)
+      @data_node = @links_json = @meta_json = @errors_node = nil
+
+      super(options.merge(root_node: self))
+      validate_options!(options.merge(links: links, meta: meta))
+
+      @links_json = links if links&.any?
+      @meta_json = meta if meta&.any?
+    end
+
+    # @return [Hash{Symbol => Hash}]
+    def as_jsonapi
+      doc = {}
+
+      doc.merge!(@data_node.as_jsonapi) if @data_node
+      doc.merge!(@errors_node.as_jsonapi) if @errors_node
+      doc.merge!(included_node.as_jsonapi)
+      doc[:links] = @links_json if @links_json
+      doc[:meta] = @meta_json if @meta_json
+      # jsonapi
+
+      doc
+    end
+
+    # @param resource_node [Node::Resource::Base]
+    # @return [Boolean]
+    def included_resource?(resource_node)
+      included_node.included_resource?(resource_node)
+    end
+
+    # @param resource_node [Node::Resource::Full]
+    # @return [Node::Resource::Full]
+    def append_included_resource(resource_node)
+      included_node.append_included_resource(resource_node)
+    end
+
+    private
+
+    def validate_options!(options)
+      links, meta = options.values_at(:links, :meta)
+
+      unless links.nil? || links.is_a?(Hash)
+        raise ArgumentError, "Expected links to be NilClass or Hash but got #{links.class.name}"
+      end
+
+      unless meta.nil? || meta.is_a?(Hash)
+        raise ArgumentError, "Expected meta to be NilClass or Hash but got #{meta.class.name}"
+      end
+    end
+
+    def included_node
+      @included_node ||= build_child_node(SimpleJsonapi::Node::Included)
+    end
+  end
+end

data/lib/simple_jsonapi/node/document/collection.rb

@@ -0,0 +1,17 @@
+module SimpleJsonapi::Node::Document
+  # Represents a JSONAPI document whose primary data is a collection of resources.
+  # @!attribute [r] resources
+  #   @return [Array<Object>]
+  class Collection < Base
+    attr_reader :resources
+
+    # @param resources [Array<Object>]
+    # @param options see {Node::Document::Base#initialize} for additional parameters
+    def initialize(resources:, **options)
+      super
+
+      @resources = Array.wrap(resources)
+      @data_node = build_child_node(SimpleJsonapi::Node::Data::Collection, resources: @resources)
+    end
+  end
+end

data/lib/simple_jsonapi/node/document/errors.rb

@@ -0,0 +1,17 @@
+module SimpleJsonapi::Node::Document
+  # Represents a JSONAPI document containing a collection of errors.
+  # @!attribute [r] errors
+  #   @return [Array<Object>]
+  class Errors < Base
+    attr_reader :errors
+
+    # @param errors [Array<Object>]
+    # @param options see {Node::Document::Base#initialize} for additional parameters
+    def initialize(errors:, **options)
+      super
+
+      @errors = Array.wrap(errors)
+      @errors_node = build_child_node(SimpleJsonapi::Node::Errors, errors: @errors)
+    end
+  end
+end

data/lib/simple_jsonapi/node/document/singular.rb

@@ -0,0 +1,17 @@
+module SimpleJsonapi::Node::Document
+  # Represents a JSONAPI document whose primary data is a single resource.
+  # @!attribute [r] resource
+  #   @return [Object]
+  class Singular < Base
+    attr_reader :resource
+
+    # @param resource [Object]
+    # @param options see {Node::Document::Base#initialize} for additional parameters
+    def initialize(resource:, **options)
+      super
+
+      @resource = resource
+      @data_node = build_child_node(SimpleJsonapi::Node::Data::Singular, resource: @resource)
+    end
+  end
+end

data/lib/simple_jsonapi/node/error.rb

@@ -0,0 +1,55 @@
+module SimpleJsonapi::Node
+  # @!attribute [r] error
+  #   @return [Object]
+  class Error < Base
+    attr_reader :error
+
+    # @param error [Object]
+    # @param options see {Node::Base#initialize} for additional parameters
+    def initialize(error:, **options)
+      super(options)
+
+      @error = error
+      @serializer = serializer_inferrer.infer(error).new
+
+      @source_node = build_child_node(
+        SimpleJsonapi::Node::ErrorSource,
+        error: error,
+        source_definition: serializer.source_definition,
+      )
+
+      @links_node = build_child_node(
+        SimpleJsonapi::Node::ObjectLinks,
+        object: error,
+        link_definitions: serializer.link_definitions,
+      )
+
+      @meta_node = build_child_node(
+        SimpleJsonapi::Node::ObjectMeta,
+        object: error,
+        meta_definitions: serializer.meta_definitions,
+      )
+    end
+
+    # @return [Hash{Symbol => Hash}]
+    def as_jsonapi
+      json = {}
+
+      member_definitions_to_render.each do |name, defn|
+        json[name] = evaluate(defn.value_proc, error).to_s
+      end
+
+      json.merge!(@source_node.as_jsonapi)
+      json.merge!(@links_node.as_jsonapi)
+      json.merge!(@meta_node.as_jsonapi)
+
+      json
+    end
+
+    private
+
+    def member_definitions_to_render
+      @member_definitions_to_render ||= serializer.member_definitions.select { |_, defn| render?(defn, error) }
+    end
+  end
+end

data/lib/simple_jsonapi/node/error_source.rb

@@ -0,0 +1,40 @@
+module SimpleJsonapi::Node
+  # @!attribute [r] error
+  #   @return [Object]
+  # @!attribute [r] source_definition
+  #   @return [Definition::ErrorSource]
+  class ErrorSource < Base
+    attr_reader :error, :source_definition
+
+    # @param error [Object]
+    # @param source_definition [Definition::ErrorSource]
+    # @param options see {Node::Base#initialize} for additional parameters
+    def initialize(error:, source_definition:, **options)
+      super(options)
+
+      @error = error
+      @source_definition = source_definition
+    end
+
+    # @return [Hash{Symbol => Hash}]
+    def as_jsonapi
+      source_json = {}
+
+      member_definitions_to_render.each do |name, defn|
+        source_json[name] = evaluate(defn.value_proc, error).to_s
+      end
+
+      if source_json.any?
+        { source: source_json }
+      else
+        {}
+      end
+    end
+
+    private
+
+    def member_definitions_to_render
+      @member_definitions_to_render ||= source_definition.member_definitions.select { |_, defn| render?(defn, error) }
+    end
+  end
+end