apigen 0.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d490568fbf42afb3f2c5ee580739f02bf13403444c0c852004d44b9dc6a1c209
+  data.tar.gz: be1468d137a7efcee80ab31f496a7ffe74bd7eb09cdcf7514e8d569a79789d15
+SHA512:
+  metadata.gz: 4f55e4d77ef95e85938b51306fa0f0cc09ec5d6371eff815d50033760bed8a792d525bd2e7439dbec4eb324022ca88c176cd30b9674db2920d5bfd29a4e3ce4e
+  data.tar.gz: 6b2fc1dfc6ab532aa69ceb4d0c6d2c6143d7604bfd0002fe1317209ef245842e12fc620a508ea72edc69049307f43a455048f26836f812c327c354e38a32de42

data/lib/apigen/formats/jsonschema.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Apigen
+  module Formats
+    module JsonSchema
+      ##
+      # JSON Schema Draft 7 generator.
+      module Draft7
+        class << self
+          def generate(api)
+            JSON.pretty_generate definitions(api)
+          end
+
+          private
+
+          def definitions(api)
+            {
+              '$schema' => 'http://json-schema.org/draft-07/schema#',
+              'definitions' => api.models.map { |key, model| [key.to_s, schema(api, model.type, model.description, model.example)] }.to_h
+            }
+          end
+
+          def schema(api, type, description = nil, example = nil)
+            schema = schema_without_description(api, type)
+            schema['description'] = description unless description.nil?
+            schema['example'] = example unless example.nil?
+            schema
+          end
+
+          def schema_without_description(api, type)
+            case type
+            when Apigen::ObjectType
+              object_schema(api, type)
+            when Apigen::ArrayType
+              array_schema(api, type)
+            when Apigen::OptionalType
+              raise 'OptionalType fields are only supported within object types.'
+            when :string
+              {
+                'type' => 'string'
+              }
+            when :int32
+              {
+                'type' => 'integer',
+                'format' => 'int32'
+              }
+            when :bool
+              {
+                'type' => 'boolean'
+              }
+            else
+              return { '$ref' => "#/definitions/#{type}" } if api.models.key? type
+              raise "Unsupported type: #{type}."
+            end
+          end
+
+          def object_schema(api, object_type)
+            {
+              'type' => 'object',
+              'properties' => object_type.properties.map { |name, property| object_property(api, name, property) }.to_h,
+              'required' => object_type.properties.reject { |_name, property| property.type.is_a? Apigen::OptionalType }.map { |name, _property| name.to_s }
+            }
+          end
+
+          def object_property(api, name, property)
+            # A property is never optional, because we specify which are required on the schema itself.
+            actual_type = property.type.is_a?(Apigen::OptionalType) ? property.type.type : property.type
+            [name.to_s, schema(api, actual_type, property.description, property.example)]
+          end
+
+          def array_schema(api, array_type)
+            {
+              'type' => 'array',
+              'items' => schema(api, array_type.type)
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/apigen/formats/openapi.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Apigen
+  module Formats
+    module OpenAPI
+      ##
+      # OpenAPI 3 generator.
+      module V3
+        class << self
+          def generate(api)
+            # TODO: Allow overriding any of the hardcoded elements.
+            {
+              'openapi' => '3.0.0',
+              'info' => {
+                'version' => '1.0.0',
+                'title' => 'API',
+                'description' => api.description,
+                'termsOfService' => '',
+                'contact' => {
+                  'name' => ''
+                },
+                'license' => {
+                  'name' => ''
+                }
+              },
+              'servers' => [
+                {
+                  'url' => 'http://localhost'
+                }
+              ],
+              'paths' => paths(api),
+              'components' => {
+                'schemas' => definitions(api)
+              }
+            }.to_yaml
+          end
+
+          private
+
+          def paths(api)
+            hash = {}
+            api.endpoints.each do |endpoint|
+              parameters = []
+              parameters.concat(endpoint.path_parameters.properties.map { |name, property| path_parameter(api, name, property) })
+              parameters.concat(endpoint.query_parameters.properties.map { |name, property| query_parameter(api, name, property) })
+              responses = endpoint.outputs.map { |output| response(api, output) }.to_h
+              operation = {
+                'operationId' => endpoint.name.to_s,
+                'parameters' => parameters,
+                'responses' => responses
+              }
+              operation['description'] = endpoint.description unless endpoint.description.nil?
+              operation['requestBody'] = input(api, endpoint.input) if endpoint.input
+              hash[endpoint.path] ||= {}
+              hash[endpoint.path][endpoint.method.to_s] = operation
+            end
+            hash
+          end
+
+          def path_parameter(api, name, property)
+            parameter = {
+              'in' => 'path',
+              'name' => name.to_s,
+              'required' => true,
+              'schema' => schema(api, property.type)
+            }
+            parameter['description'] = property.description unless property.description.nil?
+            parameter['example'] = property.example unless property.example.nil?
+            parameter
+          end
+
+          def query_parameter(api, name, property)
+            optional = property.type.is_a?(Apigen::OptionalType)
+            actual_type = optional ? property.type.type : property.type
+            parameter = {
+              'in' => 'query',
+              'name' => name.to_s,
+              'required' => !optional,
+              'schema' => schema(api, actual_type)
+            }
+            parameter['description'] = property.description unless property.description.nil?
+            parameter['example'] = property.example unless property.example.nil?
+            parameter
+          end
+
+          def input(api, property)
+            parameter = {
+              'required' => true,
+              'content' => {
+                'application/json' => {
+                  'schema' => schema(api, property.type)
+                }
+              }
+            }
+            parameter['description'] = property.description unless property.description.nil?
+            parameter['example'] = property.example unless property.example.nil?
+            parameter
+          end
+
+          def response(api, output)
+            response = {}
+            response['description'] = output.description unless output.description.nil?
+            response['example'] = output.example unless output.example.nil?
+            if output.type != :void
+              response['content'] = {
+                'application/json' => {
+                  'schema' => schema(api, output.type)
+                }
+              }
+            end
+            [output.status.to_s, response]
+          end
+
+          def definitions(api)
+            hash = {}
+            api.models.each do |key, model|
+              hash[key.to_s] = schema(api, model.type, model.description, model.example)
+            end
+            hash
+          end
+
+          def schema(api, type, description = nil, example = nil)
+            schema = schema_without_description(api, type)
+            schema['description'] = description unless description.nil?
+            schema['example'] = example unless example.nil?
+            schema
+          end
+
+          def schema_without_description(api, type)
+            case type
+            when Apigen::ObjectType
+              object_schema(api, type)
+            when Apigen::ArrayType
+              array_schema(api, type)
+            when Apigen::OptionalType
+              raise 'OptionalType fields are only supported within object types.'
+            when :string
+              {
+                'type' => 'string'
+              }
+            when :int32
+              {
+                'type' => 'integer',
+                'format' => 'int32'
+              }
+            when :bool
+              {
+                'type' => 'boolean'
+              }
+            else
+              return { '$ref' => "#/components/schemas/#{type}" } if api.models.key? type
+              raise "Unsupported type: #{type}."
+            end
+          end
+
+          def object_schema(api, object_type)
+            {
+              'type' => 'object',
+              'properties' => object_type.properties.map { |name, property| object_property(api, name, property) }.to_h,
+              'required' => object_type.properties.reject { |_name, property| property.type.is_a? Apigen::OptionalType }.map { |name, _property| name.to_s }
+            }
+          end
+
+          def object_property(api, name, property)
+            # A property is never optional, because we specify which are required on the schema itself.
+            actual_type = property.type.is_a?(Apigen::OptionalType) ? property.type.type : property.type
+            [name.to_s, schema(api, actual_type, property.description, property.example)]
+          end
+
+          def array_schema(api, array_type)
+            {
+              'type' => 'array',
+              'items' => schema(api, array_type.type)
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/apigen/formats/swagger.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Apigen
+  module Formats
+    module Swagger
+      ##
+      # Swagger 2 (aka OpenAPI 2) generator.
+      module V2
+        class << self
+          def generate(api)
+            # TODO: Allow overriding any of the hardcoded elements.
+            {
+              'swagger' => '2.0',
+              'info' => {
+                'version' => '1.0.0',
+                'title' => 'API',
+                'description' => api.description,
+                'termsOfService' => '',
+                'contact' => {
+                  'name' => ''
+                },
+                'license' => {
+                  'name' => ''
+                }
+              },
+              'host' => 'localhost',
+              'basePath' => '/',
+              'schemes' => %w[
+                http
+                https
+              ],
+              'consumes' => [
+                'application/json'
+              ],
+              'produces' => [
+                'application/json'
+              ],
+              'paths' => paths(api),
+              'definitions' => definitions(api)
+            }.to_yaml
+          end
+
+          private
+
+          def paths(api)
+            hash = {}
+            api.endpoints.each do |endpoint|
+              parameters = []
+              parameters.concat(endpoint.path_parameters.properties.map { |name, property| path_parameter(api, name, property) })
+              parameters.concat(endpoint.query_parameters.properties.map { |name, property| query_parameter(api, name, property) })
+              parameters << input_parameter(api, endpoint.input) if endpoint.input
+              responses = endpoint.outputs.map { |output| response(api, output) }.to_h
+              hash[endpoint.path] ||= {}
+              hash[endpoint.path][endpoint.method.to_s] = {
+                'parameters' => parameters,
+                'responses' => responses
+              }
+              hash[endpoint.path][endpoint.method.to_s]['description'] = endpoint.description unless endpoint.description.nil?
+            end
+            hash
+          end
+
+          def path_parameter(api, name, property)
+            {
+              'in' => 'path',
+              'name' => name.to_s,
+              'required' => true
+            }.merge(schema(api, property.type, property.description, property.example))
+          end
+
+          def query_parameter(api, name, property)
+            optional = property.type.is_a?(Apigen::OptionalType)
+            actual_type = optional ? property.type.type : property.type
+            {
+              'in' => 'query',
+              'name' => name.to_s,
+              'required' => !optional
+            }.merge(schema(api, actual_type, property.description, property.example))
+          end
+
+          def input_parameter(api, property)
+            parameter = {
+              'name' => 'input',
+              'in' => 'body',
+              'required' => true,
+              'schema' => schema(api, property.type)
+            }
+            parameter['description'] = property.description unless property.description.nil?
+            parameter['example'] = property.example unless property.example.nil?
+            parameter
+          end
+
+          def response(api, output)
+            response = {}
+            response['description'] = output.description unless output.description.nil?
+            response['example'] = output.example unless output.example.nil?
+            response['schema'] = schema(api, output.type) if output.type != :void
+            [output.status.to_s, response]
+          end
+
+          def definitions(api)
+            api.models.map { |key, model| [key.to_s, schema(api, model.type, model.description, model.example)] }.to_h
+          end
+
+          def schema(api, type, description = nil, example = nil)
+            schema = schema_without_description(api, type)
+            schema['description'] = description unless description.nil?
+            schema['example'] = example unless example.nil?
+            schema
+          end
+
+          def schema_without_description(api, type)
+            case type
+            when Apigen::ObjectType
+              object_schema(api, type)
+            when Apigen::ArrayType
+              array_schema(api, type)
+            when Apigen::OptionalType
+              raise 'OptionalType fields are only supported within object types.'
+            when :string
+              {
+                'type' => 'string'
+              }
+            when :int32
+              {
+                'type' => 'integer',
+                'format' => 'int32'
+              }
+            when :bool
+              {
+                'type' => 'boolean'
+              }
+            else
+              return { '$ref' => "#/definitions/#{type}" } if api.models.key? type
+              raise "Unsupported type: #{type}."
+            end
+          end
+
+          def object_schema(api, object_type)
+            {
+              'type' => 'object',
+              'properties' => object_type.properties.map { |name, property| object_property(api, name, property) }.to_h,
+              'required' => object_type.properties.reject { |_name, property| property.type.is_a? Apigen::OptionalType }.map { |name, _property| name.to_s }
+            }
+          end
+
+          def object_property(api, name, property)
+            # A property is never optional, because we specify which are required on the schema itself.
+            actual_type = property.type.is_a?(Apigen::OptionalType) ? property.type.type : property.type
+            [name.to_s, schema(api, actual_type, property.description, property.example)]
+          end
+
+          def array_schema(api, array_type)
+            {
+              'type' => 'array',
+              'items' => schema(api, array_type.type)
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/apigen/model.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require 'set'
+require_relative './util'
+
+module Apigen
+  PRIMARY_TYPES = Set.new %i[string int32 bool void]
+
+  ##
+  # ModelRegistry is where all model definitions are stored.
+  class ModelRegistry
+    attr_reader :models
+
+    def initialize
+      @models = {}
+    end
+
+    def model(name, &block)
+      model = Apigen::Model.new name
+      raise 'You must pass a block when calling `model`.' unless block_given?
+      model.instance_eval(&block)
+      @models[model.name] = model
+    end
+
+    def validate
+      @models.each do |_key, model|
+        model.validate self
+      end
+    end
+
+    def check_type(type)
+      if type.is_a? Symbol
+        raise "Unknown type :#{type}." unless @models.key?(type) || PRIMARY_TYPES.include?(type)
+      elsif type.is_a?(ObjectType) || type.is_a?(ArrayType) || type.is_a?(OptionalType)
+        type.validate self
+      else
+        raise "Cannot process type #{type.class.name}"
+      end
+    end
+
+    def to_s
+      @models.map do |key, model|
+        "#{key}: #{model}"
+      end.join "\n"
+    end
+  end
+
+  ##
+  # Model represents a data model with a specific name, e.g. "User" with an object type.
+  class Model
+    attr_reader :name
+    attribute_setter_getter :description
+    attribute_setter_getter :example
+
+    def initialize(name)
+      @name = name
+      @type = nil
+      @description = nil
+    end
+
+    def type(shape = nil, &block)
+      return @type unless shape
+      @type = Model.type shape, &block
+    end
+
+    def self.type(shape, &block)
+      if shape.to_s.end_with? '?'
+        shape = shape[0..-2].to_sym
+        optional = true
+      else
+        optional = false
+      end
+      case shape
+      when :object
+        object = ObjectType.new
+        object.instance_eval(&block)
+        type = object
+      when :array
+        array = ArrayType.new
+        array.instance_eval(&block)
+        type = array
+      when :optional
+        optional = OptionalType.new
+        optional.instance_eval(&block)
+        type = optional
+      else
+        type = shape
+      end
+      optional ? OptionalType.new(type) : type
+    end
+
+    def validate(model_registry)
+      raise 'One of the models is missing a name.' unless @name
+      raise "Use `type :model_type [block]` to assign a type to :#{@name}." unless @type
+      model_registry.check_type @type
+    end
+
+    def to_s
+      @type.to_s
+    end
+  end
+
+  ##
+  # ObjectType represents an object type, with specific fields.
+  class ObjectType
+    attr_reader :properties
+
+    def initialize
+      @properties = {}
+    end
+
+    # rubocop:disable Style/MethodMissingSuper
+    def method_missing(field_name, *args, &block)
+      raise "Field :#{field_name} is defined multiple times." if @properties.key? field_name
+      field_type = args[0]
+      field_description = args[1]
+      block_called = false
+      if block_given?
+        block_wrapper = lambda do
+          block_called = true
+          yield
+        end
+      end
+      property = ObjectProperty.new(
+        Apigen::Model.type(field_type, &block_wrapper),
+        field_description
+      )
+      property.instance_eval(&block) if block_given? && !block_called
+      @properties[field_name] = property
+    end
+    # rubocop:enable Style/MethodMissingSuper
+
+    def respond_to_missing?(_method_name, _include_private = false)
+      true
+    end
+
+    def validate(model_registry)
+      @properties.each do |_key, property|
+        model_registry.check_type property.type
+      end
+    end
+
+    def to_s
+      repr ''
+    end
+
+    def repr(indent)
+      repr = '{'
+      @properties.each do |key, property|
+        type_repr = if property.type.respond_to? :repr
+                      property.type.repr(indent + '  ')
+                    else
+                      property.type.to_s
+                    end
+        repr += "\n#{indent}  #{key}: #{type_repr}"
+      end
+      repr += "\n#{indent}}"
+      repr
+    end
+  end
+
+  ##
+  # ObjectProperty is a specific property in an ObjectType.
+  class ObjectProperty
+    attr_reader :type
+    attribute_setter_getter :description
+    attribute_setter_getter :example
+
+    def initialize(type, description = nil)
+      @type = type
+      @description = description
+    end
+  end
+
+  ##
+  # ArrayType represents an array type, with a given item type.
+  class ArrayType
+    def initialize(type = nil)
+      @type = type
+    end
+
+    def type(item_type = nil, &block)
+      return @type unless item_type
+      @type = Apigen::Model.type item_type, &block
+    end
+
+    def validate(model_registry)
+      raise 'Use `type [typename]` to specify the type of types in an array.' unless @type
+      model_registry.check_type @type
+    end
+
+    def to_s
+      repr ''
+    end
+
+    def repr(indent)
+      type_repr = if @type.respond_to? :repr
+                    @type.repr indent
+                  else
+                    @type.to_s
+                  end
+      "ArrayType<#{type_repr}>"
+    end
+  end
+
+  ##
+  # OptionalType represents a type whose value may be absent.
+  class OptionalType
+    def initialize(type = nil)
+      @type = type
+    end
+
+    def type(item_type = nil, &block)
+      return @type unless item_type
+      @type = Apigen::Model.type item_type, &block
+    end
+
+    def validate(model_registry)
+      raise 'Use `type [typename]` to specify an optional type.' unless @type
+      model_registry.check_type @type
+    end
+
+    def to_s
+      repr ''
+    end
+
+    def repr(indent)
+      type_repr = if @type.respond_to? :repr
+                    @type.repr indent
+                  else
+                    @type.to_s
+                  end
+      "OptionalType<#{type_repr}>"
+    end
+  end
+end

data/lib/apigen/rest.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+require_relative './model'
+require_relative './util'
+
+PATH_PARAMETER_REGEX = /\{(\w+)\}/
+
+module Apigen
+  ##
+  # Rest contains what you need to declare a REST-ish API.
+  module Rest
+    ##
+    # Declares an API.
+    def self.api(&block)
+      api = Api.new
+      api.instance_eval(&block)
+      api.validate
+      api
+    end
+
+    ##
+    # Api is a self-contained definition of a REST API, includings its endpoints and data types.
+    class Api
+      attr_reader :endpoints
+      attribute_setter_getter :description
+
+      def initialize
+        @description = ''
+        @endpoints = []
+        @model_registry = Apigen::ModelRegistry.new
+      end
+
+      ##
+      # Declares a specific endpoint.
+      def endpoint(name, &block)
+        endpoint = Endpoint.new name
+        @endpoints << endpoint
+        endpoint.instance_eval(&block)
+      end
+
+      ##
+      # Declares a data model.
+      def model(name, &block)
+        @model_registry.model name, &block
+      end
+
+      def models
+        @model_registry.models
+      end
+
+      def validate
+        @model_registry.validate
+        @endpoints.each do |e|
+          e.validate @model_registry
+        end
+      end
+
+      def to_s
+        repr = "Endpoints:\n\n"
+        repr += @endpoints.map(&:to_s).join "\n"
+        repr += "\n\nTypes:\n\n"
+        repr += @model_registry.to_s
+        repr
+      end
+    end
+
+    ##
+    # Endpoint is a definition of a specific endpoint in the API, e.g. /users with GET method.
+    class Endpoint
+      attribute_setter_getter :name
+      attribute_setter_getter :description
+      attr_reader :outputs
+      attr_reader :path_parameters
+      attr_reader :query_parameters
+
+      def initialize(name)
+        @name = name
+        @method = nil
+        @path = nil
+        @path_parameters = Apigen::ObjectType.new
+        @query_parameters = Apigen::ObjectType.new
+        @input = nil
+        @outputs = []
+        @description = nil
+      end
+
+      #
+      # Declares the HTTP method.
+      def method(method = nil)
+        return @method unless method
+        case method
+        when :get, :post, :put, :delete
+          @method = method
+        else
+          raise "Unknown HTTP method :#{method}."
+        end
+      end
+
+      #
+      # Declares the endpoint path relative to the host.
+      def path(path = nil, &block)
+        return @path unless path
+        @path = path
+        if PATH_PARAMETER_REGEX.match path
+          set_path_parameters(path, &block)
+        elsif block_given?
+          raise 'A path block was provided but no URL parameter was found.'
+        end
+      end
+
+      #
+      # Declares query parameters.
+      def query(&block)
+        raise 'A block must be passed to define query fields.' unless block_given?
+        @query_parameters.instance_eval(&block)
+      end
+
+      ##
+      # Declares the input type of an endpoint.
+      def input(&block)
+        return @input unless block_given?
+        @input = Input.new
+        @input.instance_eval(&block)
+      end
+
+      ##
+      # Declares the output of an endpoint for a given status code.
+      def output(name, &block)
+        output = Output.new name
+        @outputs << output
+        output.instance_eval(&block)
+        output
+      end
+
+      def validate(model_registry)
+        validate_properties
+        validate_input(model_registry)
+        validate_path_parameters(model_registry)
+        validate_outputs(model_registry)
+      end
+
+      def to_s
+        repr = "#{@name}: #{@input}"
+        @outputs.each do |output|
+          repr += "\n-> #{output}"
+        end
+        repr
+      end
+
+      private
+
+      def set_path_parameters(path, &block)
+        block = {} unless block_given?
+        @path_parameters.instance_eval(&block)
+        expected_parameters = path.scan(PATH_PARAMETER_REGEX).map { |parameter, _| parameter.to_sym }
+        ensure_parameters_all_defined(expected_parameters)
+      end
+
+      def ensure_parameters_all_defined(expected_parameters)
+        expected_parameters.each do |parameter|
+          raise "Path parameter :#{parameter} in path #{@path} is not defined." unless @path_parameters.properties.key? parameter
+        end
+        @path_parameters.properties.each do |parameter, _type|
+          raise "Parameter :#{parameter} does not appear in path #{@path}." unless expected_parameters.include? parameter
+        end
+      end
+
+      def validate_properties
+        raise 'One of the endpoints is missing a name.' unless @name
+        raise "Use `method :get/post/put/delete` to set an HTTP method for :#{@name}." unless @method
+        raise "Use `path \"/some/path\"` to assign a path to :#{@name}." unless @path
+      end
+
+      def validate_input(model_registry)
+        case @method
+        when :put, :post
+          raise "Use `input { type :typename }` to assign an input type to :#{@name}." unless @input
+          @input.validate(model_registry)
+        when :get
+          raise "Endpoint :#{@name} with method GET cannot accept an input payload." if @input
+        when :delete
+          raise "Endpoint :#{@name} with method DELETE cannot accept an input payload." if @input
+        end
+      end
+
+      def validate_path_parameters(model_registry)
+        @path_parameters.validate model_registry
+      end
+
+      def validate_outputs(model_registry)
+        raise "Endpoint :#{@name} does not declare any outputs" if @outputs.empty?
+        @outputs.each do |output|
+          output.validate model_registry
+        end
+      end
+    end
+
+    ##
+    # Input is the request body expected by an API endpoint.
+    class Input
+      attribute_setter_getter :description
+      attribute_setter_getter :example
+
+      def initialize
+        @type = nil
+        @description = nil
+      end
+
+      ##
+      # Declares the input type.
+      def type(type = nil, &block)
+        return @type unless type
+        @type = Apigen::Model.type type, &block
+      end
+
+      def validate(model_registry)
+        validate_properties
+        model_registry.check_type @type
+      end
+
+      def to_s
+        @type.to_s
+      end
+
+      private
+
+      def validate_properties
+        raise 'Use `type :typename` to assign a type to the input.' unless @type
+      end
+    end
+
+    ##
+    # Output is the response type associated with a specific status code for an API endpoint.
+    class Output
+      attribute_setter_getter :status
+      attribute_setter_getter :description
+      attribute_setter_getter :example
+
+      def initialize(name)
+        @name = name
+        @status = nil
+        @type = nil
+        @description = nil
+      end
+
+      ##
+      # Declares the output type.
+      def type(type = nil, &block)
+        return @type unless type
+        @type = Apigen::Model.type type, &block
+      end
+
+      def validate(model_registry)
+        validate_properties
+        model_registry.check_type @type
+      end
+
+      def to_s
+        "#{@name} #{@status} #{@type}"
+      end
+
+      private
+
+      def validate_properties
+        raise 'One of the outputs is missing a name.' unless @name
+        raise "Use `status [code]` to assign a status code to :#{@name}." unless @status
+        raise "Use `type :typename` to assign a type to :#{@name}." unless @type
+      end
+    end
+  end
+end

data/lib/apigen/util.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+##
+# Creates a setter/getter method for :attribute.
+#
+#  attribute_setter_getter :name
+# is equivalent to:
+#  def name value = nil
+#    if value.nil?
+#      @name
+#    else
+#      @name = value
+#    end
+#  end
+def attribute_setter_getter(attribute)
+  define_method attribute.to_s.to_sym do |value = nil|
+    if value.nil?
+      instance_variable_get "@#{attribute}"
+    else
+      instance_variable_set "@#{attribute}", value
+    end
+  end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: apigen
+version: !ruby/object:Gem::Version
+  version: 0.0.6
+platform: ruby
+authors:
+- Francois Wouts
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-18 00:00:00.000000000 Z
+dependencies: []
+description: A simple DSL to generate OpenAPI and/or JSON Schema definitions in Ruby.
+email: f@zenc.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/apigen/formats/jsonschema.rb
+- lib/apigen/formats/openapi.rb
+- lib/apigen/formats/swagger.rb
+- lib/apigen/model.rb
+- lib/apigen/rest.rb
+- lib/apigen/util.rb
+homepage: https://rubygems.org/gems/apigen
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: OpenAPI spec generator
+test_files: []