ruby-swagger 0.0.1

data/lib/ruby-swagger/data/paths.rb

@@ -0,0 +1,50 @@
+require 'ruby-swagger/object'
+require 'ruby-swagger/data/path'
+
+module Swagger::Data
+  class Paths < Swagger::Object #https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#pathsObject
+
+    def initialize
+      @paths = {}
+    end
+
+    def self.parse(paths)
+      raise (ArgumentError.new("Swagger::Data::Paths#parse - paths object is nil")) unless paths
+      raise (ArgumentError.new("Swagger::Data::Paths#parse - paths object is not an hash")) unless paths.is_a?(Hash)
+
+      pts = Swagger::Data::Paths.new
+
+      paths.each do |path, path_obj|
+        pts.add_path(path, path_obj)
+      end
+
+      pts
+    end
+
+    def add_path(path, path_obj)
+      raise ArgumentError.new("Swagger::Data::Paths#parse - path is nil") if path.nil? || path.empty?
+      raise ArgumentError.new("Swagger::Data::Paths#parse - path object is nil") if path_obj.nil?
+
+      unless path_obj.is_a?(Swagger::Data::Path)
+        path_obj = Swagger::Data::Path.parse(path_obj)
+      end
+
+      @paths[path] = path_obj
+    end
+
+    def [](path)
+      @paths[path]
+    end
+
+    def to_swagger
+      swag_obj = {}
+
+      @paths.each do |path, path_obj|
+        swag_obj[path] = path_obj.to_swagger
+      end
+
+      swag_obj
+    end
+
+  end
+end

data/lib/ruby-swagger/data/reference.rb

@@ -0,0 +1,30 @@
+require 'ruby-swagger/object'
+
+module Swagger::Data
+  class Reference < Swagger::Object #https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#referenceObject
+
+    @ref = nil
+
+    def self.parse(reference)
+      return nil unless reference
+
+      r = Swagger::Data::Reference.new
+      r.ref = reference['$ref']
+      r
+    end
+
+    def ref=(new_ref)
+      raise (ArgumentError.new("Swagger::Data::Reference#ref= $ref is nil")) unless new_ref
+      @ref = new_ref
+    end
+
+    def ref
+      @ref
+    end
+
+    def as_swagger
+      @ref.nil? ? {} : { '$ref' => @ref }
+    end
+
+  end
+end

data/lib/ruby-swagger/data/response.rb

@@ -0,0 +1,25 @@
+require 'ruby-swagger/object'
+require 'ruby-swagger/data/schema'
+require 'ruby-swagger/data/headers'
+require 'ruby-swagger/data/example'
+
+module Swagger::Data
+  class Response < Swagger::Object # https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#responseObject
+
+    attr_swagger :description, :schema, :headers, :examples
+
+    def self.parse(response)
+      return nil unless response
+
+      r = Swagger::Data::Response.new
+
+      r.description = response['description']
+      r.schema = Swagger::Data::Schema.parse(response['schema'])
+      r.headers = Swagger::Data::Headers.parse(response['headers'])
+      r.examples = Swagger::Data::Example.parse(response['examples'])
+
+      r
+    end
+
+  end
+end

data/lib/ruby-swagger/data/responses.rb

@@ -0,0 +1,50 @@
+require 'ruby-swagger/object'
+require 'ruby-swagger/data/reference'
+require 'ruby-swagger/data/response'
+
+module Swagger::Data
+  class Responses < Swagger::Object # https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#responsesObject
+
+    def initialize
+      @responses = {}
+    end
+
+    def self.parse(responses)
+      return nil unless responses
+
+      r = Swagger::Data::Responses.new
+
+      responses.each do |response_key, response_value|
+        r.add_response(response_key, response_value)
+      end
+
+      r
+    end
+
+    def add_response(response_code, response)
+      raise ArgumentError.new('Swagger::Data::Responses#add_response - response is nil') unless response
+
+      if !response.is_a?(Swagger::Data::Reference) && !response.is_a?(Swagger::Data::Response)
+        # it's a reference object or it's a parameter object
+        response = response['$ref'] ? Swagger::Data::Reference.parse(response) : Swagger::Data::Response.parse(response)
+      end
+
+      @responses[response_code] = response
+    end
+
+    def [](key)
+      @responses[key]
+    end
+
+    def as_swagger
+      res = {}
+
+      @responses.each do |other_name, other_value|
+        res[other_name] = other_value.to_swagger
+      end
+
+      res
+    end
+
+  end
+end

data/lib/ruby-swagger/data/schema.rb

@@ -0,0 +1,68 @@
+require 'ruby-swagger/object'
+require 'ruby-swagger/data/reference'
+require 'ruby-swagger/data/xml_object'
+require 'ruby-swagger/data/external_documentation'
+
+module Swagger::Data
+  class Schema < Swagger::Object #https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#schemaObject
+
+    attr_swagger :discriminator, :readOnly, :xml, :externalDocs, :example,
+                 :format, :title, :description, :default,
+                 :multipleOf, :maximum, :exclusiveMaximum, :minimum,
+                 :exclusiveMinimum, :maxLength, :minLength,
+                 :pattern, :maxItems, :minItems, :uniqueItems, :maxProperties,
+                 :minProperties, :required, :enum, :type, :items, :allOf,
+                 :properties, :additionalProperties
+
+    attr_reader :ref
+
+    def self.parse(schema)
+      return nil if schema.nil?
+
+      sc = Swagger::Data::Schema.new.bulk_set(schema)
+      sc.ref= schema['$ref']
+      sc
+    end
+
+    def ref=(new_ref)
+      return nil unless new_ref
+
+      @ref = new_ref
+    end
+
+    def externalDocs=(new_doc)
+      return nil unless new_doc
+
+      if !new_doc.is_a?(Swagger::Data::ExternalDocumentation)
+        new_doc = Swagger::Data::ExternalDocumentation.parse(new_doc)
+      end
+
+      @externalDocs = new_doc
+    end
+
+    def xml=(new_xml)
+      return nil unless new_xml
+
+      if !new_xml.is_a?(Swagger::Data::XMLObject)
+        new_xml = Swagger::Data::XMLObject.parse(new_xml)
+      end
+
+      @xml = new_xml
+    end
+
+    def []=(attrib, value)
+      self.send("#{attrib}=", value)
+    end
+
+    def [](attrib)
+      self.send("#{attrib}")
+    end
+
+    def as_swagger
+      res = super
+      res['$ref'] = @ref if @ref
+      res
+    end
+
+  end
+end

data/lib/ruby-swagger/data/scopes.rb

@@ -0,0 +1,44 @@
+require 'ruby-swagger/object'
+
+module Swagger::Data
+  class Scopes < Swagger::Object #https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#scopesObject
+
+    def initialize
+      @scopes = {}
+    end
+
+    def self.parse(scopes)
+      return nil unless scopes
+
+      scope = Swagger::Data::Scopes.new
+
+      scopes.each do |scope_name, scope_value|
+        scope.add_scope(scope_name, scope_value)
+      end
+
+      scope
+    end
+
+    def add_scope(scope_name, scope_value)
+      raise ArgumentError.new("Swagger::Data::Scopes#add_scope - scope_name is nil") unless scope_name
+      raise ArgumentError.new("Swagger::Data::Scopes#add_scope - scope_value is nil") unless scope_value
+
+      @scopes[scope_name] = scope_value
+    end
+
+    def [](scope)
+      @scopes[scope]
+    end
+
+    def as_swagger
+      swagger_scopes = {}
+
+      @scopes.each do |scope_k, scope_v|
+        swagger_scopes[scope_k] = scope_v
+      end
+
+      swagger_scopes
+    end
+
+  end
+end

data/lib/ruby-swagger/data/security_definitions.rb

@@ -0,0 +1,49 @@
+require 'ruby-swagger/object'
+require 'ruby-swagger/data/security_scheme'
+
+module Swagger::Data
+  class SecurityDefinitions < Swagger::Object #https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#securityDefinitionsObject
+    
+    def initialize
+      @security = {}
+    end
+
+    def self.parse(security)
+      return nil unless security
+
+      params = Swagger::Data::SecurityDefinitions.new
+
+      security.each do |pname, pvalue|
+        params.add_param(pname, pvalue)
+      end
+
+      params
+    end
+
+    def add_param(pname, pvalue)
+      raise ArgumentError.new("Swagger::Data::SecurityDefinitions#add_param - parameter name is nil") unless pname
+      raise ArgumentError.new("Swagger::Data::SecurityDefinitions#add_param - parameter value is nil") unless pvalue
+
+      if !pvalue.is_a?(Swagger::Data::SecurityScheme)
+        pvalue = Swagger::Data::SecurityScheme.parse(pvalue)
+      end
+
+      @security[pname] = pvalue
+    end
+
+    def [](pname)
+      @security[pname]
+    end
+
+    def as_swagger
+      swagger_params = {}
+
+      @security.each do |p_k, p_v|
+        swagger_params[p_k] = p_v.to_swagger
+      end
+
+      swagger_params
+    end
+
+  end
+end

data/lib/ruby-swagger/data/security_requirement.rb

@@ -0,0 +1,35 @@
+require 'ruby-swagger/object'
+
+module Swagger::Data
+  class SecurityRequirement < Swagger::Object #https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#securityRequirementObject
+
+    def initialize
+      @requirements = {}
+    end
+
+    def self.parse(security)
+      return nil unless security
+
+      s = Swagger::Data::SecurityRequirement.new
+      security.each {|key, reqs| s.add_requirement(key, reqs)}
+      s
+    end
+
+    def add_requirement(key, requirements)
+      raise (ArgumentError.new("Swagger::Data::SecurityRequirement#add_requirement - key is nil")) unless key
+      raise (ArgumentError.new("Swagger::Data::SecurityRequirement#add_requirement - requirements is nil")) unless requirements
+      raise (ArgumentError.new("Swagger::Data::SecurityRequirement#add_requirement - requirements is not an array")) unless requirements.is_a?(Array)
+
+      @requirements[key] = requirements
+    end
+
+    def [](key)
+      @requirements[key]
+    end
+
+    def as_swagger
+      @requirements
+    end
+
+  end
+end

data/lib/ruby-swagger/data/security_scheme.rb

@@ -0,0 +1,67 @@
+require 'ruby-swagger/object'
+require 'ruby-swagger/data/scopes'
+
+module Swagger::Data
+  class SecurityScheme < Swagger::Object #https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#securitySchemeObject
+
+    attr_swagger :type, :description, :name, :in, :flow, :authorizationUrl, :tokenUrl, :scopes
+
+    def self.parse(security)
+      return nil unless security
+
+      Swagger::Data::SecurityScheme.new.bulk_set(security)
+    end
+
+    def type=(new_type)
+      raise ArgumentError.new("Security::Data::SecurityScheme#type= - type is nil") unless new_type
+      raise ArgumentError.new("Security::Data::SecurityScheme#type= - unrecognized type #{new_type}") unless %w(basic apiKey oauth2).include?(new_type)
+
+      @type = new_type
+    end
+
+    def name=(new_name)
+      raise ArgumentError.new("Security::Data::SecurityScheme#name= - name is nil") if @type == 'apiKey' && !new_name
+
+      @name = new_name
+    end
+
+    def in=(new_in)
+      if @type == 'apiKey'
+        raise ArgumentError.new("Security::Data::SecurityScheme#in= - in is nil") if !new_in
+        raise ArgumentError.new("Security::Data::SecurityScheme#in= - unrecognized in #{new_in}") unless %w(query header).include?(new_in)
+      end
+
+      @in = new_in
+    end
+
+    def flow=(new_flow)
+      if @type == 'oauth2'
+        raise ArgumentError.new("Security::Data::SecurityScheme#flow= - flow is nil")  if !new_flow
+        raise ArgumentError.new("Security::Data::SecurityScheme#flow= - unrecognized flow #{new_flow}") unless %w(implicit password application accessCode).include?(new_flow)
+      end
+
+      @flow = new_flow
+    end
+
+    def authorizationUrl=(new_authorizationUrl)
+      raise ArgumentError.new("Security::Data::SecurityScheme#authorizationUrl= - authorizationUrl is nil") if @type == 'oauth2' && (@flow == 'implicit' || @flow == 'accessCode') && !new_authorizationUrl
+
+      @authorizationUrl = new_authorizationUrl
+    end
+
+    def tokenUrl=(new_tokenUrl)
+      raise ArgumentError.new("Security::Data::SecurityScheme#tokenUrl= - tokenUrl is nil") if @type == 'oauth2' && (@flow == 'password' || @flow == 'application' || @flow == 'accessCode') && !new_tokenUrl
+
+      @tokenUrl = new_tokenUrl
+    end
+
+    def scopes=(new_scopes)
+      raise ArgumentError.new("Security::Data::SecurityScheme#scopes= - scopes is nil") if @type == 'oauth2' && !new_scopes
+
+      new_scopes = Swagger::Data::Scopes.parse(new_scopes) if(!new_scopes.is_a?(Swagger::Data::Scopes))
+
+      @scopes = new_scopes
+    end
+
+  end
+end

data/lib/ruby-swagger/data/tag.rb

@@ -0,0 +1,24 @@
+require 'ruby-swagger/object'
+require 'ruby-swagger/data/external_documentation'
+
+module Swagger::Data
+  class Tag < Swagger::Object #https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#tag-object
+
+    attr_swagger :name, :description, :externalDocs
+
+    def self.parse(xml_object)
+      return nil unless xml_object
+
+      Swagger::Data::Tag.new.bulk_set(xml_object)
+    end
+
+    def externalDocs=(newDoc)
+      return nil unless newDoc
+
+      newDoc = Swagger::Data::ExternalDocumentation.parse(newDoc) unless newDoc.is_a?(Swagger::Data::ExternalDocumentation)
+
+      @externalDocs=newDoc
+    end
+
+  end
+end