jsapi 0.7.3 → 0.9.0

data/lib/jsapi/dsl/schema.rb

@@ -2,13 +2,13 @@
 
 module Jsapi
   module DSL
-    # Used to specify details of a schema.
-    class Schema < Node
+    # Used to define a schema.
+    class Schema < Base
 
       # 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({ ref: schema }) }
+        schemas.each { |schema| @meta_model.add_all_of({ ref: schema }) }
       end
 
       ##
@@ -57,7 +57,7 @@ module Jsapi
       #
       #   example 'foo'
       def example(example)
-        _meta_model.add_example(example)
+        @meta_model.add_example(example)
       end
 
       ##
@@ -77,7 +77,7 @@ module Jsapi
       #
       # See Meta::Schema::String#format for further information.
       def format(format)
-        _keyword(:format, format)
+        keyword(:format, format)
       end
 
       # Defines the kind of items that can be contained in an array.
@@ -88,12 +88,12 @@ module Jsapi
       #
       # 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}'"
+        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
+        @meta_model.items = keywords
+        Schema.new(@meta_model.items, &block) if block
       end
 
       ##
@@ -159,15 +159,15 @@ module Jsapi
       #
       # 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}'"
+        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
+        @meta_model.model = klass
       end
 
       ##
@@ -194,12 +194,12 @@ module Jsapi
       #
       # 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}'"
+        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)
+          property_model = @meta_model.add_property(name, keywords)
           Schema.new(property_model, &block) if block
         end
       end

data/lib/jsapi/dsl.rb

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

data/lib/jsapi/{helpers/invalid_value_helper.rb → invalid_value_helper.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Jsapi
-  module InvalidValueHelper
+  module InvalidValueHelper # :nodoc:
     def build_message(name, value, valid_values)
       case valid_values.count
       when 0

data/lib/jsapi/json/array.rb

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

data/lib/jsapi/json/object.rb

@@ -8,20 +8,20 @@ module Jsapi
 
       attr_reader :raw_additional_attributes, :raw_attributes
 
-      def initialize(attributes, schema, definitions)
-        schema = schema.resolve_schema(attributes, definitions, context: :request)
-        properties = schema.resolve_properties(definitions, context: :request)
+      def initialize(hash, schema, definitions, context: nil)
+        schema = schema.resolve_schema(hash, definitions, context: context)
+        properties = schema.resolve_properties(definitions, context: context)
 
         @raw_attributes = properties.transform_values do |property|
-          JSON.wrap(attributes[property.name], property.schema, definitions)
+          JSON.wrap(hash[property.name], property.schema, definitions, context: context)
         end
 
         @raw_additional_attributes =
           if (additional_properties = schema.additional_properties)
             additional_properties_schema = additional_properties.schema.resolve(definitions)
 
-            attributes.except(*properties.keys).transform_values do |value|
-              JSON.wrap(value, additional_properties_schema, definitions)
+            hash.except(*properties.keys).transform_values do |value|
+              JSON.wrap(value, additional_properties_schema, definitions, context: context)
             end
           end || {}
 

data/lib/jsapi/json.rb

@@ -13,15 +13,15 @@ module Jsapi
   # Provides a DOM for JSON values.
   module JSON
     class << self
-      def wrap(object, schema, definitions = nil)
+      def wrap(object, schema, definitions = nil, context: nil)
         schema = schema.resolve(definitions) unless definitions.nil?
 
-        object = schema.default_value(definitions, context: :request) if object.nil?
+        object = schema.default_value(definitions, context: context) if object.nil?
         return Null.new(schema) if object.nil?
 
         case schema.type
         when 'array'
-          Array.new(object, schema, definitions)
+          Array.new(object, schema, definitions, context: context)
         when 'boolean'
           Boolean.new(object, schema)
         when 'integer'
@@ -29,7 +29,7 @@ module Jsapi
         when 'number'
           Number.new(object, schema)
         when 'object'
-          Object.new(object, schema, definitions)
+          Object.new(object, schema, definitions, context: context)
         when 'string'
           String.new(object, schema)
         else

data/lib/jsapi/meta/base/attributes.rb

@@ -4,9 +4,11 @@ module Jsapi
   module Meta
     module Base
       module Attributes
+        DEFAULT_ARRAY = [].freeze
+        DEFAULT_HASH = {}.freeze
+
         # Defines an attribute.
         def attribute(name, type = Object,
-                      add_method: nil,
                       default: nil,
                       default_key: nil,
                       keys: nil,
@@ -17,26 +19,20 @@ module Jsapi
 
           instance_variable_name = "@#{name}"
 
-          # Attribute reader
-          define_method(name) do
-            value = instance_variable_get(instance_variable_name)
-            value.nil? ? default : value
-          end
-
           case type
           when Array
+            # General default
+            default ||= DEFAULT_ARRAY
+
             unless read_only
               singular_name = name.to_s.singularize
-              add_method = "add_#{singular_name}" if add_method.nil?
+              add_method = "add_#{singular_name}"
 
               type_caster = TypeCaster.new(type.first, values: values, name: singular_name)
 
               # Attribute writer
               define_method("#{name}=") do |argument|
-                if argument.nil?
-                  instance_variable_set(instance_variable_name, nil)
-                else
-                  instance_variable_set(instance_variable_name, [])
+                instance_variable_set(instance_variable_name, []).tap do
                   Array.wrap(argument).each { |element| send(add_method, element) }
                 end
               end
@@ -59,24 +55,24 @@ module Jsapi
             key_type, value_type = type.first
             key_type_caster = TypeCaster.new(key_type, values: keys, name: 'key')
 
+            # General default
+            default ||= DEFAULT_HASH
+
             # Lookup method
             define_method(singular_name) do |key = nil|
               key = default_key if key.to_s.empty?
-              send(name)&.[](key_type_caster.cast(key))
+              send(name)[key_type_caster.cast(key)]
             end
 
             unless read_only
-              add_method = "add_#{singular_name}" if add_method.nil?
+              add_method = "add_#{singular_name}"
 
               value_type_caster = TypeCaster.new(value_type, values: values)
 
               # Attribute writer
               define_method("#{name}=") do |argument|
-                if argument.nil?
-                  instance_variable_set(instance_variable_name, nil)
-                else
-                  instance_variable_set(instance_variable_name, {})
-                  argument.each { |key, value| send(add_method, key, value) }
+                instance_variable_set(instance_variable_name, {}).tap do
+                  Hash(argument).each { |key, value| send(add_method, key, value) }
                 end
               end
 
@@ -123,6 +119,12 @@ module Jsapi
               end
             end
           end
+
+          # Attribute reader
+          define_method(name) do
+            value = instance_variable_get(instance_variable_name)
+            value.nil? ? default : value
+          end
         end
 
         def attribute_names

data/lib/jsapi/meta/base/model.rb

@@ -11,13 +11,7 @@ module Jsapi
         #
         # Raises an +ArgumentError+ if at least one keyword is not supported.
         def initialize(keywords = {})
-          keywords.each do |key, value|
-            if respond_to?(method = "#{key}=")
-              public_send(method, value)
-            else
-              raise ArgumentError, "unsupported keyword: #{key}"
-            end
-          end
+          merge!(keywords)
         end
 
         def inspect(*attributes) # :nodoc:
@@ -30,6 +24,20 @@ module Jsapi
           }>"
         end
 
+        # Merges +keywords+ into the model.
+        #
+        # Raises an +ArgumentError+ if at least one keyword is not supported.
+        def merge!(keywords = {})
+          keywords.each do |key, value|
+            if respond_to?(method = "#{key}=")
+              public_send(method, value)
+            else
+              raise ArgumentError, "unsupported keyword: #{key}"
+            end
+          end
+          self
+        end
+
         # Returns false.
         def reference?
           false

data/lib/jsapi/meta/callback/model.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Meta
+    class Operation < Base::Model; end
+
+    module Callback
+      # Specifies a callback object. Applies to \OpenAPI 3.0 and higher.
+      class Model < Base::Model
+        ##
+        # :attr: operations
+        attribute :operations, { String => Operation }
+
+        undef add_operation
+
+        # Adds a callback operation.
+        #
+        # Raises an +ArgumentError+ if +expression+ is blank.
+        def add_operation(expression, keywords = {})
+          raise ArgumentError, "expression can't be blank" if expression.blank?
+
+          (@operations ||= {})[expression.to_s] = Operation.new(nil, keywords)
+        end
+
+        # Returns a hash representing the \OpenAPI callback object.
+        def to_openapi(version, definitions)
+          operations.transform_values do |operation|
+            { operation.method => operation.to_openapi(version, definitions) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Meta
+    module Callback
+      class Reference < Base::Reference
+        # Returns a hash representing the \OpenAPI reference object.
+        def to_openapi(*)
+          { '$ref': "#/components/callbacks/#{ref}" }
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/meta/callback.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'callback/model'
+require_relative 'callback/reference'
+
+module Jsapi
+  module Meta
+    module Callback
+      class << self
+        # Creates a Model or Reference.
+        def new(keywords = {})
+          return Reference.new(keywords) if keywords.key?(:ref)
+
+          Model.new(keywords)
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/meta/contact.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Meta
+    # Specifies a contact object.
+    class Contact < Base::Model
+      include OpenAPI::Extensions
+
+      ##
+      # :attr: email
+      # The email address of the contact.
+      attribute :email, String
+
+      ##
+      # :attr: name
+      # The name of the contact.
+      attribute :name, String
+
+      ##
+      # :attr: url
+      # The URL of the contact.
+      attribute :url, String
+
+      # Returns a hash representing the \OpenAPI contact object.
+      def to_openapi(*)
+        with_openapi_extensions(name: name, url: url, email: email)
+      end
+    end
+  end
+end

data/lib/jsapi/meta/defaults.rb

@@ -5,12 +5,12 @@ module Jsapi
     # Holds the default values for a particular Schema type.
     class Defaults < Base::Model
       ##
-      # :attr: read
+      # :attr: within_requests
       # The default value of parameters and properties when reading requests.
       attribute :within_requests
 
       ##
-      # :attr: write
+      # :attr: within_responses
       # The default value of properties when writing responses.
       attribute :within_responses