jsapi 0.1.1

data/lib/jsapi/meta/schema/numeric.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Meta
+    module Schema
+      class Numeric < Base
+        include Conversion
+
+        ##
+        # :attr: maximum
+        # The (exclusive) maximum.
+        attribute :maximum, writer: false
+
+        ##
+        # :attr: minimum
+        # The (exclusive) minimum.
+        attribute :minimum, writer: false
+
+        ##
+        # :attr: multiple_of
+        attribute :multiple_of, writer: false
+
+        def maximum=(value) # :nodoc:
+          boundary = Boundary.from(value)
+
+          add_validation(
+            'maximum',
+            Validation::Maximum.new(
+              boundary.value,
+              exclusive: boundary.exclusive?
+            )
+          )
+          @maximum = boundary
+        end
+
+        def minimum=(value) # :nodoc:
+          boundary = Boundary.from(value)
+
+          add_validation(
+            'minimum',
+            Validation::Minimum.new(
+              boundary.value,
+              exclusive: boundary.exclusive?
+            )
+          )
+          @minimum = boundary
+        end
+
+        def multiple_of=(value) # :nodoc:
+          add_validation('multiple_of', Validation::MultipleOf.new(value))
+          @multiple_of = value
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/meta/schema/object.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Meta
+    module Schema
+      class Object < Base
+        ##
+        # :attr: all_of_references
+        attribute :all_of_references, [Reference], default: []
+
+        alias :all_of= :all_of_references=
+        alias :add_all_of :add_all_of_reference
+
+        ##
+        # :attr: discriminator
+        attribute :discriminator, Discriminator
+
+        ##
+        # :attr: model
+        # The model class to access nested object parameters by. The default
+        # model class is Model::Base.
+        attribute :model, Class, default: Model::Base
+
+        ##
+        # :attr: properties
+        # The properties.
+        attribute :properties, { String => Property }, writer: false, default: {}
+
+        def add_property(name, keywords = {}) # :nodoc:
+          (@properties ||= {})[name.to_s] = Property.new(name, **keywords)
+        end
+
+        def resolve_properties(access, definitions)
+          properties = merge_properties(definitions, [])
+
+          case access
+          when :read
+            properties.reject { |_k, v| v.write_only? }
+          when :write
+            properties.reject { |_k, v| v.read_only? }
+          else
+            properties
+          end
+        end
+
+        def to_json_schema # :nodoc:
+          super.merge(
+            allOf: all_of_references.map(&:to_json_schema).presence,
+            properties: properties.transform_values(&:to_json_schema),
+            required: properties.values.select(&:required?).map(&:name)
+          ).compact
+        end
+
+        def to_openapi(version) # :nodoc:
+          super.merge(
+            allOf: all_of_references.map do |schema|
+              schema.to_openapi(version)
+            end.presence,
+            discriminator: discriminator&.to_openapi(version),
+            properties: properties.transform_values do |property|
+              property.to_openapi(version)
+            end,
+            required: properties.values.select(&:required?).map(&:name)
+          ).compact
+        end
+
+        protected
+
+        def merge_properties(definitions, path)
+          return properties unless all_of_references.present?
+
+          {}.tap do |properties|
+            all_of_references.each do |reference|
+              schema = reference.resolve(definitions)
+              raise "circular reference: #{reference.schema}" if schema.in?(path)
+
+              properties.merge!(schema.merge_properties(definitions, path + [self]))
+            end
+            properties.merge!(self.properties)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/meta/schema/reference.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Meta
+    module Schema
+      class Reference < BaseReference
+        alias :schema :ref
+        alias :schema= :ref=
+
+        ##
+        # :attr: existence
+        # The level of Existence. The default level of existence
+        # is +ALLOW_OMITTED+.
+        attribute :existence, Existence, default: Existence::ALLOW_OMITTED
+
+        def resolve(definitions) # :nodoc:
+          schema = super
+          return schema if existence < Existence::ALLOW_EMPTY
+
+          Delegator.new(schema, [existence, schema.existence].max)
+        end
+
+        # Returns a hash representing the \JSON \Schema reference object.
+        def to_json_schema
+          { '$ref': "#/definitions/#{ref}" }
+        end
+
+        # Returns a hash representing the \OpenAPI reference object.
+        def to_openapi(version)
+          version = OpenAPI::Version.from(version)
+          path = version.major == 2 ? 'definitions' : 'components/schemas'
+
+          { '$ref': "#/#{path}/#{ref}" }
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/meta/schema/string.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Meta
+    module Schema
+      class String < Base
+        include Conversion
+
+        ##
+        # :attr: format
+        # The optional format of a string. Possible values are:
+        #
+        # - <code>"date"</code>
+        # - <code>"date-time"</code>
+        #
+        attribute :format, ::String, values: %w[date date-time]
+
+        ##
+        # :attr: max_length
+        # The maximum length of a string.
+        attribute :max_length, writer: false
+
+        ##
+        # :attr: min_length
+        # The minimum length of a string.
+        attribute :min_length, writer: false
+
+        ##
+        # :attr: pattern
+        # The regular expression a string must match.
+        attribute :pattern, writer: false
+
+        def max_length=(value) # :nodoc:
+          add_validation('max_length', Validation::MaxLength.new(value))
+          @max_length = value
+        end
+
+        def min_length=(value) # :nodoc:
+          add_validation('min_length', Validation::MinLength.new(value))
+          @min_length = value
+        end
+
+        def pattern=(value) # :nodoc:
+          add_validation('pattern', Validation::Pattern.new(value))
+          @pattern = value
+        end
+
+        def to_json_schema # :nodoc:
+          format ? super.merge(format: format) : super
+        end
+
+        def to_openapi(*) # :nodoc:
+          format ? super.merge(format: format) : super
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/meta/schema/validation/base.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Meta
+    module Schema
+      module Validation
+        class Base
+          def self.keyword
+            @keyword ||= name.demodulize.camelize(:lower).to_sym
+          end
+
+          attr_reader :value
+
+          def initialize(value)
+            @value = value
+          end
+
+          def to_json_schema_validation
+            { self.class.keyword => value }
+          end
+
+          def to_openapi_validation(*)
+            to_json_schema_validation
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/meta/schema/validation/enum.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Meta
+    module Schema
+      module Validation
+        class Enum < Base
+          def initialize(value)
+            unless value.respond_to?(:include?)
+              raise ArgumentError, "invalid enum: #{value.inspect}"
+            end
+
+            super
+          end
+
+          def validate(value, errors)
+            return true if self.value.include?(value)
+
+            errors.add(:base, :inclusion)
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/meta/schema/validation/max_items.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Meta
+    module Schema
+      module Validation
+        class MaxItems < Base
+          def initialize(value)
+            unless value.respond_to?(:<=)
+              raise ArgumentError, "invalid max items: #{value.inspect}"
+            end
+
+            super
+          end
+
+          def validate(value, errors)
+            return true if value.size <= self.value
+
+            errors.add(:base, :invalid)
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/meta/schema/validation/max_length.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Meta
+    module Schema
+      module Validation
+        class MaxLength < Base
+          def initialize(value)
+            unless value.respond_to?(:<=)
+              raise ArgumentError, "invalid max length: #{value.inspect}"
+            end
+
+            super
+          end
+
+          def validate(value, errors)
+            return true if value.to_s.length <= self.value
+
+            errors.add(:base, :too_long, count: self.value)
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/meta/schema/validation/maximum.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Meta
+    module Schema
+      module Validation
+        class Maximum < Base
+          attr_reader :exclusive
+
+          def initialize(value, exclusive: false)
+            if exclusive
+              raise ArgumentError, "invalid exclusive maximum: #{value.inspect}" unless value.respond_to?(:<)
+            else
+              raise ArgumentError, "invalid maximum: #{value.inspect}" unless value.respond_to?(:<=)
+            end
+
+            super(value)
+            @exclusive = exclusive
+          end
+
+          def validate(value, errors)
+            if exclusive
+              return true if value < self.value
+
+              errors.add(:base, :less_than, count: self.value)
+            else
+              return true if value <= self.value
+
+              errors.add(:base, :less_than_or_equal_to, count: self.value)
+            end
+            false
+          end
+
+          def to_json_schema_validation
+            return super unless exclusive
+
+            { exclusiveMaximum: value }
+          end
+
+          def to_openapi_validation(version)
+            version = OpenAPI::Version.from(version)
+            return to_json_schema_validation if version.major == 3 && version.minor == 1
+            return super unless exclusive
+
+            { maximum: value, exclusiveMaximum: true }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/meta/schema/validation/min_items.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Meta
+    module Schema
+      module Validation
+        class MinItems < Base
+          def initialize(value)
+            unless value.respond_to?(:>=)
+              raise ArgumentError, "invalid min items: #{value.inspect}"
+            end
+
+            super
+          end
+
+          def validate(value, errors)
+            return true if value.size >= self.value
+
+            errors.add(:base, :invalid)
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/meta/schema/validation/min_length.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Meta
+    module Schema
+      module Validation
+        class MinLength < Base
+          def initialize(value)
+            unless value.respond_to?(:>=)
+              raise ArgumentError, "invalid min length: #{value.inspect}"
+            end
+
+            super
+          end
+
+          def validate(value, errors)
+            return true if value.to_s.length >= self.value
+
+            errors.add(:base, :too_short, count: self.value)
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/meta/schema/validation/minimum.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Meta
+    module Schema
+      module Validation
+        class Minimum < Base
+          attr_reader :exclusive
+
+          def initialize(value, exclusive: false)
+            if exclusive
+              raise ArgumentError, "invalid exclusive minimum: #{value.inspect}" unless value.respond_to?(:>)
+            else
+              raise ArgumentError, "invalid minimum: #{value.inspect}" unless value.respond_to?(:>=)
+            end
+
+            super(value)
+            @exclusive = exclusive
+          end
+
+          def validate(value, errors)
+            if exclusive
+              return true if value > self.value
+
+              errors.add(:base, :greater_than, count: self.value)
+            else
+              return true if value >= self.value
+
+              errors.add(:base, :greater_than_or_equal_to, count: self.value)
+            end
+            false
+          end
+
+          def to_json_schema_validation
+            return super unless exclusive
+
+            { exclusiveMinimum: value }
+          end
+
+          def to_openapi_validation(version)
+            version = OpenAPI::Version.from(version)
+            return to_json_schema_validation if version.major == 3 && version.minor == 1
+            return super unless exclusive
+
+            { minimum: value, exclusiveMinimum: true }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/meta/schema/validation/multiple_of.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Meta
+    module Schema
+      module Validation
+        class MultipleOf < Base
+          def initialize(value)
+            raise ArgumentError, "invalid multiple of: #{value.inspect}" unless value.respond_to?(:%)
+
+            super
+          end
+
+          def validate(value, errors)
+            return true if (value % self.value).zero?
+
+            errors.add(:base, :invalid)
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/meta/schema/validation/pattern.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Meta
+    module Schema
+      module Validation
+        class Pattern < Base
+          def initialize(value)
+            unless value.is_a?(Regexp)
+              raise ArgumentError, "invalid pattern: #{value.inspect}"
+            end
+
+            super
+          end
+
+          def validate(value, errors)
+            return true if value.to_s.match?(self.value)
+
+            errors.add(:base, :invalid)
+            false
+          end
+
+          def to_json_schema_validation
+            { pattern: value.source }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/meta/schema/validation.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'validation/base'
+require_relative 'validation/enum'
+require_relative 'validation/max_items'
+require_relative 'validation/max_length'
+require_relative 'validation/maximum'
+require_relative 'validation/min_items'
+require_relative 'validation/min_length'
+require_relative 'validation/minimum'
+require_relative 'validation/multiple_of'
+require_relative 'validation/pattern'

data/lib/jsapi/meta/schema.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative 'schema/conversion'
+require_relative 'schema/boundary'
+require_relative 'schema/delegator'
+require_relative 'schema/reference'
+require_relative 'schema/discriminator'
+require_relative 'schema/base'
+require_relative 'schema/boolean'
+require_relative 'schema/array'
+require_relative 'schema/numeric'
+require_relative 'schema/integer'
+require_relative 'schema/number'
+require_relative 'schema/object'
+require_relative 'schema/string'
+require_relative 'schema/validation'
+
+module Jsapi
+  module Meta
+    module Schema
+      class << self
+        # Creates a new schema model or reference. The +:type+ keyword determines
+        # the type of the schema to be created. Possible types are:
+        #
+        # - <code>"array"</code>
+        # - <code>"boolean"</code>
+        # - <code>"integer"</code>
+        # - <code>"number"</code>
+        # - <code>"object"</code>
+        # - <code>"string"</code>
+        #
+        # The default type is <code>"object"</code>.
+        #
+        # Raises an InvalidArgumentError if the given type is invalid.
+        def new(keywords = {})
+          if keywords.key?(:ref) || keywords.key?(:schema)
+            return Reference.new(keywords)
+          end
+
+          type = keywords[:type]
+          case type&.to_s
+          when 'array'
+            Array
+          when 'boolean'
+            Boolean
+          when 'integer'
+            Integer
+          when 'number'
+            Number
+          when 'object', nil
+            Object
+          when 'string'
+            String
+          else
+            raise InvalidArgumentError.new('type', type, Base::TYPES)
+          end.new(keywords.except(:type))
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/meta.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'meta/invalid_argument_error'
+require_relative 'meta/reference_error'
+require_relative 'meta/attributes'
+require_relative 'meta/base'
+require_relative 'meta/base_reference'
+require_relative 'meta/openapi'
+require_relative 'meta/example'
+require_relative 'meta/existence'
+require_relative 'meta/property'
+require_relative 'meta/schema'
+require_relative 'meta/request_body'
+require_relative 'meta/parameter'
+require_relative 'meta/response'
+require_relative 'meta/operation'
+require_relative 'meta/rescue_handler'
+require_relative 'meta/definitions'
+
+module Jsapi
+  # The meta model.
+  module Meta end
+end

data/lib/jsapi/model/attributes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Model
+    module Attributes
+      extend ActiveSupport::Concern
+
+      included do
+        delegate :[], :attribute?, :attributes, to: :nested
+      end
+
+      def method_missing(*args) # :nodoc:
+        name = args.first
+        attribute?(name) ? self[name] : super
+      end
+
+      def respond_to_missing?(param1, _param2) # :nodoc:
+        attribute?(param1) ? true : super
+      end
+    end
+  end
+end