skeleton 0.3.3 → 0.4.1

data/lib/skeleton/structure.rb

@@ -1,192 +1,146 @@
-require 'skeleton/model'
+require 'set'
+
 require 'skeleton/path'
-require 'skeleton/info'
+require 'skeleton/model'
+require 'skeleton/contact'
+require 'skeleton/license'
+require 'skeleton/tag'
+require 'skeleton/scope'
 require 'skeleton/parameter'
-require 'skeleton/responses'
-require 'skeleton/security_definitions'
+require 'skeleton/response'
+require 'skeleton/security_scheme'
 
 module Skeleton
-  class Structure < Model
-    attr_accessor :host, :base_path, :external_docs
-    attr_presence :info, :host, :base_path, :external_docs, :security
-    attr_not_empty :consumes, :responses, :produces, :schemes, :security, :tags,
-                   :definitions, :parameters, :paths, :security_definitions
-
-    def responses=(value)
-      case value
-      when Hash
-        Skeleton::Responses.new(value)
+  class Structure
+    attr_accessor :terms, :host, :base_path, :title, :version, :description,
+      :external_docs
+
+    alias_method :describe, :description=
+
+    def configure(&block)
+      return self unless block
+
+      if block.arity == 0
+        self.instance_eval(&block)
       else
-        @responses = value
+        yield(self)
       end
-    end
 
-    def responses
-      @responses ||= Skeleton::Responses.new
+      self
     end
 
-    def consumes=(value)
-      @consumes = Array(value)
+    def schemes
+      @schemes ||= Set.new
     end
 
     def consumes
-      @consumes ||= []
-    end
-
-    def produces=(value)
-      @produces = Array(value)
+      @consumes ||= Set.new
     end
 
     def produces
-      @produces ||= []
+      @produces ||= Set.new
     end
 
-    def schemes=(value)
-      @schemes = Array(value)
+    def license
+      @license ||= Skeleton::License.new
     end
 
-    def schemes
-      @schemes ||= []
-    end
-
-    def security=(value)
-      @security = Array(value)
-    end
-
-    def security
-      @security ||= []
+    def tags
+      @tags ||= {}
     end
 
-    def tags=(value)
-      @tags = Array(value)
+    def contact
+      @contact ||= Skeleton::Contact.new
     end
 
-    def tags
-      @tags ||= []
+    def responses
+      @responses ||= {}
     end
 
-    def info
-      @info ||= Skeleton::Info.new
+    def parameters
+      @parameters ||= {}
     end
 
-    def definitions
-      @definitions ||= {}
+    def scopes
+      @scopes ||= {}
     end
 
-    def parameters
-      @parameters ||= {}
+    def security
+      @security ||= {}
     end
 
     def paths
       @paths ||= {}
     end
 
-    def security_definitions
-      @security_definitions ||= Skeleton::SecurityDefinitions.new
+    def models
+      @models ||= {}
     end
 
-    # Define or get a path. If a block is provided, it will define a new path
-    # object. If no block is provided, the current block will be returned
-    #
-    # @param resource [String] the api path
-    #
-    # @return [Skeleton::Path]
-    def path(resource, &block)
-      if block
-        path_object = Skeleton::Path.new
-        yield(path_object)
-        paths[resource] = path_object
-      else
-        paths[resource]
-      end
+    def scheme(*types)
+      types.flatten.each { |t| schemes.add(t.to_s) }
     end
 
-    def parameter(location, name, &block)
-      param = Skeleton::Parameter.new({name: name})
-      yield(param) if block
-      parameters[name] = param
+    def consume(*types)
+      types.flatten.each { |t| consumes.add(t.to_s) }
     end
 
-    def to_h
-      hash = {}
-      hash[:info] = info.to_h if info?
-      hash[:host] = host if host?
-      hash[:base_path] = base_path if base_path?
-      hash[:external_docs] = external_docs if external_docs?
-      hash[:schemes]  = schemes if schemes?
-      hash[:consumes] = consumes if consumes?
-      hash[:produces] = produces if produces?
-
-      if paths?
-        hash[:paths] = {}
-        paths.each do |resource, path|
-          hash[:paths][resource] = path.to_h
-        end
-      end
-
-      if parameters?
-        hash[:parameters] = {}
-        parameters.each do |name, parameter|
-          hash[:parameters][name] = parameter.to_h
-        end
-      end
+    def produce(*types)
+      types.flatten.each { |t| produces.add(t.to_s) }
+    end
 
-      hash[:responses] = responses.to_h if responses?
+    def parameters?
+      !parameters.empty?
+    end
 
-      if security_definitions?
-        hash[:security_definitions] = security_definitions.to_h
-      end
+    def responses?
+      !responses.empty?
+    end
 
-      if security?
-        hash[:security] = security.map(&:to_h)
-      end
+    def secure?
+      !security.empty?
+    end
 
-      hash[:tags] = tags.map(&:to_h) if tags?
-      hash
-    end
-
-    def to_swagger_hash
-      hash = {}
-      hash[:swagger] = '2.0'
-      hash[:info] = info.to_swagger_hash if info?
-      hash[:host] = host if host?
-      hash[:basePath] = base_path if base_path?
-      hash[:externalDocs] = external_docs if external_docs?
-      hash[:schemes]  = schemes if schemes?
-      hash[:consumes] = consumes if consumes?
-      hash[:produces] = produces if produces?
-
-      if paths?
-        hash[:paths] = {}
-        paths.each do |resource, path|
-          hash[:paths][resource] = path.to_swagger_hash
-        end
-      end
+    def define_response(name, &block)
+      responses[name] = Skeleton::Response.new
+      responses[name].instance_eval(&block) if block
+      responses[name]
+    end
 
-      if parameters?
-        hash[:parameters] = {}
-        parameters.each do |name, parameter|
-          hash[:parameters][name] = parameter.to_swagger_hash
-        end
-      end
+    def define_parameter(name, &block)
+      parameters[name] = Skeleton::Parameter.new
+      parameters[name].instance_eval(&block) if block
+      parameters[name]
+    end
 
-      if responses?
-        hash[:responses] = responses.to_swagger_hash
-      end
+    def define_scope(name, &block)
+      scopes[name] = Skeleton::Scope.new
+      scopes[name].instance_eval(&block) if block
+      scopes[name]
+    end
 
-      if security_definitions?
-        hash[:securityDefinitions] = security_definitions.to_swagger_hash
-      end
+    def define_security(name, &block)
+      security[name] = Skeleton::SecurityScheme.new(name: name)
+      security[name].instance_eval(&block) if block
+      security[name]
+    end
 
-      if security?
-        hash[:security] = security.map(&:to_swagger_hash)
-      end
+    def define_tag(name, &block)
+      tags[name] = Skeleton::Tag.new(name: name)
+      tags[name].instance_eval(&block) if block
+      tags[name]
+    end
 
-      if tags?
-        hash[:tags] = tags.map(&:to_swagger_hash)
-      end
+    def define_path(path, options={}, &block)
+      paths[path] = Skeleton::Path.new
+      paths[path].instance_eval(&block) if block
+      paths[path]
+    end
 
-      hash
+    def define_model(name, options={}, &block)
+      models[name] = Skeleton::Model.new(name: name)
+      models[name].instance_eval(&block) if block
+      models[name]
     end
   end
 end

data/lib/skeleton/swagger.rb

@@ -0,0 +1,9 @@
+require 'skeleton/swagger/serializer'
+
+module Skeleton
+  module Swagger
+    def self.serialize(structure)
+      Skeleton::Swagger::Serializer.new(structure).to_h
+    end
+  end
+end

data/lib/skeleton/tag.rb

@@ -1,24 +1,19 @@
-require 'skeleton/model'
-
+require 'skeleton/attributes'
 module Skeleton
-  class Tag < Model
+  class Tag
+    extend Skeleton::Attributes
+
     attr_accessor :name, :description, :external_docs
     attr_presence :name, :description, :external_docs
 
-    def to_h
-      hash = {}
-      hash[:name]          = name if name?
-      hash[:description]   = description if description?
-      hash[:external_docs] = external_docs if external_docs?
-      hash
+    def initialize(args={})
+      args.each do |k, v|
+        setter = "#{k}="
+        self.send(setter, v) if self.respond_to?(setter)
+      end
     end
 
-    def to_swagger_hash
-      hash = {}
-      hash[:name]         = name if name?
-      hash[:description]  = description if description?
-      hash[:externalDocs] = external_docs if external_docs?
-      hash
-    end
+    alias_method :describe, :description=
+    alias_method :document, :external_docs=
   end
 end

data/lib/skeleton/version.rb

@@ -1,3 +1,3 @@
 module Skeleton
-  VERSION = '0.3.3'
+  VERSION = '0.4.1'
 end

data/skeleton.gemspec

@@ -23,4 +23,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency('bundler', '~> 1.6')
   spec.add_development_dependency('rake')
   spec.add_development_dependency('minitest')
+  spec.add_development_dependency('json-schema')
+  spec.add_development_dependency('webmock')
 end

data/test/fixtures/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": {}
+}