ruby-swagger 0.0.1

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

@@ -0,0 +1,45 @@
+require 'ruby-swagger/object'
+
+module Swagger::Data
+  class Items < Swagger::Object # https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#itemsObject
+
+    attr_swagger :type, :format, :items, :collectionFormat, :default,
+                 :maximum, :exclusiveMaximum, :minimum, :exclusiveMinimum,
+                 :maxLength, :minLength, :pattern, :maxItems,
+                 :minItems, :uniqueItems, :enum, :multipleOf
+
+    def initialize
+      @type = "string"  #we default to an array of strings
+    end
+
+    def self.parse(items)
+      return nil if items.nil?
+
+      Swagger::Data::Items.new.bulk_set(items)
+    end
+
+    def type=(new_type)
+      raise ArgumentError.new("Swagger::Data::Items#type= - type is nil") unless new_type
+      raise ArgumentError.new("Swagger::Data::Items#type= - type #{new_type} is invalid") unless %w(string number integer boolean array).include?(new_type)
+
+      @type = new_type
+    end
+
+    def items=(new_items)
+      raise ArgumentError.new("Swagger::Data::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
+
+    def collectionFormat=(new_collection_format)
+      return nil unless new_collection_format
+      raise ArgumentError.new("Swagger::Data::Items#collectionFormat= - collectionFormat #{new_collection_format} is invalid") unless %w(csv ssv tsv pipes).include?(new_collection_format)
+      @collectionFormat = new_collection_format
+    end
+
+  end
+end

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

@@ -0,0 +1,51 @@
+require 'ruby-swagger/data/url'
+require 'ruby-swagger/object'
+
+module Swagger::Data
+  class License < Swagger::Object #https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#license-object
+
+    DEFAULT_NAME = 'Apache 2.0'
+    DEFAULT_URL = 'http://www.apache.org/licenses/LICENSE-2.0.html'
+
+    attr_swagger :name, :url
+
+    def initialize
+      @name = DEFAULT_NAME
+      @url = Swagger::Data::Url.new(DEFAULT_URL)
+    end
+
+    def self.parse(license)
+      return nil unless license
+
+      Swagger::Data::License.new.bulk_set(license)
+    end
+
+    def name=(new_name)
+      raise (ArgumentError.new("Swagger::Data::License - license name is invalid ")) if new_name.nil? || new_name.empty?
+      @name = new_name
+    end
+
+    def url=(url)
+      return nil unless url
+
+      @url = Swagger::Data::Url.new(url)
+      validate_url!
+      @url
+    end
+
+    def url
+      @url.url
+    end
+
+    def valid?
+      @url.valid?
+    end
+
+    private
+
+    def validate_url!
+      raise (ArgumentError.new("Swagger::Data::License - contact url is invalid")) unless @url.valid?
+    end
+
+  end
+end

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

@@ -0,0 +1,31 @@
+module Swagger::Data
+  class Mime
+
+    @@types = [
+      'text/plain',
+      'text/plain; charset=utf-8',
+      'application/octet-stream',
+      'application/json',
+      'application/postscript',
+      'application/pdf',
+      'application/postscript',
+      'application/octet-stream',
+      'application/xml',
+      'application/zip',
+      'text/xml',
+      'text/tab-separated-values',
+      'application/vnd.github+json',
+      'application/vnd.github.v3+json',
+      'application/vnd.github.v3.raw+json',
+      'application/vnd.github.v3.text+json',
+      'application/vnd.github.v3.html+json',
+      'application/vnd.github.v3.full+json',
+      'application/vnd.github.v3.diff',
+      'application/vnd.github.v3.patch']
+
+    def self.valid?(type)
+      @@types.include?(type)
+    end
+
+  end
+end

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

@@ -0,0 +1,82 @@
+require 'ruby-swagger/object'
+require 'ruby-swagger/data/external_documentation'
+require 'ruby-swagger/data/responses'
+require 'ruby-swagger/data/security_requirement'
+
+module Swagger::Data
+  class Operation < Swagger::Object #https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#operationObject
+
+    attr_swagger :tags, :summary, :description, :externalDocs, :operationId,
+                 :consumes, :produces, :parameters, :responses,
+                 :schemes, :deprecated, :security
+
+    def self.parse(operation)
+      return unless operation
+
+      Swagger::Data::Operation.new.bulk_set(operation)
+    end
+
+    def externalDocs=(newDoc)
+      return nil unless newDoc
+
+      unless newDoc.is_a?(Swagger::Data::ExternalDocumentation)
+        newDoc = Swagger::Data::ExternalDocumentation.parse(newDoc)
+      end
+
+      @externalDocs=newDoc
+    end
+
+    def responses=(newResp)
+      return nil unless newResp
+
+      unless newResp.is_a?(Swagger::Data::Responses)
+        newResp = Swagger::Data::Responses.parse(newResp)
+      end
+
+      @responses = newResp
+    end
+
+    def security=(newSecurity)
+      return nil unless newSecurity
+
+      @security = []
+
+      newSecurity.each do |sec_object|
+        unless sec_object.is_a?(Swagger::Data::SecurityRequirement)
+          sec_object = Swagger::Data::SecurityRequirement.parse(sec_object)
+        end
+
+        @security.push(sec_object)
+      end
+    end
+
+    def parameters=(newParams)
+      return nil unless newParams
+
+      @parameters = []
+
+      newParams.each do |parameter|
+        add_parameter(parameter)
+      end
+    end
+
+    def add_parameter(new_parameter)
+      @parameters ||= []
+
+      if new_parameter.is_a?(Hash)
+
+        new_parameter = if new_parameter['$ref']
+                            #it's a reference object
+                            Swagger::Data::Reference.parse(new_parameter)
+                        else
+                            #it's a parameter object
+                            Swagger::Data::Parameter.parse(new_parameter)
+                        end
+
+      end
+
+      @parameters.push(new_parameter)
+    end
+
+  end
+end

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

@@ -0,0 +1,88 @@
+require 'ruby-swagger/object'
+require 'ruby-swagger/data/items'
+require 'ruby-swagger/data/schema'
+require 'ruby-swagger/grape/param'
+
+module Swagger::Data
+  class Parameter < Swagger::Object # https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#parameter-object
+
+    attr_swagger :name, :in, :description, :required, :schema,
+                 :type, :format, :allowEmptyValue, :items,
+                 :collectionFormat, :default, :maximum,
+                 :exclusiveMaximum, :minimum, :exclusiveMinimum,
+                 :maxLength, :minLength, :pattern, :maxItems,
+                 :minItems, :uniqueItems, :enum, :multipleOf
+
+    def self.parse(new_parameter)
+      return nil unless new_parameter
+
+      p = Swagger::Data::Parameter.new
+      %w(name in description required).each do |field|
+        p.send("#{field}=", new_parameter[field])
+      end
+
+      if p.in == 'body'
+        p.schema = Swagger::Data::Schema.parse(new_parameter['schema'])
+      else
+        %w(type format allowEmptyValue collectionFormat default maximum exclusiveMaximum minimum exclusiveMinimum maxLength minLength pattern maxItems minItems uniqueItems enum multipleOf).each do |field|
+          p.send("#{field}=", new_parameter[field])
+        end
+        p.items = Swagger::Data::Items.parse(new_parameter['items'])
+      end
+
+      p
+    end
+
+    def name=(new_name)
+      raise ArgumentError.new('Swagger::Data::Parameter#name called with nil') if new_name.nil?
+      @name = new_name
+    end
+
+    def in=(new_in)
+      raise ArgumentError.new('Swagger::Data::Parameter#in= called with nil') if new_in.nil?
+      raise ArgumentError.new("Swagger::Data::Parameter#in= called with invalid value #{new_in}") unless %w(query header path formData body).include?(new_in)
+
+      @in = new_in
+    end
+
+    def items=(new_items)
+      raise ArgumentError.new("Swagger::Data::Parameter#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
+
+    def self.from_grape(grape_parameter)
+      return nil if grape_parameter.nil? || grape_parameter.last[:type].is_a?(Hash) || grape_parameter.last[:type] == 'Hash'
+
+      grape_type = Swagger::Grape::Param.new(grape_parameter.last).to_swagger
+
+      parameter = Swagger::Data::Parameter.new
+      parameter.name= grape_parameter.first
+      parameter.in= 'formData'
+      parameter.description = grape_type['description']
+      parameter.required = grape_type['required']
+      parameter.default = grape_type['default']
+      parameter.type = grape_type['type']
+      parameter.format = grape_type['format']
+
+      if parameter.type == 'array'
+        items = Swagger::Data::Items.new
+        items.type = 'string'
+        parameter.items = items
+      end
+
+      parameter.type.nil? ? nil : parameter
+    rescue => e
+      puts "error processing parameter #{grape_parameter} [#{e}]"
+      raise e
+    end
+
+    private
+
+
+
+  end
+end

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

@@ -0,0 +1,53 @@
+require 'ruby-swagger/object'
+require 'ruby-swagger/data/parameter'
+
+module Swagger::Data
+  class Parameters < Swagger::Object # https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#parametersDefinitionsObject
+
+    def initialize
+      @parameters = {}
+    end
+
+    def self.parse(parameters)
+      return nil unless parameters
+
+      params = Swagger::Data::Parameters.new
+
+      parameters.each do |pname, pvalue|
+        params.add_param(pname, pvalue)
+      end
+
+      params
+    end
+
+    def add_param(pname, pvalue)
+      raise ArgumentError.new("Swagger::Data::Parameters#add_param - parameter name is nil") unless pname
+      raise ArgumentError.new("Swagger::Data::Parameters#add_param - parameter value is nil") unless pvalue
+
+      if !pvalue.is_a?(Swagger::Data::Parameter)
+        pvalue = Swagger::Data::Parameter.parse(pvalue)
+      end
+
+      @parameters[pname] = pvalue
+    end
+
+    def [](pname)
+      @parameters[pname]
+    end
+
+    def params
+      @parameters.keys
+    end
+
+    def as_swagger
+      swagger_params = {}
+
+      @parameters.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/path.rb

@@ -0,0 +1,115 @@
+require 'ruby-swagger/object'
+require 'ruby-swagger/data/operation'
+require 'ruby-swagger/data/parameter'
+require 'ruby-swagger/data/reference'
+
+module Swagger::Data
+  class Path < Swagger::Object #https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#path-item-object
+
+    attr_swagger :get, :put, :post, :delete, :options, :head, :patch, :parameters #and $ref
+    @ref = nil
+
+    def self.parse(path)
+      raise (ArgumentError.new("Swagger::Data::Path - path is nil")) unless path
+
+      res = Swagger::Data::Path.new.bulk_set(path)
+      res.ref= path['$ref'] if path['$ref']
+      res
+    end
+
+    def get=(new_get)
+      return nil unless new_get
+      unless new_get.is_a?(Swagger::Data::Operation)
+        new_get = Swagger::Data::Operation.parse(new_get)
+      end
+
+      @get = new_get
+    end
+
+    def self.put=(new_put)
+      return nil unless new_put
+      unless new_put.is_a?(Swagger::Data::Operation)
+        new_put = Swagger::Data::Operation.parse(new_put)
+      end
+      @put = new_put
+    end
+
+    def post=(new_post)
+      return nil unless new_post
+      unless new_post.is_a?(Swagger::Data::Operation)
+        new_post = Swagger::Data::Operation.parse(new_post)
+      end
+      @post= new_post
+    end
+
+    def delete=(new_delete)
+      return nil unless new_delete
+      unless new_delete.is_a?(Swagger::Data::Operation)
+        new_delete = Swagger::Data::Operation.parse(new_delete)
+      end
+      @delete= new_delete
+    end
+
+    def options=(new_options)
+      return nil unless new_options
+      unless new_options.is_a?(Swagger::Data::Operation)
+        new_options = Swagger::Data::Operation.parse(new_options)
+      end
+      @options= new_options
+    end
+
+    def head=(new_head)
+      return nil unless new_head
+      unless new_head.is_a?(Swagger::Data::Operation)
+        new_head = Swagger::Data::Operation.parse(new_head)
+      end
+
+      @head= new_head
+    end
+
+    def patch=(new_patch)
+      return nil unless new_patch
+      unless new_patch.is_a?(Swagger::Data::Operation)
+        new_patch = Swagger::Data::Operation.parse(new_patch)
+      end
+      @patch= new_patch
+    end
+
+    def parameters=(new_parameters)
+      return nil unless new_parameters
+      raise (ArgumentError.new("Swagger::Data::Path#parameters= - parameters is not an array")) unless new_parameters.is_a?(Array)
+
+      @parameters = []
+
+      new_parameters.each do |parameter|
+        new_param = if parameter['$ref']
+                      #it's a reference object
+                      Swagger::Data::Reference.parse(parameter)
+                    else
+                      #it's a parameter object
+                      Swagger::Data::Parameter.parse(parameter)
+                    end
+
+        @parameters.push(new_param)
+      end
+
+    end
+
+    def ref=(new_ref)
+      return nil unless new_ref
+      raise (ArgumentError.new("Swagger::Data::Path#ref= - $ref is not a string")) unless new_ref.is_a?(String)
+
+      @ref = new_ref
+    end
+
+    def ref
+      @ref
+    end
+
+    def as_swagger
+      res = super
+      res['$ref'] = @ref if @ref
+      res
+    end
+  end
+end