skeleton 0.2.0 → 0.3.0

data/lib/skeleton/path.rb

@@ -0,0 +1,111 @@
+require 'skeleton/operation'
+require 'skeleton/parameter'
+require 'skeleton/model'
+
+module Skeleton
+  class Path < Model
+    attr_accessor :ref
+    attr_writer :operations
+    attr_not_empty :parameters, :operations
+
+    def operations
+      @operations ||= {}
+    end
+
+    def parameters=(value)
+      @parameters = Array(value)
+    end
+
+    def parameters
+      @parameters ||= []
+    end
+
+    def parameter(location, name, &block)
+      param = Skeleton::Parameter.new({name: name})
+      yield(param) if block
+      parameters << param
+    end
+
+    def get(&block)
+      define_operation(:get, &block)
+    end
+
+    def put(&block)
+      define_operation(:put, &block)
+    end
+
+    def post(&block)
+      define_operation(:post, &block)
+    end
+
+    def delete(&block)
+      define_operation(:delete, &block)
+    end
+
+    def options(&block)
+      define_operation(:options, &block)
+    end
+
+    def head(&block)
+      define_operation(:head, &block)
+    end
+
+    def patch(&block)
+      define_operation(:patch, &block)
+    end
+
+    def to_h
+      hash = {}
+      if operations?
+        operations.each do |method, operation|
+          if operation.respond_to?(:to_h)
+            hash[method] = operation.to_h
+          else
+            hash[method] = operation
+          end
+        end
+      end
+      if parameters?
+        hash[:parameters] = parameters.map do |parameter|
+          if parameter.respond_to?(:to_h)
+            parameter.to_h
+          else
+            parameter
+          end
+        end
+      end
+      hash
+    end
+
+    def to_swagger_hash
+      hash = {}
+      if operations?
+        operations.each do |method, operation|
+          if operation.respond_to?(:to_swagger_hash)
+            hash[method] = operation.to_swagger_hash
+          else
+            hash[method] = operation
+          end
+        end
+      end
+      if parameters?
+        hash[:parameters] = parameters.map do |parameter|
+          if parameter.respond_to?(:to_swagger_hash)
+            parameter.to_swagger_hash
+          else
+            parameter
+          end
+        end
+      end
+      hash
+    end
+
+    private
+
+    def define_operation(method, &block)
+      operation = Skeleton::Operation.new
+      yield(operation) if block
+      operations[method] = operation
+    end
+  end
+end

data/lib/skeleton/response.rb

@@ -0,0 +1,59 @@
+require 'skeleton/model'
+require 'skeleton/headers'
+require 'skeleton/schema'
+
+module Skeleton
+  class Response < Model
+    attr_accessor :description
+    attr_reader :headers, :schema
+    attr_presence :descriptions, :examples
+    attr_not_empty :headers, :schema
+
+    def headers=(value)
+      case value
+      when Hash
+        @headers = Skeleton::Headers.new(value)
+      else
+        @headers = value
+      end
+    end
+
+    def schema=(value)
+      case value
+      when Hash
+        @schema = Skeleton::Schema.new(value)
+      else
+        @schema = value
+      end
+    end
+
+    def examples=(value)
+      case value
+      when Hash
+        @examples = Skeleton::Example.new(value)
+      else
+        @examples = value
+      end
+    end
+
+    def to_h
+      hash = {}
+      hash[:description] = description   if description?
+      hash[:examples]    = examples.to_h if examples?
+      hash[:headers]     = headers.to_h  if headers?
+      hash[:schema]      = schema.to_h   if schema?
+      hash[:examples]    = examples.to_h if examples?
+      hash
+    end
+
+    def to_swagger_hash
+      hash = {}
+      hash[:description] = description              if description?
+      hash[:examples]    = examples.to_swagger_hash if examples?
+      hash[:headers]     = headers.to_swagger_hash  if headers?
+      hash[:schema]      = schema.to_swagger_hash   if schema?
+      hash[:examples]    = examples.to_swagger_hash if examples?
+      hash
+    end
+  end
+end

data/lib/skeleton/responses.rb

@@ -0,0 +1,59 @@
+require 'skeleton/model'
+require 'skeleton/response'
+
+module Skeleton
+  class Responses < Model
+    attr_accessor :default
+    attr_presence :default
+
+    def initialize(args={})
+      @responses = {}
+      args.each { |k, v| set(k, v) }
+    end
+
+    def get(code)
+      @responses[code]
+    end
+    alias_method :[], :get
+
+    def set(code, value)
+      case value
+      when Hash
+        @responses[code] = Skeleton::Response.new(value)
+      else
+        @responses[code] = value
+      end
+    end
+    alias_method :[]=, :set
+
+    def empty?
+      @responses.empty?
+    end
+
+    def to_h
+      hash = {}
+      hash[:default] = default.to_h if default?
+      @responses.each do |code, response|
+        if response.respond_to?(:to_h)
+          hash[code] = response.to_h
+        else
+          hash[code] = response
+        end
+      end
+      hash
+    end
+
+    def to_swagger_hash
+      hash = {}
+      hash[:default] = default.to_h if default?
+      @responses.each do |code, response|
+        if response.respond_to?(:to_swagger_hash)
+          hash[code] = response.to_swagger_hash
+        else
+          hash[code] = response
+        end
+      end
+      hash
+    end
+  end
+end

data/lib/skeleton/schema.rb

@@ -0,0 +1,70 @@
+require 'skeleton/model'
+
+module Skeleton
+  class Schema < Model
+    attr_accessor :ref, :type, :format, :title, :description, :default,
+                  :multiple_of, :maximum, :exclusive_maximum, :minimum,
+                  :exclusive_minimum, :max_length, :min_length, :pattern,
+                  :max_items, :min_items, :unique_items, :max_properties,
+                  :min_properties, :required, :enum, :discriminator, :read_only,
+                  :xml, :external_docs, :example
+
+    attr_presence :required, :exclusive_maximum, :exclusive_minimum,
+                  :unique_items, :discriminator, :read_only, :xml,
+                  :external_docs, :example
+
+    def to_h
+      hash = {}
+      hash[:type]              = type              if type?
+      hash[:format]            = format            if format?
+
+      hash[:items] = items.to_hash if items?
+
+      hash[:title]             = title             if title?
+      hash[:description]       = description       if description?
+      hash[:default]           = default           if default?
+      hash[:multiple_of]       = multiple_of       if multiple_of?
+      hash[:maximum]           = maximum           if maximum?
+      hash[:exclusive_maximum] = exclusive_maximum if exclusive_maximum?
+      hash[:minimum]           = minimum           if minimum?
+      hash[:exclusive_minimum] = exclusive_minimum if exclusive_minimum?
+      hash[:max_length]        = max_length        if max_length?
+      hash[:min_length]        = min_length        if min_length?
+      hash[:pattern]           = pattern           if pattern?
+      hash[:max_items]         = max_items         if max_items?
+      hash[:min_items]         = min_items         if min_items?
+      hash[:unique_items]      = unique_items      if unique_items?
+      hash[:max_properties]    = max_properties    if max_properties?
+      hash[:min_properties]    = min_properties    if min_properties?
+      hash[:enum]              = enum              if enum?
+      hash
+    end
+
+    def to_swagger_hash
+      hash = {}
+      hash[:type]             = type              if type?
+      hash[:format]           = format            if format?
+
+      hash[:items] = items.to_swagger_hash if items?
+
+      hash[:title]            = title             if title?
+      hash[:description]      = description       if description?
+      hash[:default]          = default           if default?
+      hash[:multipleOf]       = multiple_of       if multiple_of?
+      hash[:maximum]          = maximum           if maximum?
+      hash[:exclusiveMaximum] = exclusive_maximum if exclusive_maximum?
+      hash[:minimum]          = minimum           if minimum?
+      hash[:exclusiveMinimum] = exclusive_minimum if exclusive_minimum?
+      hash[:maxLength]        = max_length        if max_length?
+      hash[:minLength]        = min_length        if min_length?
+      hash[:pattern]          = pattern           if pattern?
+      hash[:maxItems]         = max_items         if max_items?
+      hash[:minItems]         = min_items         if min_items?
+      hash[:uniqueItems]      = unique_items      if unique_items?
+      hash[:maxProperties]    = max_properties    if max_properties?
+      hash[:minProperties]    = min_properties    if min_properties?
+      hash[:enum]             = enum              if enum?
+      hash
+    end
+  end
+end

data/lib/skeleton/scopes.rb

@@ -0,0 +1,24 @@
+require 'skeleton/model'
+
+module Skeleton
+  class Scopes < Model
+    attr_reader :scopes
+
+    def initialize
+      @scopes = {}
+    end
+
+    def [](name)
+      @scopes[name]
+    end
+
+    def []=(name, description)
+      @scopes[name] = description
+    end
+
+    def to_h
+      @scopes
+    end
+    alias_method :to_swagger_hash, :to_h
+  end
+end

data/lib/skeleton/security_definitions.rb

@@ -0,0 +1,46 @@
+require 'skeleton/model'
+require 'skeleton/security_scheme'
+
+module Skeleton
+  class SecurityDefinitions < Model
+    def initialize(args={})
+      @schemes = {}
+      args.each { |k, v| set(k, v) }
+    end
+
+    def get(name)
+      @schemes[name]
+    end
+    alias_method :[], :get
+
+    def set(name, value)
+      case value
+      when Hash
+        @schemes[name] = Skeleton::SecurityScheme.new(value)
+      else
+        @schemes[name] = value
+      end
+    end
+    alias_method :[]=, :set
+
+    def empty?
+      !@schemes.empty?
+    end
+
+    def to_h
+      hash = {}
+      @schemes.each do |name, scheme|
+        hash[name] = scheme.to_h
+      end
+      hash
+    end
+
+    def to_swagger_hash
+      hash = {}
+      @schemes.each do |name, scheme|
+        hash[name] = scheme.to_swagger_hash
+      end
+      hash
+    end
+  end
+end

data/lib/skeleton/security_requirement.rb

@@ -0,0 +1,29 @@
+require 'skeleton/model'
+
+module Skeleton
+  class SecurityRequirement < Model
+    def initialize(args={})
+      @requirements = []
+      args.each { |name, value| set(name, value) }
+    end
+
+    def get(name)
+      @requirements[name]
+    end
+    alias_method :[], :get
+
+    def set(name, value)
+      @requirements[name] = Array(value)
+    end
+    alias_method :[]=, :set
+
+    def to_h
+      hash = {}
+      @requirements.each do |name, definition|
+        hash[name] = definition
+      end
+      hash
+    end
+    alias_method :to_swagger_hash, :to_h
+  end
+end

data/lib/skeleton/security_scheme.rb

@@ -0,0 +1,47 @@
+require 'skeleton/model'
+require 'skeleton/scopes'
+
+module Skeleton
+  class SecurityScheme < Model
+    attr_accessor :type, :description, :name, :location, :flow, :authorization_url,
+                  :token_url, :scopes
+
+    attr_presence :type, :description, :name, :location, :flow, :authorization_url,
+                  :token_url, :scopes
+
+    def scopes=(value)
+      case value
+      when Hash
+        @scopes = Skeleton::Scopes.new(value)
+      else
+        @scopes = value
+      end
+    end
+
+    def to_h
+      hash = {}
+      hash[:type]              = type              if type?
+      hash[:description]       = description       if description?
+      hash[:name]              = name              if name?
+      hash[:location]          = location          if location?
+      hash[:flow]              = flow              if flow?
+      hash[:authorization_url] = authorization_url if authorization_url?
+      hash[:token_url]         = token_url         if token_url?
+      hash[:scopes]            = scopes.to_h       if scopes?
+      hash
+    end
+
+    def to_swagger_hash
+      hash = {}
+      hash[:type]              = type              if type?
+      hash[:description]       = description       if description?
+      hash[:name]              = name              if name?
+      hash[:location]          = location          if location?
+      hash[:flow]              = flow              if flow?
+      hash[:authorizationUrl]  = authorization_url if authorization_url?
+      hash[:tokenUrl]          = token_url         if token_url?
+      hash[:scopes]            = scopes.to_swagger_hash if scopes?
+      hash
+    end
+  end
+end