simple_jsonapi 1.0.0

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/lib/simple_jsonapi.rb

@@ -0,0 +1,112 @@
+require 'active_support'
+require 'active_support/core_ext'
+
+require 'simple_jsonapi/helpers/exceptions'
+require 'simple_jsonapi/helpers/serializer_inferrer'
+require 'simple_jsonapi/helpers/serializer_methods'
+
+require 'simple_jsonapi/parameters/fields_spec'
+require 'simple_jsonapi/parameters/include_spec'
+require 'simple_jsonapi/parameters/sort_spec'
+
+require 'simple_jsonapi/definition/base'
+require 'simple_jsonapi/definition/attribute'
+require 'simple_jsonapi/definition/error'
+require 'simple_jsonapi/definition/error_source'
+require 'simple_jsonapi/definition/link'
+require 'simple_jsonapi/definition/meta'
+require 'simple_jsonapi/definition/relationship'
+require 'simple_jsonapi/definition/resource'
+
+require 'simple_jsonapi/node/base'
+require 'simple_jsonapi/node/attributes'
+require 'simple_jsonapi/node/data/collection'
+require 'simple_jsonapi/node/data/singular'
+require 'simple_jsonapi/node/document/base'
+require 'simple_jsonapi/node/document/collection'
+require 'simple_jsonapi/node/document/singular'
+require 'simple_jsonapi/node/document/errors'
+require 'simple_jsonapi/node/error'
+require 'simple_jsonapi/node/error_source'
+require 'simple_jsonapi/node/errors'
+require 'simple_jsonapi/node/included'
+require 'simple_jsonapi/node/object_links'
+require 'simple_jsonapi/node/object_meta'
+require 'simple_jsonapi/node/relationship'
+require 'simple_jsonapi/node/relationship_data/base'
+require 'simple_jsonapi/node/relationship_data/collection'
+require 'simple_jsonapi/node/relationship_data/singular'
+require 'simple_jsonapi/node/relationships'
+require 'simple_jsonapi/node/resource/base'
+require 'simple_jsonapi/node/resource/full'
+require 'simple_jsonapi/node/resource/linkage'
+
+require 'simple_jsonapi/serializer'
+require 'simple_jsonapi/error_serializer'
+
+require 'simple_jsonapi/errors/bad_request'
+require 'simple_jsonapi/errors/exception_serializer'
+require 'simple_jsonapi/errors/wrapped_error'
+require 'simple_jsonapi/errors/wrapped_error_serializer'
+
+module SimpleJsonapi
+  MIME_TYPE = 'application/vnd.api+json'.freeze
+
+  mattr_accessor :serializer_inferrer, :error_serializer_inferrer
+
+  self.serializer_inferrer = SerializerInferrer.new
+  self.error_serializer_inferrer = SerializerInferrer.new(namespace: SimpleJsonapi::Errors.name)
+
+  def self.render_resource(resource, options = {})
+    document_options = normalize_render_options(
+      options,
+      resource: resource,
+      serializer: serializer_inferrer,
+    )
+
+    Node::Document::Singular.new(document_options).as_jsonapi
+  end
+
+  def self.render_resources(resources, options = {})
+    document_options = normalize_render_options(
+      options,
+      resources: resources,
+      serializer: serializer_inferrer,
+    )
+
+    Node::Document::Collection.new(document_options).as_jsonapi
+  end
+
+  def self.render_errors(errors, options = {})
+    document_options = normalize_render_options(
+      options,
+      errors: errors,
+      serializer: error_serializer_inferrer,
+    )
+
+    Node::Document::Errors.new(document_options).as_jsonapi
+  end
+
+  def self.normalize_render_options(options, defaults)
+    defaults.merge(options.symbolize_keys).transform_keys do |key|
+      key == :serializer ? :serializer_inferrer : key
+    end
+  end
+
+  private_class_method :normalize_render_options
+end
+
+module SimpleJsonapi::Definition
+end
+
+module SimpleJsonapi::Definition::Concerns
+end
+
+module SimpleJsonapi::Errors
+end
+
+module SimpleJsonapi::Node
+end
+
+module SimpleJsonapi::Parameters
+end

data/lib/simple_jsonapi/definition/attribute.rb

@@ -0,0 +1,45 @@
+# Represents a single attribute in a resource's +attributes+ collection
+# @!attribute [r] name
+#   @return [Symbol]
+# @!attribute [r] data_type
+#   @return [Symbol]
+# @!attribute [r] array
+#   @return [Boolean]
+# @!attribute [r] description
+#   @return [String]
+class SimpleJsonapi::Definition::Attribute < SimpleJsonapi::Definition::Base
+  attr_reader :name, :data_type, :array, :description
+  # @visibility private
+  attr_reader :value_proc
+
+  # @overload initialize(name, type: nil, description: nil, **options, &block)
+  # @overload initialize(name, value, type: nil, description: nil, **options)
+  # @param type [Symbol] data type
+  # @param description [String]
+  # @yieldparam resource [Object]
+  # @yieldreturn [Object]
+  # @option (see Definition::Base#initialize)
+  def initialize(name, *args, type: nil, array: false, description: nil, **options, &block)
+    raise ArgumentError, "A name is required" if name.blank?
+
+    super
+    @name = name.to_sym
+    @data_type = type&.to_sym
+    @array = array
+    @description = description.to_s.presence
+
+    if args.none? && !block_given?
+      @value_proc = wrap_in_proc { |resource| resource.public_send(name) }
+    else
+      @value_proc = wrap_in_proc(*args, &block)
+    end
+  end
+
+  private
+
+  def initialize_dup(new_def)
+    super
+    # name is a symbol, can't be duped
+    new_def.instance_variable_set(:@value_proc, @value_proc.dup)
+  end
+end

data/lib/simple_jsonapi/definition/base.rb

@@ -0,0 +1,50 @@
+require 'simple_jsonapi/definition/concerns/has_links_object'
+require 'simple_jsonapi/definition/concerns/has_meta_object'
+
+# Defines how a portion of a rendered JSONAPI document is generated from a
+# resource or error object. See {file:README.md} for more details.
+#
+# @abstract
+class SimpleJsonapi::Definition::Base
+  # @visibility private
+  # attr_reader :options, :if_predicate, :unless_predicate
+  attr_reader :if_predicate, :unless_predicate
+
+  # @param args See subclass documentation for the arguments they require.
+  # @option options [Proc<Boolean>] if
+  # @option options [Proc<Boolean>] unless
+  def initialize(*_args, **options, &_block)
+    @if_predicate = @unless_predicate = nil
+    @if_predicate = wrap_in_proc(options[:if]) if options.key?(:if)
+    @unless_predicate = wrap_in_proc(options[:unless]) if options.key?(:unless)
+  end
+
+  private def initialize_dup(new_def)
+    super
+
+    new_def.instance_variable_set(:@if_predicate, @if_predicate.dup) unless @if_predicate.nil?
+    new_def.instance_variable_set(:@unless_predicate, @unless_predicate.dup) unless @unless_predicate.nil?
+  end
+
+  private
+
+  def wrap_in_proc(*args, &block)
+    if args.empty? && !block_given?
+      raise ArgumentError, "Either a value or a block is required"
+    elsif args.size == 1 && block_given?
+      raise ArgumentError, "A value and a block cannot both be present"
+    elsif args.size > 1
+      raise ArgumentError, "Too many arguments provided (#{args.size})"
+    end
+
+    callable_or_value = args[0]
+
+    if block_given?
+      block
+    elsif callable_or_value.is_a?(Proc)
+      callable_or_value
+    else
+      proc { |*| callable_or_value }
+    end
+  end
+end

data/lib/simple_jsonapi/definition/concerns/has_links_object.rb

@@ -0,0 +1,36 @@
+module SimpleJsonapi
+  module Definition
+    module Concerns
+      # Adds a {#link} method and {#link_definitions} collection to a
+      # definition.
+      #
+      # @!attribute [r] link_definitions
+      #   @return [Hash{Symbol => String,Object}]
+      module HasLinksObject
+        # @visibility private
+        def self.included(base)
+          base.send :attr_accessor, :link_definitions
+        end
+
+        def initialize(*args, &block)
+          super
+          @link_definitions = {}
+        end
+
+        private def initialize_dup(new_def)
+          super
+          new_def.link_definitions = link_definitions.deep_dup
+        end
+
+        # @overload link(name, options = {}, &block)
+        # @overload link(name, value, options = {})
+        # @yieldparam object [Object]
+        # @yieldreturn [String,Hash]
+        # @return [void]
+        def link(name, *args, **options, &block)
+          link_definitions[name.to_sym] = Link.new(name, *args, options, &block)
+        end
+      end
+    end
+  end
+end

data/lib/simple_jsonapi/definition/concerns/has_meta_object.rb

@@ -0,0 +1,36 @@
+module SimpleJsonapi
+  module Definition
+    module Concerns
+      # Adds a {#meta} method and {#meta_definitions} collection to a
+      # definition.
+      #
+      # @!attribute [r] meta_definitions
+      #   @return [Hash{Symbol => String,Object}]
+      module HasMetaObject
+        # @visibility private
+        def self.included(base)
+          base.send :attr_accessor, :meta_definitions
+        end
+
+        def initialize(*args, &block)
+          super
+          @meta_definitions = {}
+        end
+
+        private def initialize_dup(new_def)
+          super
+          new_def.meta_definitions = meta_definitions.deep_dup
+        end
+
+        # @overload meta(name, options = {}, &block)
+        # @overload meta(name, value, options = {})
+        # @yieldparam object [Object]
+        # @yieldreturn [Object]
+        # @return [void]
+        def meta(name, *args, **options, &block)
+          meta_definitions[name.to_sym] = Meta.new(name, *args, options, &block)
+        end
+      end
+    end
+  end
+end

data/lib/simple_jsonapi/definition/error.rb

@@ -0,0 +1,70 @@
+# @!attribute [r] member_definitions
+#   @return [Hash{Symbol => Attribute}]
+# @!attribute [r] source_definition
+#   @return [ErrorSource]
+class SimpleJsonapi::Definition::Error < SimpleJsonapi::Definition::Base
+  include SimpleJsonapi::Definition::Concerns::HasLinksObject
+  include SimpleJsonapi::Definition::Concerns::HasMetaObject
+
+  attr_reader :member_definitions, :source_definition
+
+  def initialize
+    super
+    @member_definitions = {}
+    @source_definition = SimpleJsonapi::Definition::ErrorSource.new
+  end
+
+  private def initialize_dup(new_def)
+    super
+    new_def.instance_variable_set(:@source_definition, @source_definition.dup) unless @source_definition.nil?
+    new_def.instance_variable_set(:@member_definitions, @member_definitions.dup) unless @member_definitions.nil?
+  end
+
+  # @overload id(options = {}, &block)
+  # @overload id(value, options = {})
+  # @return [void]
+  def id(*args, **options, &block)
+    member_definitions[:id] = SimpleJsonapi::Definition::Attribute.new(:id, *args, **options, &block)
+  end
+
+  # @overload status(options = {}, &block)
+  # @overload status(value, options = {})
+  # @return [void]
+  def status(*args, **options, &block)
+    member_definitions[:status] = SimpleJsonapi::Definition::Attribute.new(:status, *args, **options, &block)
+  end
+
+  # @overload code(options = {}, &block)
+  # @overload code(value, options = {})
+  # @return [void]
+  def code(*args, **options, &block)
+    member_definitions[:code] = SimpleJsonapi::Definition::Attribute.new(:code, *args, **options, &block)
+  end
+
+  # @overload title(options = {}, &block)
+  # @overload title(value, options = {})
+  # @return [void]
+  def title(*args, **options, &block)
+    member_definitions[:title] = SimpleJsonapi::Definition::Attribute.new(:title, *args, **options, &block)
+  end
+
+  # @overload detail(options = {}, &block)
+  # @overload detail(value, options = {})
+  # @return [void]
+  def detail(*args, **options, &block)
+    member_definitions[:detail] = SimpleJsonapi::Definition::Attribute.new(:detail, *args, **options, &block)
+  end
+
+  # @overload about_link(options = {}, &block)
+  # @overload about_link(value, options = {})
+  # @return [void]
+  def about_link(*args, **options, &block)
+    link(:about, *args, options, &block)
+  end
+
+  # @see ErrorSource#initialize
+  # @return [void]
+  def source(&block)
+    @source_definition = SimpleJsonapi::Definition::ErrorSource.new(&block)
+  end
+end

data/lib/simple_jsonapi/definition/error_source.rb

@@ -0,0 +1,29 @@
+class SimpleJsonapi::Definition::ErrorSource < SimpleJsonapi::Definition::Base
+  # @visibility private
+  attr_reader :member_definitions
+
+  def initialize(&block)
+    super
+    @member_definitions = {}
+    instance_eval(&block) if block_given?
+  end
+
+  private def initialize_dup(new_def)
+    super
+    new_def.instance_variable_set(:@member_definitions, @member_definitions.dup) unless @member_definitions.nil?
+  end
+
+  # @overload pointer(options = {}, &block)
+  # @overload pointer(value, options = {})
+  # @return [void]
+  def pointer(*args, **options, &block)
+    member_definitions[:pointer] = SimpleJsonapi::Definition::Attribute.new(:pointer, *args, **options, &block)
+  end
+
+  # @overload parameter(options = {}, &block)
+  # @overload parameter(value, options = {})
+  # @return [void]
+  def parameter(*args, **options, &block)
+    member_definitions[:parameter] = SimpleJsonapi::Definition::Attribute.new(:parameter, *args, **options, &block)
+  end
+end

data/lib/simple_jsonapi/definition/link.rb

@@ -0,0 +1,27 @@
+# Represents a single member in a +links+ object
+# @!attribute [r] name
+#   @return [Symbol]
+class SimpleJsonapi::Definition::Link < SimpleJsonapi::Definition::Base
+  attr_reader :name
+  # @visibility private
+  attr_reader :value_proc
+
+  # @overload initialize(name, options = {}, &block)
+  # @overload initialize(name, value, options = {})
+  # @yieldparam object [Object] The resource or error.
+  # @yieldreturn [String,Hash] The link or link object.
+  # @option (see Definition::Base#initialize)
+  def initialize(name, *args, **options, &block)
+    raise ArgumentError, "A name is required" if name.blank?
+
+    super
+    @name = name
+    @value_proc = wrap_in_proc(*args, &block)
+  end
+
+  private def initialize_dup(new_def)
+    super
+    # name is a symbol, can't be duped
+    new_def.instance_variable_set(:@value_proc, @value_proc.dup)
+  end
+end

data/lib/simple_jsonapi/definition/meta.rb

@@ -0,0 +1,27 @@
+# Represents a single member in a +meta+ object
+# @!attribute [r] name
+#   @return [Symbol]
+class SimpleJsonapi::Definition::Meta < SimpleJsonapi::Definition::Base
+  attr_reader :name
+  # @visibility private
+  attr_reader :value_proc
+
+  # @overload initialize(name, options = {}, &block)
+  # @overload initialize(name, value, options = {})
+  # @yieldparam object [Object] The resource or error.
+  # @yieldreturn [String,Hash] The metadata value.
+  # @option (see Definition::Base#initialize)
+  def initialize(name, *args, **options, &block)
+    raise ArgumentError, "A name is required" if name.blank?
+
+    super
+    @name = name
+    @value_proc = wrap_in_proc(*args, &block)
+  end
+
+  private def initialize_dup(new_def)
+    super
+    # name is a symbol, can't be duped
+    new_def.instance_variable_set(:@value_proc, @value_proc.dup)
+  end
+end