ruby-swagger 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6d94ab24421b81598d6242602e17f2cefaf039d6
+  data.tar.gz: a7656dc9e774420f7a063d25cff63715bce4ca42
+SHA512:
+  metadata.gz: e2677461caa8dacfcc5d68f4fef90e1dc78ba1188207e462067b078e94a629113d3ad2ff9cdbca8b522b6c11d2591378c607e731b395821930b5fae01b829101
+  data.tar.gz: 4dac18bf044a8dcc43caf9a94a5bb5c9e0484428fbf84ebc7172303e185fe9dd1f1dc0b227118a5900e676ac8917bc80813f989d04f2f6d43db8fea800dec021

data/lib/ruby-swagger.rb

@@ -0,0 +1,7 @@
+require 'ruby-swagger/data/document'
+
+require 'ruby-swagger/railtie' if defined?(Rails)
+
+if defined?(Grape)
+  require 'ruby-swagger/grape/grape'
+end

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

@@ -0,0 +1,49 @@
+require 'json'
+require 'yaml'
+require 'ruby-swagger/data/url'
+require 'ruby-swagger/object'
+
+module Swagger::Data
+  class Contact < Swagger::Object #https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#contactObject
+
+    DEFAULT_NAME = 'John Doe'
+    DEFAULT_EMAIL = 'john.doe@example.com'
+    DEFAULT_URL = 'https://google.com/?q=john%20doe'
+
+    attr_swagger :name, :email, :url
+
+    def initialize
+      @name = DEFAULT_NAME
+      @email = DEFAULT_EMAIL
+      @url = Swagger::Data::Url.new DEFAULT_URL
+    end
+
+    def self.parse(contact)
+      return nil unless contact
+
+      c = Swagger::Data::Contact.new.bulk_set(contact)
+      c.validate_url!
+
+      c
+    end
+
+    def url=(url)
+      return nil unless url
+
+      @url = Swagger::Data::Url.new(url)
+    end
+
+    def url
+      @url.url
+    end
+
+    def valid?
+      true
+    end
+
+    def validate_url!
+      raise (ArgumentError.new("Swagger::Data::Contact - contact url is invalid")) if @url && !@url.valid?
+    end
+
+  end
+end

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

@@ -0,0 +1,49 @@
+require 'ruby-swagger/object'
+require 'ruby-swagger/data/schema'
+
+module Swagger::Data
+  class Definitions < Swagger::Object #https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#definitionsObject
+
+    def initialize
+      @definitions = {}
+    end
+
+    def self.parse(definitions)
+      return nil unless definitions
+
+      definition = Swagger::Data::Definitions.new
+
+      definitions.each do |definition_name, definition_value|
+        definition.add_definition(definition_name, definition_value)
+      end
+
+      definition
+    end
+
+    def add_definition(definition_name, definition_value)
+      raise ArgumentError.new("Swagger::Data::Definitions#add_definition - definition_name is nil") unless definition_name
+      raise ArgumentError.new("Swagger::Data::Definitions#add_definition - definition_value is nil") unless definition_value
+
+      if !definition_value.is_a?(Swagger::Data::Schema)
+        definition_value = Swagger::Data::Schema.parse(definition_value)
+      end
+
+      @definitions[definition_name] = definition_value
+    end
+
+    def [](key)
+      @definitions[key]
+    end
+
+    def as_swagger
+      swagger_defs = {}
+
+      @definitions.each do |def_k, def_v|
+        swagger_defs[def_k] = def_v.to_swagger
+      end
+
+      swagger_defs
+    end
+
+  end
+end

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

@@ -0,0 +1,181 @@
+require 'json'
+require 'ruby-swagger/object'
+require 'ruby-swagger/data/info'
+require 'ruby-swagger/data/mime'
+require 'ruby-swagger/data/paths'
+require 'ruby-swagger/data/definitions'
+require 'ruby-swagger/data/parameters'
+require 'ruby-swagger/data/responses'
+require 'ruby-swagger/data/security_definitions'
+require 'ruby-swagger/data/security_requirement'
+require 'ruby-swagger/data/tag'
+require 'ruby-swagger/data/external_documentation'
+
+module Swagger::Data
+  class Document < Swagger::Object  #https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#swagger-object
+
+    SPEC_VERSION = '2.0'  #https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#fixed-fields
+    DEFAULT_HOST = 'localhost:80'
+
+    attr_swagger :swagger, :info, :host, :basePath, :schemes, :consumes,
+                 :produces, :paths, :definitions, :parameters, :responses, :securityDefinitions,
+                 :security, :tags, :externalDocs
+
+    # create an empty document
+    def initialize
+      @swagger = '2.0'
+      @info = Swagger::Data::Info.new
+      @paths = Swagger::Data::Paths.new
+    end
+
+    # parse an hash document into a set of Swagger objects
+    #   document is a hash
+    def self.parse(document)
+      raise (ArgumentError.new("Swagger::Document#parse - document object is nil")) unless document
+
+      Swagger::Data::Document.new.bulk_set(document)
+    end
+
+    def swagger=(new_swagger)
+      raise (ArgumentError.new("Swagger::Document#swagger= - the document is not a swagger #{SPEC_VERSION} version")) unless "2.0" == new_swagger
+      @swagger = new_swagger
+    end
+
+    def info=(new_info)
+      raise (ArgumentError.new("Swagger::Document#info= - info object is nil")) unless new_info
+
+      new_info = Swagger::Data::Info.parse(new_info) unless new_info.is_a?(Swagger::Data::Info)
+
+      @info = new_info
+    end
+
+    def basePath=(new_path)
+      new_path = new_path.nil? ? '/' : new_path
+
+      if !(new_path =~ /^\/.+$/)
+        new_path = "/#{new_path}" #new path must start with a /
+      end
+
+      @basePath ||= new_path
+    end
+
+    def schemes=(new_schemes)
+      return nil unless new_schemes
+
+      new_schemes.each do |scheme|
+        raise (ArgumentError.new("Swagger::Data::Document#schemes= - unrecognized scheme #{scheme}")) unless %w(http https ws wss).include?(scheme)
+      end
+
+      @schemes = new_schemes
+    end
+
+    def produces=(new_produces)
+      return nil unless new_produces
+
+      new_produces.each do |produce|
+        raise (ArgumentError.new("Swagger::Data::Document#produces= - unrecognized produce type #{produce}")) unless Swagger::Data::Mime.valid?(produce)
+      end
+
+      @produces = new_produces
+    end
+
+    def consumes=(new_consumes)
+      return nil unless new_consumes
+
+      new_consumes.each do |consume|
+        raise (ArgumentError.new("Swagger::Data::Document#consumes= - unrecognized consume type #{consume}]")) unless Swagger::Data::Mime.valid?(consume)
+      end
+
+      @consumes= new_consumes
+    end
+
+    def paths=(new_paths)
+      raise ArgumentError.new("Swagger::Data::Document#paths= - paths is nil") unless paths
+
+      new_paths = Swagger::Data::Paths.parse(new_paths) if(!new_paths.is_a?(Swagger::Data::Paths))
+
+      @paths = new_paths
+    end
+
+    def definitions=(new_definitions)
+      return nil unless new_definitions
+
+      if (!new_definitions.is_a?(Swagger::Data::Definitions))
+        new_definitions = Swagger::Data::Definitions.parse(new_definitions)
+      end
+
+      @definitions = new_definitions
+    end
+
+    def parameters=(new_parameters)
+      return nil unless new_parameters
+
+      if (!new_parameters.is_a?(Swagger::Data::Parameters))
+        new_parameters = Swagger::Data::Parameters.parse(new_parameters)
+      end
+
+      @parameters = new_parameters
+    end
+
+    def responses=(new_responses)
+      return nil unless new_responses
+
+      if (!new_responses.is_a?(Swagger::Data::Responses))
+        new_responses = Swagger::Data::Responses.parse(new_responses)
+      end
+
+      @responses = new_responses
+    end
+
+    def securityDefinitions=(newSecurityDef)
+      return nil unless newSecurityDef
+
+      if (!newSecurityDef.is_a?(Swagger::Data::SecurityDefinitions))
+        newSecurityDef = Swagger::Data::SecurityDefinitions.parse(newSecurityDef)
+      end
+
+      @securityDefinitions= newSecurityDef
+    end
+
+    def security=(new_security)
+      return nil unless new_security
+
+      if (!new_security.is_a?(Swagger::Data::SecurityRequirement))
+        new_security = Swagger::Data::SecurityRequirement.parse(new_security)
+      end
+
+      @security = new_security
+    end
+
+    def tags=(new_tags)
+      return nil unless new_tags
+
+      @tags = []
+
+      new_tags.each do |tag|
+        add_tag(tag)
+      end
+    end
+
+    def add_tag(new_tag)
+      return nil unless new_tag
+
+      if (!new_tag.is_a?(Swagger::Data::Tag))
+        new_tag = Swagger::Data::Tag.parse(new_tag)
+      end
+
+      @tags.push(new_tag)
+    end
+
+    def externalDocs=(new_externalDocs)
+      return nil unless new_externalDocs
+
+      if (!new_externalDocs.is_a?(Swagger::Data::ExternalDocumentation))
+        new_externalDocs = Swagger::Data::ExternalDocumentation.parse(new_externalDocs)
+      end
+
+      @externalDocs = new_externalDocs
+    end
+
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'ruby-swagger/object'
+
+module Swagger::Data
+  class Example < Swagger::Object #https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#exampleObject
+
+    attr_accessor :examples
+
+    def initialize
+      @examples = {}
+    end
+
+    def self.parse(new_examples)
+      return nil unless new_examples
+
+      ex_obj = Swagger::Data::Example.new
+
+      examples = {}
+      new_examples.each {|example_mime, example| examples[example_mime] = example }
+      ex_obj.examples = examples
+
+      ex_obj
+    end
+
+    def as_swagger
+      @examples
+    end
+
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'ruby-swagger/object'
+
+module Swagger::Data
+  class ExternalDocumentation < Swagger::Object #https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#externalDocumentationObject
+
+    attr_swagger :url, :description
+
+    def initialize
+      @url = "http://localhost"
+    end
+
+    def self.parse(external)
+      return nil unless external
+
+      Swagger::Data::ExternalDocumentation.new.bulk_set(external)
+    end
+
+    def url=(new_url)
+      raise (ArgumentError.new("Swagger::Data::ExternalDocumentation#url - url is nil")) unless new_url
+      @url = new_url
+    end
+
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'ruby-swagger/object'
+require 'ruby-swagger/data/items'
+
+module Swagger::Data
+  class Header < Swagger::Object # https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#header-object
+
+    attr_swagger :description, :type, :format, :items,
+                 :collectionFormat, :default, :maximum,
+                 :exclusiveMaximum, :minimum, :exclusiveMinimum,
+                 :maxLength, :minLength, :pattern, :maxItems,
+                 :minItems, :uniqueItems, :enum, :multipleOf
+
+    def self.parse(header)
+      return nil unless header
+
+      Swagger::Data::Header.new.bulk_set(header)
+    end
+
+    def type=(new_type)
+      raise ArgumentError.new('Swagger::Data::Header#type called with nil') if new_type.nil?
+      @type = new_type
+    end
+
+    def items=(new_items)
+      raise ArgumentError.new("Swagger::Data::Header#items= items is nil") if new_items.nil? && @type == 'array'
+      if !new_items.nil? && !new_items.is_a?(Swagger::Data::Items)
+        new_items = Swagger::Data::Items.parse(new_items)
+      end
+
+      @items = new_items
+    end
+
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'ruby-swagger/object'
+require 'ruby-swagger/data/header'
+
+module Swagger::Data
+  class Headers < Swagger::Object # https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#headersObject
+
+    def initialize
+      @headers = {}
+    end
+
+    def self.parse(headers)
+      return nil unless headers
+
+      h = Swagger::Data::Headers.new
+
+      headers.each {|header_key, header_value| h.add_header(header_key, header_value) }
+
+      h
+    end
+
+    def add_header(header_key, header_value)
+      raise ArgumentError.new("Swagger::Data::Headers#add_header - parameter name is nil") unless header_key
+      raise ArgumentError.new("Swagger::Data::Headers#add_header - parameter value is nil") unless header_value
+
+      if !header_value.is_a?(Swagger::Data::Header)
+        header_value = Swagger::Data::Header.parse(header_value)
+      end
+
+      @headers[header_key] = header_value
+    end
+
+    def [](key)
+      @headers[key]
+    end
+
+    def as_swagger
+      res = {}
+
+      @headers.each do |key, value|
+        res[key] = value.to_swagger
+      end
+
+      res
+    end
+
+
+  end
+end

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

@@ -0,0 +1,56 @@
+require 'ruby-swagger/object'
+require 'ruby-swagger/data/contact'
+require 'ruby-swagger/data/license'
+
+module Swagger::Data
+  class Info < Swagger::Object  #https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#info-object
+
+    DEFAULT_TITLE = 'My uber-duper API'
+    DEFAULT_DESCRIPTION = 'My uber-duper API description'
+    DEFAULT_VERSION = '0.1'
+
+    attr_swagger :title, :description, :termsOfService, :contact, :license, :version
+
+    def initialize
+      @title = DEFAULT_TITLE
+      @description = DEFAULT_DESCRIPTION
+      @version = DEFAULT_VERSION
+    end
+
+    def self.parse(info)
+      raise (ArgumentError.new("Swagger::Data::Info#parse - info object is nil")) unless info
+
+      Swagger::Data::Info.new.bulk_set(info)
+    end
+
+    def title=(new_title)
+      raise (ArgumentError.new("Swagger::Data::Info#title= - title is invalid")) if new_title.nil? || new_title.empty?
+      @title = new_title
+    end
+
+    def contact=(new_contact)
+      return nil unless new_contact
+
+      if(!new_contact.is_a?(Swagger::Data::Contact))
+        new_contact = Swagger::Data::Contact.parse(new_contact)
+      end
+
+      @contact = new_contact
+    end
+
+    def license=(new_license)
+      return nil unless new_license
+
+      if(!new_license.is_a?(Swagger::Data::License))
+        new_license = Swagger::Data::License.parse(new_license)
+      end
+
+      @license = new_license
+    end
+
+    def valid?
+      @license.valid? && @contact.valid?
+    end
+
+  end
+end