simple_jsonapi 1.0.0

data/lib/simple_jsonapi/node/resource/full.rb

@@ -0,0 +1,49 @@
+module SimpleJsonapi::Node::Resource
+  # Represents a single resource object.
+  class Full < Base
+    # @param options see {Node::Resource::Base#initialize} for additional parameters
+    def initialize(**options)
+      super(options)
+
+      @attributes_node = build_child_node(
+        SimpleJsonapi::Node::Attributes,
+        resource: resource,
+        resource_type: resource_type,
+        attribute_definitions: serializer.attribute_definitions,
+      )
+
+      @relationships_node = build_child_node(
+        SimpleJsonapi::Node::Relationships,
+        resource: resource,
+        resource_type: resource_type,
+        relationship_definitions: serializer.relationship_definitions,
+      )
+
+      @links_node = build_child_node(
+        SimpleJsonapi::Node::ObjectLinks,
+        object: resource,
+        link_definitions: serializer.link_definitions,
+      )
+
+      @meta_node = build_child_node(
+        SimpleJsonapi::Node::ObjectMeta,
+        object: resource,
+        meta_definitions: serializer.meta_definitions,
+      )
+    end
+
+    # @return [Hash{Symbol => Hash}]
+    def as_jsonapi
+      json = {}
+      json[:id] = resource_id
+      json[:type] = resource_type
+
+      json.merge!(@attributes_node.as_jsonapi)
+      json.merge!(@relationships_node.as_jsonapi)
+      json.merge!(@links_node.as_jsonapi)
+      json.merge!(@meta_node.as_jsonapi)
+
+      json
+    end
+  end
+end

data/lib/simple_jsonapi/node/resource/linkage.rb

@@ -0,0 +1,25 @@
+module SimpleJsonapi::Node::Resource
+  # Represents a single resource linkage object.
+  #
+  # @!attribute [r] meta
+  #   @return [Hash{Symbol => Object}]
+  class Linkage < Base
+    attr_reader :meta
+
+    # @param meta [Hash{Symbol => Object}]
+    # @param options see {Node::Resource::Base#initialize} for additional parameters
+    def initialize(meta: nil, **options)
+      super(options)
+      @meta = meta
+    end
+
+    # @return [Hash{Symbol => Hash}]
+    def as_jsonapi
+      json = {}
+      json[:id] = resource_id
+      json[:type] = resource_type
+      json[:meta] = meta if meta.present?
+      json
+    end
+  end
+end

data/lib/simple_jsonapi/parameters/fields_spec.rb

@@ -0,0 +1,45 @@
+module SimpleJsonapi::Parameters
+  # Represents the +fields+ parameter as defined by the JSONAPI spec.
+  class FieldsSpec
+    # Wraps a +fields+ parameter in a {FieldsSpec} instance.
+    # @param fields [Hash{Symbol => String},FieldsSpec]
+    def self.wrap(fields)
+      if fields.is_a?(FieldsSpec)
+        fields
+      else
+        FieldsSpec.new(fields)
+      end
+    end
+
+    # @param specs [Hash{Symbol => String,Array<String>,Array<Symbol>}]
+    #   The hash keys are resource types, and the values are lists of field names to render in the output.
+    def initialize(specs = {})
+      @data = {}
+      merge(specs) if specs.present?
+    end
+
+    # @param specs [Hash{Symbol => String,Array<String>,Array<Symbol>}]
+    #   The hash keys are resource types, and the values are lists of field names to render in the output.
+    # @return [self]
+    def merge(specs = {})
+      specs.each do |type, fields|
+        @data[type.to_sym] = Array
+                             .wrap(fields)
+                             .flat_map { |s| s.to_s.split(",") }
+                             .map { |s| s.strip.to_sym }
+      end
+      self
+    end
+
+    # @param type [String,Symbol]
+    # @return [Array<Symbol>]
+    def [](type)
+      @data[type.to_sym]
+    end
+
+    # @param type [String,Symbol]
+    def all_fields?(type)
+      @data[type.to_sym].nil?
+    end
+  end
+end

data/lib/simple_jsonapi/parameters/include_spec.rb

@@ -0,0 +1,57 @@
+module SimpleJsonapi::Parameters
+  # Represents the +include+ parameter as defined by the JSONAPI spec.
+  class IncludeSpec
+    # Wraps an +include+ parameter in an {IncludeSpec} instance.
+    # @param specs [IncludeSpec,String,Array<String>,Array<Symbol>]
+    def self.wrap(specs)
+      if specs.is_a?(IncludeSpec)
+        specs
+      else
+        IncludeSpec.new(specs)
+      end
+    end
+
+    # @param specs [String,Array<String>,Array<Symbol>]
+    #   e.g. <code>"author,comments,comments.author"</code> or <code>["author", "comments", "comments.author"]</code>
+    def initialize(*specs)
+      @data = {}
+      merge(*specs) if specs.any?
+    end
+
+    # @param specs [String,Array<String>,Array<Symbol>]
+    #   e.g. <code>"author,comments,comments.author"</code> or <code>["author", "comments", "comments.author"]</code>
+    # @return [self]
+    def merge(*specs)
+      paths = specs.flatten.flat_map { |s| s.to_s.split(",") }
+
+      paths.each do |path|
+        terms = path.split(".")
+
+        nested_spec = @data[terms.first.to_sym] ||= IncludeSpec.new
+        if terms.size > 1
+          nested_spec.merge(terms.drop(1).join("."))
+        end
+      end
+
+      self
+    end
+
+    # @param relationship_name [String,Symbol]
+    # @return [IncludeSpec]
+    def [](relationship_name)
+      @data[relationship_name.to_sym]
+    end
+
+    # @param relationship_name [String,Symbol]
+    def include?(relationship_name)
+      @data.key?(relationship_name.to_sym)
+    end
+
+    # @return [Hash]
+    def to_h
+      @data.each_with_object({}) do |(name, spec), hash|
+        hash[name] = spec.to_h
+      end
+    end
+  end
+end

data/lib/simple_jsonapi/parameters/sort_spec.rb

@@ -0,0 +1,107 @@
+module SimpleJsonapi::Parameters
+  # Represents the +sort+ parameter as defined by the JSONAPI spec.
+  class SortSpec
+    # Wraps a +sort+ parameter in a {SortSpec} instance.
+    # @param sorts [SortSpec,Hash{Symbol => String},Hash{Symbol => Array<String>}]
+    def self.wrap(sorts)
+      if sorts.is_a?(SortSpec)
+        sorts
+      else
+        SortSpec.new(sorts)
+      end
+    end
+
+    # Creates a {SortSpec} that raises an error when it's called.
+    # @return [SortSpec]
+    def self.not_supported
+      @not_supported ||= new.tap do |spec|
+        spec.instance_variable_set(:@not_supported, true)
+      end
+    end
+
+    delegate :inspect, :to_s, to: :@data
+
+    # @param specs [Hash{Symbol => String},Hash{Symbol => Array<String>}]
+    #   e.g., { comments: "-date,author" }
+    def initialize(specs = {})
+      @not_supported = nil
+      @data = Hash.new { |_h, _k| [] }
+      merge(specs) if specs.present?
+    end
+
+    # @param specs [Hash{Symbol => String},Hash{Symbol => Array<String>}]
+    #   e.g., { comments: "-date,author" } or { comments: ["-date", "author"] }
+    # @return [self]
+    def merge(specs = {})
+      specs.each do |relationship_name, field_specs|
+        @data[relationship_name.to_sym] = Array
+                                          .wrap(field_specs)
+                                          .flat_map { |fs| fs.to_s.split(",") }
+                                          .map { |fs| SortFieldSpec.new(fs) }
+                                          .presence
+      end
+      self
+    end
+
+    # @param relationship_name [String,Symbol]
+    # @return [SortFieldSpec]
+    def [](relationship_name)
+      if not_supported?
+        raise NotImplementedError, "Sorting nested relationships is not implemented."
+      else
+        @data[relationship_name.to_sym]
+      end
+    end
+
+    protected
+
+    def not_supported?
+      !!@not_supported
+    end
+  end
+
+  # Represents a single field (and direction) in a {SortSpec}.
+  # @!attribute [rw] field
+  #   @return Symbol
+  # @!attribute [rw] dir
+  #   @return [:asc,:desc]
+  class SortFieldSpec
+    attr_accessor :field, :dir
+
+    # @param spec [String]
+    def initialize(spec)
+      if spec =~ /\A(-?)(\w+)\Z/
+        self.field = $2.to_sym
+        self.dir = ($1 == '-' ? :desc : :asc)
+      else
+        raise ArgumentError, "field spec must match 'field' or '-field'"
+      end
+    end
+
+    def asc?
+      dir == :asc
+    end
+
+    def desc?
+      dir == :desc
+    end
+
+    def dup
+      SortFieldSpec.new(to_s)
+    end
+
+    def ==(other)
+      other.respond_to?(:field) && other.respond_to?(:dir) && [field, dir] == [other.field, other.dir]
+    end
+    alias_method :eql?, :==
+
+    def hash
+      [field, dir].hash
+    end
+
+    def to_s
+      "#{'-' if desc?}#{field}"
+    end
+    alias_method :inspect, :to_s
+  end
+end

data/lib/simple_jsonapi/serializer.rb

@@ -0,0 +1,89 @@
+# Subclass {Serializer} to create serializers for specific types of resources.
+class SimpleJsonapi::Serializer
+  include SimpleJsonapi::SerializerMethods
+
+  class << self
+    # @overload (see Definition::Resource#id)
+    # @return (see Definition::Resource#id)
+    def id(*args, &block)
+      definition.id(*args, &block)
+    end
+
+    # @overload (see Definition::Resource#type)
+    # @return (see Definition::Resource#type)
+    def type(*args, &block)
+      definition.type(*args, &block)
+    end
+
+    # @overload (see Definition::Resource#id)
+    # @return (see Definition::Resource#id)
+    # @overload attribute(name, options = {})
+    # @overload attribute(name, options = {}, &block)
+    # @return (see Definition::Resource#attribute)
+    def attribute(name, **options, &block)
+      definition.attribute(name, **options, &block)
+    end
+
+    # @overload (see Definition::Resource#has_one)
+    # @param (see Definition::Resource#has_one)
+    # @yieldparam (see Definition::Resource#has_one)
+    # @yieldreturn (see Definition::Resource#has_one)
+    # @return (see Definition::Resource#has_one)
+    def has_one(name, **options, &block)
+      definition.has_one(name, **options, &block)
+    end
+
+    # @overload (see Definition::Resource#has_many)
+    # @param (see Definition::Resource#has_many)
+    # @yieldparam (see Definition::Resource#has_many)
+    # @yieldreturn (see Definition::Resource#has_many)
+    # @return (see Definition::Resource#has_many)
+    def has_many(name, **options, &block)
+      definition.has_many(name, **options, &block)
+    end
+
+    # @overload (see Definition::Concerns::HasLinksObject#link)
+    # @return (see Definition::Concerns::HasLinksObject#link)
+    def link(name, *args, **options, &block)
+      definition.link(name, *args, **options, &block)
+    end
+
+    # @overload (see Definition::Concerns::HasMetaObject#meta)
+    # @return (see Definition::Concerns::HasMetaObject#meta)
+    def meta(name, *args, **options, &block)
+      definition.meta(name, *args, **options, &block)
+    end
+  end
+
+  self.definition = SimpleJsonapi::Definition::Resource.new
+
+  # @return (see Definition::Resource#id_definition)
+  def id_definition
+    definition.id_definition
+  end
+
+  # @return (see Definition::Resource#type_definition)
+  def type_definition
+    definition.type_definition
+  end
+
+  # @return (see Definition::Resource#attribute_definitions)
+  def attribute_definitions
+    definition.attribute_definitions
+  end
+
+  # @return (see Definition::Resource#relationship_definitions)
+  def relationship_definitions
+    definition.relationship_definitions
+  end
+
+  # @return (see Definition::Concerns::HasLinksObject#link_definitions)
+  def link_definitions
+    definition.link_definitions
+  end
+
+  # @return (see Definition::Concerns::HasMetaObject#meta_definitions)
+  def meta_definitions
+    definition.meta_definitions
+  end
+end

data/lib/simple_jsonapi/version.rb

@@ -0,0 +1,3 @@
+module SimpleJsonapi
+  VERSION = '1.0.0'.freeze
+end

data/simple_jsonapi.gemspec

@@ -0,0 +1,29 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'simple_jsonapi/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'simple_jsonapi'
+  spec.version       = SimpleJsonapi::VERSION
+  spec.license       = "MIT"
+  spec.authors       = ['PatientsLikeMe']
+  spec.email         = ['engineers@patientslikeme.com']
+  spec.homepage      = 'https://www.patientslikeme.com'
+
+  spec.summary       = 'A library for building JSONAPI documents in Ruby.'
+  spec.description   = 'A library for building JSONAPI documents in Ruby.'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^test/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'activesupport', '~> 5.1'
+
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'minitest-reporters'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'mocha'
+end

data/test/errors/bad_request_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+class BadRequestTest < Minitest::Spec
+  let(:error) do
+    SimpleJsonapi::Errors::BadRequest.new(
+      id: "the id",
+      status: "the status",
+      code: "the code",
+      title: "the title",
+      detail: "the detail",
+      source_pointer: "the source pointer",
+      source_parameter: "the source parameter",
+      about_link: "the about link",
+    )
+  end
+
+  describe SimpleJsonapi::Errors::BadRequest do
+    describe "properties" do
+      it "are assigned specific values" do
+        assert_equal "400", error.status
+        assert_equal "bad_request", error.code
+        assert_equal "Bad request", error.title
+      end
+
+      it "are stored" do
+        assert_equal "the id", error.id
+        assert_equal "the detail", error.detail
+        assert_equal "the source pointer", error.source_pointer
+        assert_equal "the source parameter", error.source_parameter
+        assert_equal "the about link", error.about_link
+      end
+    end
+  end
+end