swagger-core 0.2.0

data/lib/swagger/uri.rb

@@ -0,0 +1,10 @@
+module Swagger
+  class URI < String
+    attr_reader :uri
+    def initialize(string)
+      # FIXME: Is it possible to initialize with heuristic parse once?
+      @uri = Addressable::URI.heuristic_parse string
+      super
+    end
+  end
+end

data/lib/swagger/uri_template.rb

@@ -0,0 +1,10 @@
+module Swagger
+  class URITemplate < String
+    attr_reader :uri_template
+    def initialize(string)
+      # FIXME: Is it possible to initialize with heuristic parse once?
+      @uri_template = Addressable::Template.new string
+      super
+    end
+  end
+end

data/lib/swagger/v2/api_declaration.rb

@@ -0,0 +1,81 @@
+require 'json-schema'
+require 'swagger/v2/info'
+require 'swagger/v2/path'
+
+module Swagger
+  module V2
+    SWAGGER_SCHEMA = File.expand_path 'schemas/swagger/v2.0/schema.json', Swagger::RESOURCES_DIR
+    JSON_SCHEMA = File.expand_path 'schemas/json_schema/draft-04.json', Swagger::RESOURCES_DIR
+
+    class APIDeclaration < Swagger::APIDeclaration
+      required_section :swagger, Float
+      required_section :info, Info
+      required_section :paths, Hash[String => Path]
+      section :host, Swagger::URITemplate
+      section :basePath, Swagger::URITemplate
+      section :schemes, Array[String]
+      section :consumes, Array[String]
+      section :produces, Array[String]
+      section :schemas, Hash
+      section :definitions, Hash
+      section :security, Array
+      # FIXME: Doesn't :parameter exist at this level as well?
+
+      attr_reader :apis
+
+      alias_method :base_path, :basePath
+
+      # def initialize(hash)
+      #   super
+      #   attach_to_apis
+      # end
+
+      def apis
+        # Perhaps not the best way...
+        paths.values.map do | path |
+          path.operations.values
+        end.flatten
+      end
+
+      def uri_template
+        # TODO: Can calculated values be safely memoized?
+        # TODO: Actual URI Template objects or just strings?
+        "#{host}#{basePath}"
+      end
+
+      def fully_validate
+        # FIXME: fully_validate is ideal, but very slow with the current schema/validator
+        errors = JSON::Validator.fully_validate(swagger_schema, to_json)
+        fail Swagger::InvalidDefinition, errors unless errors.empty?
+        true
+      end
+
+      def validate
+        JSON::Validator.validate!(swagger_schema, to_json)
+      rescue JSON::Schema::ValidationError => e
+        raise Swagger::InvalidDefinition, e.message
+      end
+
+      private
+
+      def swagger_schema
+        @swagger_schema ||= JSON.parse(File.read(SWAGGER_SCHEMA))
+
+        # Offline workaround
+        # @swagger_schema = JSON.parse(File.read(SWAGGER_SCHEMA)
+        #   .gsub('http://json-schema.org/draft-04/schema', "file://#{SWAGGER_SCHEMA}"))
+        # @swagger_schema['$schema'] = 'http://json-schema.org/draft-04/schema#'
+        # @swagger_schema
+      end
+
+      # def attach_to_apis
+      #   @apis ||= Set.new
+      #   paths.each do |path, api|
+      #     api.path = path
+      #     api.parent = self
+      #     @apis << api
+      #   end
+      # end
+    end
+  end
+end

data/lib/swagger/v2/api_operation.rb

@@ -0,0 +1,56 @@
+require 'swagger/v2/parameter'
+require 'swagger/v2/response'
+
+module Swagger
+  module V2
+    class APIOperation < DefinitionSection
+      extend Forwardable
+      def_delegators :parent, :uri_template, :path, :host
+
+      # required_section :verb, Symbol
+      section :summary, String
+      section :description, String
+      section :operationId, String
+      section :produces, Array[String]
+      section :consumes, Array[String]
+      section :tags, Array[String]
+      section :parameters, Array[Parameter]
+      section :responses, Hash[String => Response]
+      section :schemes, Array[String]
+
+      def initialize(hash)
+        hash[:parameters] ||= []
+        super
+      end
+
+      def verb
+        parent.operations.key self
+      end
+
+      def default_response
+        return nil if responses.values.nil?
+
+        # FIXME: Swagger isn't very clear on "normal response codes"
+        # In the examples, default is actually an error
+        responses['200'] || responses['201'] || responses['default'] || responses.values.first
+      end
+
+      # def self.coerce(orig_hash)
+      #   fail TypeError, 'Can only coerce from a hash' unless orig_hash.is_a? Hash
+      #   top_level_parameters = orig_hash.delete :parameters
+
+      #   new_hash = {
+      #     verb: orig_hash.keys.first
+      #   }.merge(orig_hash.values.first).merge(parameters: top_level_parameters)
+
+      #   APIOperation.new(new_hash)
+      # end
+
+      # def to_hash
+      #   base_hash = super
+      #   base_hash.delete :verb
+      #   { verb => base_hash }
+      # end
+    end
+  end
+end

data/lib/swagger/v2/example.rb

@@ -0,0 +1,24 @@
+module Swagger
+  module V2
+    class Example
+      extend Forwardable
+      def_delegator :@raw, :to_s, :inspect
+
+      attr_reader :raw
+
+      def initialize(sample)
+        @raw = sample
+      end
+
+      def parse(_format = :json)
+        return @raw unless @raw.is_a? String
+
+        JSON.parse(@raw)
+      end
+
+      def inspect
+        @raw.inspect
+      end
+    end
+  end
+end

data/lib/swagger/v2/info.rb

@@ -0,0 +1,23 @@
+module Swagger
+  module V2
+    class Info < DefinitionSection
+      class Contact < DefinitionSection
+        section :name, String
+        section :url, Swagger::URI
+        section :email, String
+      end
+
+      class License < DefinitionSection
+        required_section :name, String
+        section :url, Swagger::URI
+      end
+
+      required_section :version, String
+      required_section :title, String
+      section :description, String
+      section :termsOfService, String
+      section :contact, Contact
+      section :license, License
+    end
+  end
+end

data/lib/swagger/v2/parameter.rb

@@ -0,0 +1,6 @@
+module Swagger
+  module V2
+    class Parameter < Hashie::Mash
+    end
+  end
+end

data/lib/swagger/v2/path.rb

@@ -0,0 +1,38 @@
+require 'swagger/v2/api_operation'
+
+module Swagger
+  module V2
+    class Path < DefinitionSection
+      extend Forwardable
+      def_delegator :parent, :host
+
+      VERBS = [:get, :put, :post, :delete, :options, :head, :patch]
+
+      section :parameters, Array[Parameter]
+
+      VERBS.each do | verb |
+        section verb, APIOperation
+      end
+
+      def initialize(hash)
+        hash[:parameters] ||= []
+        super
+      end
+
+      def operations
+        VERBS.each_with_object({}) do | v, h |
+          operation = send v
+          h[v] = operation if operation
+        end
+      end
+
+      def uri_template
+        "#{parent.host}#{parent.base_path}#{path}"
+      end
+
+      def path
+        parent.paths.key self
+      end
+    end
+  end
+end

data/lib/swagger/v2/response.rb

@@ -0,0 +1,21 @@
+require 'swagger/v2/example'
+
+module Swagger
+  module V2
+    class Response < DefinitionSection
+      section :description, String
+      section :schema, Swagger::Schema
+      section :headers, Array # [String => String] # TODO: Headers
+      section :examples, Hash[Swagger::MimeType => Example]
+
+      def status_code
+        code = parent.responses.key self
+        code = '200' if code == 'default'
+        code.to_i
+      rescue
+        # TODO: Warning?
+        200
+      end
+    end
+  end
+end

data/lib/swagger/version.rb

@@ -0,0 +1,3 @@
+module Swagger
+  VERSION = '0.2.0'
+end

data/resources/schemas/json_schema/draft-04.json

@@ -0,0 +1,150 @@
+{
+    "id": "http://json-schema.org/draft-04/schema#",
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "positiveInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "positiveIntegerDefault0": {
+            "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ]
+        },
+        "simpleTypes": {
+            "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "minItems": 1,
+            "uniqueItems": true
+        }
+    },
+    "type": "object",
+    "properties": {
+        "id": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "multipleOf": {
+            "type": "number",
+            "minimum": 0,
+            "exclusiveMinimum": true
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "boolean",
+            "default": false
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxLength": { "$ref": "#/definitions/positiveInteger" },
+        "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/positiveInteger" },
+        "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxProperties": { "$ref": "#/definitions/positiveInteger" },
+        "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "dependencies": {
+        "exclusiveMaximum": [ "maximum" ],
+        "exclusiveMinimum": [ "minimum" ]
+    },
+    "default": {}
+}

data/resources/schemas/swagger/v2.0/schema.json

@@ -0,0 +1,532 @@
+{
+  "title": "A JSON Schema for Swagger 2.0 API.",
+  "$schema": "http://json-schema.org/draft-04/schema#",
+
+  "type": "object",
+  "required": [ "swagger", "info", "paths" ],
+  "additionalProperties": false,
+  "patternProperties": {
+    "^x-": {
+      "$ref": "#/definitions/vendorExtension"
+    }
+  },
+  "properties": {
+    "swagger": {
+      "type": "number",
+      "enum": [ 2.0 ],
+      "description": "The Swagger version of this document."
+    },
+    "info": {
+      "$ref": "#/definitions/info"
+    },
+    "externalDocs": {
+      "$ref": "#/definitions/externalDocs"
+    },
+    "host": {
+      "type": "string",
+      "format": "uri",
+      "pattern": "^((?!\\:\/\/).)*$",
+      "description": "The fully qualified URI to the host of the API."
+    },
+    "basePath": {
+      "type": "string",
+      "pattern": "^/",
+      "description": "The base path to the API. Example: '/api'."
+    },
+    "schemes": {
+      "type": "array",
+      "description": "The transfer protocol of the API.",
+      "items": {
+        "type": "string",
+        "enum": [ "http", "https", "ws", "wss" ]
+      }
+    },
+    "consumes": {
+      "type": "array",
+      "description": "A list of MIME types accepted by the API.",
+      "items": {
+        "$ref": "#/definitions/mimeType"
+      }
+    },
+    "produces": {
+      "type": "array",
+      "description": "A list of MIME types the API can produce.",
+      "items": {
+        "$ref": "#/definitions/mimeType"
+      }
+    },
+    "paths": {
+      "type": "object",
+      "description": "Relative paths to the individual endpoints. They must be relative to the 'basePath'.",
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        },
+        "^/.*[^\/]$": {
+          "$ref": "#/definitions/pathItem"
+        }
+      },
+      "additionalProperties": false
+    },
+    "definitions": {
+      "type": "object",
+      "description": "One or more JSON objects describing the schemas being consumed and produced by the API.",
+      "additionalProperties": { "$ref": "#/definitions/schema" }
+    },
+    "parameters": {
+      "type": "object",
+      "description": "One or more JSON representations for parameters",
+      "additionalProperties": { "$ref": "#/definitions/parameter" }
+    },
+    "responses": { "$ref": "#/definitions/responses" },
+    "security": { "$ref": "#/definitions/security" },
+    "tags": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/tag"
+      }
+    }
+  },
+  "definitions": {
+    "externalDocs": {
+      "type": "object",
+      "description": "information about external documentation",
+      "required": [ "url" ],
+      "properties": {
+        "description": {
+          "type": "string"
+        },
+        "url": {
+          "type": "string",
+          "format": "uri"
+        }
+      }
+    },
+    "info": {
+      "type": "object",
+      "description": "General information about the API.",
+      "required": [ "version", "title" ],
+      "additionalProperties": false,
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      },
+      "properties": {
+        "version": {
+          "type": "string",
+          "description": "A semantic version number of the API."
+        },
+        "title": {
+          "type": "string",
+          "description": "A unique and precise title of the API."
+        },
+        "description": {
+          "type": "string",
+          "description": "A longer description of the API. Should be different from the title.  Github-flavored markdown is allowed."
+        },
+        "termsOfService": {
+          "type": "string",
+          "description": "The terms of service for the API."
+        },
+        "contact": {
+          "type": "object",
+          "description": "Contact information for the owners of the API.",
+          "additionalProperties": false,
+          "properties": {
+            "name": {
+              "type": "string",
+              "description": "The identifying name of the contact person/organization."
+            },
+            "url": {
+              "type": "string",
+              "description": "The URL pointing to the contact information.",
+              "format": "uri"
+            },
+            "email": {
+              "type": "string",
+              "description": "The email address of the contact person/organization.",
+              "format": "email"
+            }
+          }
+        },
+        "license": {
+          "type": "object",
+          "required": [ "name" ],
+          "additionalProperties": false,
+          "properties": {
+            "name": {
+              "type": "string",
+              "description": "The name of the license type. It's encouraged to use an OSI compatible license."
+            },
+            "url": {
+              "type": "string",
+              "description": "The URL pointing to the license.",
+              "format": "uri"
+            }
+          }
+        }
+      }
+    },
+    "example": {
+      "type": "object",
+      "patternProperties": {
+        "^[a-z0-9-]+/[a-z0-9\\-+]+$": {}
+      },
+      "additionalProperties": false
+    },
+    "mimeType": {
+      "type": "string",
+      "pattern": "^[\\sa-z0-9\\-+;\\.=\\/]+$",
+      "description": "The MIME type of the HTTP message."
+    },
+    "operation": {
+      "type": "object",
+      "required": [ "responses" ],
+      "additionalProperties": false,
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      },
+      "properties": {
+        "tags": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "summary": {
+          "type": "string",
+          "description": "A brief summary of the operation."
+        },
+        "description": {
+          "type": "string",
+          "description": "A longer description of the operation, github-flavored markdown is allowed."
+        },
+        "externalDocs": {
+          "$ref": "#/definitions/externalDocs"
+        },
+        "operationId": {
+          "type": "string",
+          "description": "A friendly name of the operation"
+        },
+        "produces": {
+          "type": "array",
+          "description": "A list of MIME types the API can produce.",
+          "additionalItems": false,
+          "items": {
+            "$ref": "#/definitions/mimeType"
+          }
+        },
+        "consumes": {
+          "type": "array",
+          "description": "A list of MIME types the API can consume.",
+          "additionalItems": false,
+          "items": {
+            "$ref": "#/definitions/mimeType"
+          }
+        },
+        "parameters": {
+          "type": "array",
+          "description": "The parameters needed to send a valid API call.",
+          "minItems": 1,
+          "additionalItems": false,
+          "items": {
+            "oneOf": [
+              { "$ref": "#/definitions/parameter" },
+              {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "$ref": {
+                    "type": "string"
+                  }
+                }
+              }
+            ]
+          }
+        },
+        "responses": {
+          "$ref": "#/definitions/responses"
+        },
+        "schemes": {
+          "type": "array",
+          "description": "The transfer protocol of the API.",
+          "items": {
+            "type": "string",
+            "enum": [ "http", "https", "ws", "wss" ]
+          }
+        },
+        "security": {
+          "$ref": "#/definitions/securityRequirement"
+        }
+      }
+    },
+    "pathItem": {
+      "type": "object",
+      "additionalProperties": false,
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      },
+      "properties": {
+        "$ref": {
+          "type": "string"
+        },
+        "get": {
+          "$ref": "#/definitions/operation"
+        },
+        "put": {
+          "$ref": "#/definitions/operation"
+        },
+        "post": {
+          "$ref": "#/definitions/operation"
+        },
+        "delete": {
+          "$ref": "#/definitions/operation"
+        },
+        "options": {
+          "$ref": "#/definitions/operation"
+        },
+        "head": {
+          "$ref": "#/definitions/operation"
+        },
+        "patch": {
+          "$ref": "#/definitions/operation"
+        },
+        "parameters": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/parameter"
+          }
+        }
+      }
+    },
+    "responses": {
+      "type": "object",
+      "description": "Response objects names can either be any valid HTTP status code or 'default'.",
+      "minProperties": 1,
+      "additionalProperties": false,
+      "patternProperties": {
+        "^([0-9]+)$|^(default)$": {
+          "$ref": "#/definitions/response"
+        },
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      }
+    },
+    "response": {
+      "type": "object",
+      "required": [ "description" ],
+      "properties": {
+        "description": {
+          "type": "string"
+        },
+        "schema": {
+          "$ref": "#/definitions/schema"
+        },
+        "headers": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/serializableType"
+          }
+        },
+        "examples": {
+          "$ref": "#/definitions/example"
+        }
+      },
+      "additionalProperties": false
+    },
+    "serializableType": {
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": [ "string", "number", "boolean", "integer", "array", "file" ]
+        },
+        "format": {
+          "type": "string"
+        },
+        "items": {
+          "type": "object"
+        },
+        "collectionFormat": {
+          "type": "string"
+        }
+      }
+    },
+    "vendorExtension": {
+      "description": "Any property starting with x- is valid.",
+      "additionalProperties": true,
+      "additionalItems": true
+    },
+    "parameter": {
+      "type": "object",
+      "required": [ "name", "in" ],
+      "oneOf": [
+        {
+          "patternProperties": {
+            "^x-": {
+              "$ref": "#/definitions/vendorExtension"
+            }
+          },
+          "properties": {
+            "name": {
+              "type": "string",
+              "description": "The name of the parameter."
+            },
+            "in": {
+              "type": "string",
+              "description": "Determines the location of the parameter.",
+              "enum": [ "query", "header", "path", "formData" ]
+            },
+            "description": {
+              "type": "string",
+              "description": "A brief description of the parameter. This could contain examples of use.  Github-flavored markdown is allowed."
+            },
+            "required": {
+              "type": "boolean",
+              "description": "Determines whether or not this parameter is required or optional."
+            },
+            "type": {
+              "type": "string",
+              "enum": [ "string", "number", "boolean", "integer", "array" ]
+            },
+            "format": {
+              "type": "string"
+            },
+            "items": {
+              "type": "object"
+            },
+            "collectionFormat": {
+              "type": "string"
+            }
+          },
+          "additionalProperties": false
+        },
+        {
+          "patternProperties": {
+            "^x-": {
+              "$ref": "#/definitions/vendorExtension"
+            }
+          },
+          "properties": {
+            "name": {
+              "type": "string",
+              "description": "The name of the parameter."
+            },
+            "in": {
+              "type": "string",
+              "description": "Determines the location of the parameter.",
+              "enum": [ "body" ]
+            },
+            "description": {
+              "type": "string",
+              "description": "A brief description of the parameter. This could contain examples of use."
+            },
+            "required": {
+              "type": "boolean",
+              "description": "Determines whether or not this parameter is required or optional."
+            },
+            "schema": {
+              "$ref": "#/definitions/schema"
+            }
+          },
+          "additionalProperties": false
+        }
+      ]
+    },
+    "schema": {
+      "type": "object",
+      "description": "A deterministic version of a JSON Schema object.",
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        }
+      },
+      "properties": {
+        "$ref": { "type": "string" },
+        "format": { "type": "string" },
+        "title": { "$ref": "http://json-schema.org/draft-04/schema#/properties/title" },
+        "description": { "$ref": "http://json-schema.org/draft-04/schema#/properties/description" },
+        "default": { "$ref": "http://json-schema.org/draft-04/schema#/properties/default" },
+        "multipleOf": { "$ref": "http://json-schema.org/draft-04/schema#/properties/multipleOf" },
+        "maximum": { "$ref": "http://json-schema.org/draft-04/schema#/properties/maximum" },
+        "exclusiveMaximum": { "$ref": "http://json-schema.org/draft-04/schema#/properties/exclusiveMaximum" },
+        "minimum": { "$ref": "http://json-schema.org/draft-04/schema#/properties/minimum" },
+        "exclusiveMinimum": { "$ref": "http://json-schema.org/draft-04/schema#/properties/exclusiveMinimum" },
+        "maxLength": { "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveInteger" },
+        "minLength": { "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0" },
+        "pattern": { "$ref": "http://json-schema.org/draft-04/schema#/properties/pattern" },
+        "discriminator": { "type": "string" },
+        "xml": { "$ref": "#/definitions/xml"},
+        "items": {
+          "anyOf": [
+            { "$ref": "#/definitions/schema" },
+            {
+              "type": "array",
+              "minItems": 1,
+              "items": { "$ref": "#/definitions/schema" }
+            }
+          ],
+          "default": { }
+        },
+        "maxItems": { "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveInteger" },
+        "minItems": { "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0" },
+        "uniqueItems": { "$ref": "http://json-schema.org/draft-04/schema#/properties/uniqueItems" },
+        "maxProperties": { "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveInteger" },
+        "minProperties": { "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0" },
+        "required": { "$ref": "http://json-schema.org/draft-04/schema#/definitions/stringArray" },
+        "externalDocs": { "$ref": "#/definitions/externalDocs" },
+        "properties": {
+          "type": "object",
+          "additionalProperties": { "$ref": "#/definitions/schema" },
+          "default": { }
+        },
+        "enum": { "$ref": "http://json-schema.org/draft-04/schema#/properties/enum" },
+        "type": { "$ref": "http://json-schema.org/draft-04/schema#/properties/type" },
+        "example": {
+
+        },
+        "allOf": {
+          "type": "array",
+          "minItems": 1,
+          "items": { "$ref": "#/definitions/schema" }
+        }
+      }
+    },
+    "security": {
+      "description": "defines security definitions"
+    },
+    "securityRequirement": {
+      "description": "defines a security requirement",
+      "type": "array"
+    },
+    "xml": {
+      "properties": {
+        "name": { "type": "string"},
+        "namespace": { "type": "string" },
+        "prefix": { "type": "string" },
+        "attribute": { "type": "boolean" },
+        "wrapped": { "type": "boolean" }
+      },
+      "additionalProperties": false
+    },
+    "tag": {
+      "type": "object",
+      "properties": {
+        "externalDocs": { "$ref": "#/definitions/externalDocs" }
+      },
+      "patternProperties": {
+        "^x-": {
+          "$ref": "#/definitions/vendorExtension"
+        },
+        "^/.*[^\/]$": {
+          "type": "string"
+        }
+      }
+    }
+  }
+}