jsapi 0.1.1

data/lib/jsapi/dsl/node.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module DSL
+    class Node
+      def initialize(meta_model, &block)
+        @_meta_model = meta_model
+        instance_eval(&block) if block
+      end
+
+      def method_missing(*args, &block) # :nodoc:
+        _keyword(*args, &block)
+      end
+
+      def respond_to_missing?(*args) # :nodoc:
+        _keyword?(args.first)
+      end
+
+      private
+
+      attr_reader :_meta_model
+
+      def _define(*args, &block)
+        block.call
+      rescue Error => e
+        raise e.prepend_origin(args.compact.join(' '))
+      rescue StandardError => e
+        raise Error.new(e, args.compact.join(' ').presence)
+      end
+
+      def _eval(model, klass = Node, &block)
+        return unless block
+
+        if model.reference?
+          raise Error, 'reference cannot be specified together with a block'
+        end
+
+        klass.new(model, &block)
+      end
+
+      def _find_method(name)
+        ["#{name}=", "add_#{name}"].find do |method|
+          _meta_model.respond_to?(method)
+        end
+      end
+
+      def _keyword(name, *params, &block)
+        method = _find_method(name)
+        raise "unsupported method: #{name}" unless method
+
+        _define(name) do
+          value = _meta_model.public_send(method, *params)
+          _eval(value, &block)
+        end
+      end
+
+      def _keyword?(name)
+        _find_method(name).present?
+      end
+    end
+  end
+end

data/lib/jsapi/dsl/openapi/callback.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module DSL
+    module OpenAPI
+      # Used to specify details of a callback.
+      class Callback < Node
+
+        # Defines a callback operation.
+        #
+        #   operation '{$request.query.foo}' do
+        #     parameter 'bar', type: 'string'
+        #   end
+        def operation(expression, **keywords, &block)
+          _define('operation', expression.inspect) do
+            operation_model = _meta_model.add_operation(expression, keywords)
+            Operation.new(operation_model, &block) if block
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/dsl/openapi/root.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module DSL
+    module OpenAPI
+      # Used to specify details of an OpenAPI object.
+      class Root < Node
+        include Callbacks
+      end
+    end
+  end
+end

data/lib/jsapi/dsl/openapi.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'openapi/callback'
+require_relative 'openapi/root'

data/lib/jsapi/dsl/operation.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module DSL
+    # Used to specify details of an operation.
+    class Operation < Node
+      include Callbacks
+
+      # Overrides Object#method to handle +method+ as a keyword.
+      def method(method) # :nodoc:
+        _keyword(:method, method)
+      end
+
+      # Specifies the model class to access top-level parameters by.
+      #
+      #   model Foo do
+      #     def bar
+      #       # ...
+      #     end
+      #   end
+      #
+      # +klass+ can be any subclass of Model::Base. If block is given, an
+      # anonymous class is created that inherits either from +klass+ or
+      # Model::Base.
+      def model(klass = nil, &block)
+        if block
+          klass = Class.new(klass || Model::Base)
+          klass.class_eval(&block)
+        end
+        _meta_model.model = klass
+      end
+
+      # Defines a parameter or refers a reusable parameter.
+      #
+      #   # define a parameter
+      #   parameter 'foo', type: 'string'
+      #
+      #   # define a nested parameter
+      #   parameter 'foo', type: 'object' do
+      #     property 'bar', type: 'string'
+      #   end
+      #
+      #   # refer a reusable parameter
+      #   parameter ref: 'foo'
+      #
+      # Refers the reusable parameter with the same name if neither any
+      # keywords nor a block is specified.
+      #
+      #   parameter 'foo'
+      #
+      def parameter(name = nil, **keywords, &block)
+        _define('parameter', name&.inspect) do
+          name = keywords[:ref] if name.nil?
+          keywords = { ref: name } unless keywords.any? || block
+
+          parameter_model = _meta_model.add_parameter(name, keywords)
+          _eval(parameter_model, Parameter, &block)
+        end
+      end
+
+      # Defines the request body or refers a reusable request body.
+      #
+      #   # define a request body
+      #   request_body type: 'object' do
+      #     property 'foo', type: 'string'
+      #   end
+      #
+      #   # refer a reusable request body
+      #   request_body ref: 'foo'
+      #
+      # Refers the reusable request body with the same name if neither any
+      # keywords nor a block is specified.
+      #
+      #   request_body 'foo'
+      #
+      def request_body(**keywords, &block)
+        _define('request body') do
+          _meta_model.request_body = keywords
+          _eval(_meta_model.request_body, RequestBody, &block)
+        end
+      end
+
+      # Defines a response or refers a reusable response.
+      #
+      #   # define a response
+      #   response 200, type: 'object' do
+      #     property 'foo', type: 'string'
+      #   end
+      #
+      #   # refer a reusable response
+      #   response 200, ref: 'foo'
+      #
+      # The default status is <code>"default"</code>.
+      #
+      # Refers the reusable response with the same name if neither any keywords
+      # nor a block is specified.
+      #
+      #   response 'foo'
+      #
+      # Raises an Error if name is specified together with keywords or a block.
+      def response(status_or_name = nil, name = nil, **keywords, &block)
+        _define('response', status_or_name&.inspect) do
+          raise Error, 'name cannot be specified together with keywords ' \
+                       'or a block' if name && (keywords.any? || block)
+
+          if keywords.any? || block
+            status = status_or_name
+          else
+            status = status_or_name if name
+            keywords = { ref: name || status_or_name }
+          end
+          response_model = _meta_model.add_response(status, keywords)
+          _eval(response_model, Response, &block)
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/dsl/parameter.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module DSL
+    # Used to specify details of a parameter.
+    class Parameter < Schema
+      include Examples
+    end
+  end
+end

data/lib/jsapi/dsl/request_body.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module DSL
+    # Used to specify details of a request body.
+    class RequestBody < Schema
+      include Examples
+    end
+  end
+end

data/lib/jsapi/dsl/response.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module DSL
+    # Used to specify details of a response.
+    class Response < Schema
+      include Examples
+
+      # Defines a link or refers a reusable link object.
+      #
+      #   # define a link
+      #   link 'foo', operation_id: 'bar'
+      #
+      #   # refer a reusable link
+      #   link ref: 'foo'
+      #
+      # Refers the reusable link object with the same name if neither any
+      # keywords nor a block is specified.
+      #
+      #   link 'foo'
+      #
+      def link(name = nil, **keywords, &block)
+        _define('link', name&.inspect) do
+          name = keywords[:ref] if name.nil?
+          keywords = { ref: name } unless keywords.any? || block
+
+          link_model = _meta_model.add_link(name, keywords)
+          Node.new(link_model, &block) if block
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/dsl/schema.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module DSL
+    # Used to specify details of a schema.
+    class Schema < Node
+
+      # Includes all of the properties from +schemas+. Each argument must
+      # be the name of a schema defined by ClassMethods#api_schema or
+      # Definitions#schema.
+      def all_of(*schemas)
+        schemas.each { |schema| _meta_model.add_all_of({ schema: schema }) }
+      end
+
+      # Specifies a sample matching the schema.
+      def example(example)
+        _meta_model.add_example(example)
+      end
+
+      # Overrides Kernel#format to handle +format+ as a keyword.
+      def format(format) # :nodoc:
+        _keyword(:format, format)
+      end
+
+      # Specifies the kind of items that can be contained in an array.
+      #
+      #   items do
+      #     property 'foo', type: 'string'
+      #   end
+      #
+      # Raises an Error if type is other than <code>"array"</code>.
+      def items(**keywords, &block)
+        unless _meta_model.respond_to?(:items=)
+          raise Error, "items isn't supported for '#{_meta_model.type}'"
+        end
+
+        _meta_model.items = keywords
+        Schema.new(_meta_model.items, &block) if block
+      end
+
+      # Specifies the model class to access nested object parameters by.
+      #
+      #   model Foo do
+      #     def bar
+      #       # ...
+      #     end
+      #   end
+      #
+      # +klass+ can be any subclass of Model::Base. If block is given, an
+      # anonymous class is created that inherits either from +klass+ or
+      # Model::Base.
+      #
+      # Raises an Error if type is other than <code>"object"</code>.
+      def model(klass = nil, &block)
+        unless _meta_model.respond_to?(:model=)
+          raise Error, "model isn't supported for '#{_meta_model.type}'"
+        end
+
+        if block
+          klass = Class.new(klass || Model::Base)
+          klass.class_eval(&block)
+        end
+        _meta_model.model = klass
+      end
+
+      # Defines a property.
+      #
+      #   property 'foo', type: 'string'
+      #
+      #   property 'foo' do
+      #     property 'bar', type: 'string'
+      #   end
+      #
+      # Raises an Error if type is other than <code>"object"</code>.
+      def property(name, **keywords, &block)
+        _define('property', name.inspect) do
+          unless _meta_model.respond_to?(:add_property)
+            raise Error, "property isn't supported for '#{_meta_model.type}'"
+          end
+
+          property_model = _meta_model.add_property(name, keywords)
+          Schema.new(property_model, &block) if block
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/dsl.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'dsl/callbacks'
+require_relative 'dsl/examples'
+require_relative 'dsl/error'
+require_relative 'dsl/node'
+require_relative 'dsl/schema'
+require_relative 'dsl/parameter'
+require_relative 'dsl/request_body'
+require_relative 'dsl/response'
+require_relative 'dsl/operation'
+require_relative 'dsl/openapi'
+require_relative 'dsl/definitions'
+require_relative 'dsl/class_methods'
+
+module Jsapi
+  # Provides class methods to define top-level API components.
+  # See ClassMethods for details.
+  module DSL
+    def self.included(base) # :nodoc:
+      base.extend(ClassMethods)
+    end
+  end
+end

data/lib/jsapi/json/array.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module JSON
+    # Represents a JSON array.
+    class Array < Value
+      def initialize(elements, schema, definitions)
+        super(schema)
+        @elements = Array(elements).map do |element|
+          JSON.wrap(element, schema.items, definitions)
+        end
+      end
+
+      # Returns +true+ if it contains no elements, +false+ otherwise.
+      def empty?
+        @elements.empty?
+      end
+
+      def inspect # :nodoc:
+        "#<#{self.class.name} [#{@elements.map(&:inspect).join(', ')}]>"
+      end
+
+      # See Value#validate.
+      def validate(errors)
+        return false unless super
+
+        @elements.map { |element| element.validate(errors) }.all?
+      end
+
+      def value
+        @value ||= @elements.map(&:value)
+      end
+    end
+  end
+end

data/lib/jsapi/json/boolean.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module JSON
+    # Represents +true+ or +false+.
+    class Boolean < Value
+      TRUTHY_VALUES = [true, 'True', 'true'].freeze
+
+      attr_reader :value
+
+      def initialize(value, schema)
+        super(schema)
+        @value = value.in?(TRUTHY_VALUES)
+      end
+    end
+  end
+end

data/lib/jsapi/json/integer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module JSON
+    # Represents a JSON integer.
+    class Integer < Value
+      attr_reader :value
+
+      def initialize(value, schema)
+        super(schema)
+        @value = schema.convert(value.to_i)
+      end
+    end
+  end
+end

data/lib/jsapi/json/null.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module JSON
+    # Represents +null+.
+    class Null < Value
+
+      # Returns allways +true+.
+      def empty?
+        true
+      end
+
+      def inspect # :nodoc:
+        "#<#{self.class}>"
+      end
+
+      # Returns allways +true+.
+      def null?
+        true
+      end
+
+      def value
+        nil
+      end
+    end
+  end
+end

data/lib/jsapi/json/number.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module JSON
+    # Represents a JSON number.
+    class Number < Value
+      attr_reader :value
+
+      def initialize(value, schema)
+        super(schema)
+        @value = schema.convert(value.to_f)
+      end
+    end
+  end
+end

data/lib/jsapi/json/object.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module JSON
+    # Represents a JSON object.
+    class Object < Value
+      include Model::Nestable
+
+      attr_reader :raw_attributes
+
+      def initialize(attributes, schema, definitions)
+        # Select inherriting schema on polymorphism
+        if (discriminator = schema.discriminator)
+          schema = discriminator.resolve(
+            attributes[discriminator.property_name],
+            definitions
+          )
+        end
+        # Wrap attribute values
+        @raw_attributes = schema.resolve_properties(:write, definitions)
+                                .transform_values do |property|
+          JSON.wrap(attributes[property.name], property.schema, definitions)
+        end
+
+        super(schema)
+      end
+
+      # Returns +true+ if all attributes are empty, +false+ otherwise.
+      def empty?
+        @raw_attributes.values.all?(&:empty?)
+      end
+
+      def inspect # :nodoc:
+        "#<#{self.class.name} " \
+        "#{@raw_attributes.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')}>"
+      end
+
+      # Returns a model to read attributes by.
+      def model
+        @model ||= (schema.model || Model::Base).new(self)
+      end
+
+      alias value model
+
+      # See Value#validate
+      def validate(errors)
+        return false unless super
+
+        validate_attributes(errors)
+      end
+    end
+  end
+end

data/lib/jsapi/json/string.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module JSON
+    # Represents a JSON string.
+    class String < Value
+      attr_reader :value
+
+      def initialize(value, schema)
+        super(schema)
+        @value = schema.convert(
+          case schema.format
+          when 'date'
+            value.to_date
+          when 'date-time'
+            value.to_datetime
+          else
+            value.to_s
+          end
+        )
+      end
+
+      # See Value#empty?.
+      def empty?
+        value.blank?
+      end
+    end
+  end
+end

data/lib/jsapi/json/value.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module JSON
+    # Represents a JSON value.
+    #
+    # Subclasses of Value must provide a +value+ method returning the outside
+    # representation of the JSON value.
+    class Value
+      attr_reader :schema
+
+      def initialize(schema)
+        @schema = schema
+      end
+
+      # Used by #validate to test whether or not it is empty.
+      # Returns +false+ by default.
+      def empty?
+        false
+      end
+
+      def inspect # :nodoc:
+        "#<#{self.class} #{value.inspect}>"
+      end
+
+      # Used by #validate to test whether or not it is +null+.
+      # Returns +false+ by default.
+      def null?
+        false
+      end
+
+      # Validates it against #schema. Returns +true+ if it is valid, +false+
+      # otherwise. Detected errors are added to +errors+.
+      def validate(errors)
+        unless schema.existence.reach?(self)
+          errors.add(:base, :blank)
+          return false
+        end
+        return true if null?
+
+        schema.validations.each_value.map do |validation|
+          validation.validate(value, errors)
+        end.all?
+      end
+    end
+  end
+end

data/lib/jsapi/json.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'json/value'
+require_relative 'json/array'
+require_relative 'json/boolean'
+require_relative 'json/integer'
+require_relative 'json/null'
+require_relative 'json/number'
+require_relative 'json/object'
+require_relative 'json/string'
+
+module Jsapi
+  # Provides a DOM for JSON values.
+  module JSON
+    class << self
+      def wrap(object, schema, definitions = nil)
+        schema = schema.resolve(definitions) unless definitions.nil?
+
+        object = schema.default if object.nil?
+        return Null.new(schema) if object.nil?
+
+        case schema.type
+        when 'array'
+          Array.new(object, schema, definitions)
+        when 'boolean'
+          Boolean.new(object, schema)
+        when 'integer'
+          Integer.new(object, schema)
+        when 'number'
+          Number.new(object, schema)
+        when 'object'
+          Object.new(object, schema, definitions)
+        when 'string'
+          String.new(object, schema)
+        else
+          raise "invalid type: #{schema.type}"
+        end
+      end
+    end
+  end
+end