ruby-swagger 0.0.1

data/lib/ruby-swagger/grape/param.rb

@@ -0,0 +1,33 @@
+require 'ruby-swagger/grape/type'
+
+module Swagger::Grape
+  class Param
+
+    def initialize(param)
+      @param = param
+    end
+
+    def to_swagger
+      swagger_param = {}
+      swagger_param['description'] = @param[:desc]  if @param[:desc].present?
+      swagger_param['default'] = @param[:default]   if @param[:default].present?
+
+      swagger_param.merge! Swagger::Grape::Type.new(@param[:type]).to_swagger
+
+      swagger_param
+    end
+
+    def has_type_definition?
+      type.downcase == 'object'
+    end
+
+    def type_definition
+      (Object.const_get(type)).to_s
+    end
+
+    def type
+      @param[:type].to_s || 'string'
+    end
+
+  end
+end

data/lib/ruby-swagger/grape/route_path.rb

@@ -0,0 +1,37 @@
+require 'ruby-swagger/data/path'
+require 'ruby-swagger/data/operation'
+require 'ruby-swagger/grape/method'
+
+module Swagger::Grape
+  class RoutePath
+
+    attr_reader :types, :scopes
+
+    def initialize(route_name)
+      @name = route_name
+      @operations = {}
+      @types = []
+      @scopes = []
+    end
+
+    def add_operation(route)
+      method = Swagger::Grape::Method.new(@name, route)
+      grape_operation = method.operation
+
+      @types = (@types | method.types).uniq
+      @scopes = (@scopes | method.scopes).uniq
+      @operations[route.route_method.downcase] = grape_operation
+    end
+
+    def to_swagger
+      path = Swagger::Data::Path.new
+
+      @operations.each do |operation_verb, operation|
+        path.send("#{operation_verb}=", operation)
+      end
+
+      path
+    end
+
+  end
+end

data/lib/ruby-swagger/grape/routes.rb

@@ -0,0 +1,52 @@
+require 'ruby-swagger/data/paths'
+require 'ruby-swagger/data/path'
+require 'ruby-swagger/grape/route_path'
+
+module Swagger::Grape
+  class Routes
+
+    attr_reader :types, :scopes
+
+    def initialize(routes)
+      @routes = routes
+      @types = []
+      @scopes = []
+    end
+
+    def to_swagger
+      swagger = Swagger::Data::Paths.new
+      paths = {}
+
+      @routes.each do |route|
+
+        next if route.route_hidden == true  #implement custom "hidden" extension
+
+        swagger_path_name = swagger_path_name(route)
+        paths[swagger_path_name] ||= Swagger::Grape::RoutePath.new(swagger_path_name)
+        paths[swagger_path_name].add_operation(route)
+      end
+
+      paths.each do |path_name, path|
+        swagger.add_path(path_name, path.to_swagger)
+        @types = (@types | path.types).uniq
+        @scopes = (@scopes | path.scopes).uniq
+      end
+
+      swagger
+    end
+
+    private
+
+    def swagger_path_name(grape_route)
+      grape_path_name = grape_route.route_path
+      grape_prefix = grape_route.route_prefix
+      grape_path_name.gsub!(/^\/#{grape_prefix}/, '') if grape_prefix
+      grape_path_name.gsub!(/^\/:version/, '') #remove api version - if any
+      grape_path_name.gsub!(/\(\.:format\)$/, '') #remove api format - if any
+      grape_path_name.gsub!(/\(\..+\)$/, '') #remove api format - if any
+      grape_path_name.gsub!(/\/:([a-zA-Z0-9_]+)/, '/{\1}')  #convert parameters from :format into {format}
+      grape_path_name
+    end
+
+  end
+end

data/lib/ruby-swagger/grape/type.rb

@@ -0,0 +1,141 @@
+module Swagger::Grape
+  class Type
+
+    attr_reader :discovered_types
+
+    def initialize(type)
+      @type = type.to_s || 'String'
+    end
+
+    def to_swagger(with_definition = true)
+      type_convert(@type.to_s, with_definition)
+    end
+
+    def sub_types
+      type = Object.const_get(@type)
+      return [] unless type.respond_to?(:exposures)
+
+      types = []
+
+      type.exposures.each do |property, definition|
+        types << definition[:using] if definition[:using].present?
+      end
+
+      types.uniq
+    end
+
+    private
+
+    def type_convert(type, with_definition = true)
+      swagger_type = {}
+
+      case type.downcase
+        when 'string'
+          swagger_type['type'] = 'string'
+        when 'integer'
+          swagger_type['type'] = 'integer'
+        when 'array'
+          swagger_type['type'] = 'array'
+          swagger_type['items'] = {'type' => 'string'}
+        when 'hash'
+          swagger_type['type'] = 'object'
+          swagger_type['properties'] = {}
+        when 'boolean'
+          swagger_type['type'] = 'boolean'
+        when 'virtus::attribute::boolean'
+          swagger_type['type'] = 'boolean'
+        when 'symbol'
+          swagger_type['type'] = 'string'
+        when 'float'
+          swagger_type['type'] = 'number'
+          swagger_type['format'] = 'float'
+        when 'rack::multipart::uploadedfile'
+          swagger_type['type'] = 'string'
+          STDERR.puts "Warning - I have no idea how to handle the type file. Right now I will consider this a string, but we should probably handle it..."
+        when 'date'
+          swagger_type['type'] = 'date'
+        when 'datetime'
+          swagger_type['format'] = 'date-time'
+          swagger_type['format'] = 'string'
+        else
+          swagger_type['type'] = "object"
+
+          if with_definition
+            # I can just reference the name of the object here
+            swagger_type['$ref'] = "#/definitions/#{type}"
+          else
+            type = Object.const_get(@type)
+            # I need to define the full object
+            raise ArgumentError.new("Don't know how to translate the object #{@type}") unless type.respond_to?(:exposures)
+
+            swagger_type['properties'] = {}
+
+            type.exposures.each do |property, definition|
+
+              cursor = swagger_type
+              target = property.to_s
+
+              if definition[:nested]
+                # it's a nested parameter
+                path = target.split('__')
+                cursor = find_elem_in_schema(cursor, path.dup)
+                target = path.last
+              end
+
+              target = definition[:as].to_s if definition[:as].present?
+
+              cursor['properties'][target] = {}
+
+              if definition[:documentation].present? && definition[:documentation][:type].present?
+                cursor['properties'][target] = type_convert(definition[:documentation][:type].to_s, true)
+              end
+
+              if definition[:using].present?
+                #it's either an object or an array of object
+                using = type_convert(definition[:using].to_s, true)
+
+                if cursor['type'].present? && cursor['type'] == 'array'
+                  cursor['items'] = using
+                else
+                  cursor['properties'][target] = using
+                end
+
+              end
+
+              cursor['properties'][target]['description'] = definition[:documentation][:desc] if definition[:documentation].present?
+              cursor['properties'][target]['type'] ||= 'string'  #no type defined, assuming it's a string
+            end
+          end
+      end
+
+      swagger_type
+    end
+
+    def find_elem_in_schema(root, schema_path)
+      return root if schema_path.nil? || schema_path.empty?
+
+      next_elem = schema_path.shift
+
+      return root if root['properties'][next_elem].nil?
+
+      case root['properties'][next_elem]['type']
+        when 'array'
+          #to descend an array this must be an array of objects
+          root['properties'][next_elem]['items']['type'] = 'object'
+          root['properties'][next_elem]['items']['properties'] ||= {}
+
+          find_elem_in_schema(root['properties'][next_elem]['items'], schema_path)
+        when 'object'
+          find_elem_in_schema(root['properties'][next_elem], schema_path)
+        else
+          # I'm discending an object that before I assumed was something else
+          root['properties'][next_elem]['type'] = 'object'
+          root['properties'][next_elem]['properties'] ||= {}
+
+          find_elem_in_schema(root['properties'][next_elem], schema_path)
+      end
+
+    end
+
+  end
+end

data/lib/ruby-swagger/io/comparable.rb

@@ -0,0 +1,30 @@
+module Swagger::IO
+  class Comparable
+
+    def self.copy_description_old_definition(definition, old_definition)
+      return if definition.nil? || old_definition.nil? || definition.class != old_definition.class
+
+      case definition
+        when Hash
+
+          definition.keys.each do |key|
+            old_v = definition[key]
+
+            if (key == 'description' || key == 'summary') && old_definition[key]
+              definition[key] = old_definition[key]
+            end
+
+            if old_v.is_a?(Hash) || old_v.is_a?(Array)
+              copy_description_old_definition(definition[key], old_definition[key])
+            end
+          end
+        when Array
+          definition.each_with_index do |item, index|
+            copy_description_old_definition(definition[index], old_definition[index])
+          end
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,48 @@
+require 'ruby-swagger/io/file_system'
+require 'ruby-swagger/io/comparable'
+
+module Swagger::IO
+  class Definitions
+
+    def self.read_definitions
+      definitions = {}
+
+      Swagger::IO::FileSystem.all_files("definitions/**/*.yml").each do |file|
+        definitions[File.basename(file, ".yml")] = YAML::load_file(file)
+      end
+
+      definitions
+    end
+
+    def self.write_definitions(definitions)
+      return if definitions.nil?
+
+      #Remove dead definitions
+      Swagger::IO::FileSystem.all_files("definitions/**/*.yml").each do |file|
+        def_name = File.basename(file, ".yml")
+
+        unless definitions[def_name]
+          STDERR.puts "#{def_name} is not present anymore, removing #{file}"
+          Swagger::IO::FileSystem.delete_file(file)
+        end
+
+      end
+
+      # Write new definitions
+      definitions.each do |definition_name, definition|
+
+        # If an old definition exists, we copy over the documentation to the generated definition
+        if Swagger::IO::FileSystem.file_exists?("definitions/#{definition_name}.yml")
+          old_definition = Swagger::IO::FileSystem.read_file("definitions/#{definition_name}.yml")
+
+          Swagger::IO::Comparable.copy_description_old_definition(definition, old_definition)
+        end
+
+        Swagger::IO::FileSystem.write_file(definition.to_yaml, "definitions/#{definition_name}.yml", true)
+      end
+    end
+
+
+  end
+
+end

data/lib/ruby-swagger/io/file_system.rb

@@ -0,0 +1,97 @@
+require 'ruby-swagger/object'
+require 'ruby-swagger/data/document'
+require 'ruby-swagger/io/security'
+require 'ruby-swagger/io/definitions'
+require 'ruby-swagger/io/paths'
+
+module Swagger::IO
+  class FileSystem
+
+    DOC_SUBPARTS = %w(responses security tags)
+
+    @@default_path = './doc/swagger'
+
+    def self.default_path=(new_path)
+      @@default_path = new_path
+    end
+
+    def self.default_path
+      @@default_path
+    end
+
+    def self.init_fs_structure
+      FileUtils.mkdir_p(@@default_path) unless Dir.exists?(@@default_path)
+    end
+
+    def self.read_file(name)
+      YAML::load_file(@@default_path + '/' + name)
+    end
+
+    def self.write_file(content, location, overwrite = false)
+      file_path = @@default_path + '/' + location
+
+      return if !overwrite && File.exists?(file_path)
+
+      dir_path = File.dirname(file_path)
+
+      FileUtils.mkdir_p(dir_path) unless Dir.exists?(dir_path)
+      File.open(file_path, 'w') {|f| f.write(content) }
+    end
+
+    def self.file_exists?(name)
+      File.exists?(@@default_path + '/' + name)
+    end
+
+    def self.all_files(pattern)
+      Dir["#{@@default_path}/#{pattern}"]
+    end
+
+    def self.delete_file(file)
+      FileUtils.rm_f(file)
+    end
+
+    def initialize(swagger_doc)
+      @doc = swagger_doc
+    end
+
+    def write!
+      Swagger::IO::FileSystem.init_fs_structure
+
+      swagger = @doc.to_swagger
+
+      Swagger::IO::Paths.write_paths(swagger.delete('paths'))
+
+      DOC_SUBPARTS.each {|doc_part| write_subpart(doc_part, swagger.delete(doc_part))}
+      Swagger::IO::Definitions.write_definitions(swagger.delete('definitions'))
+      Swagger::IO::Security.write_security_definitions(swagger.delete('securityDefinitions'))
+      Swagger::IO::FileSystem.write_file(swagger.to_yaml, 'base_doc.yml')
+    end
+
+    def self.read
+      doc = YAML::load_file("#{default_path}/base_doc.yml")
+
+      DOC_SUBPARTS.each do |doc_part|
+        file_path = "#{default_path}/#{doc_part}.yml"
+        doc[doc_part] = YAML::load_file(file_path) if File.exists?(file_path)
+      end
+
+      doc['paths'] = Swagger::IO::Paths.read_paths
+      doc['definitions'] = Swagger::IO::Definitions.read_definitions
+      doc['securityDefinitions'] = Swagger::IO::Security.read_security_definitions
+ 
+      Swagger::Data::Document.parse(doc)
+    end
+
+    def compile!
+      Swagger::IO::FileSystem.write_file(JSON.pretty_generate(@doc.to_swagger), 'swagger.json', true)
+    end
+
+    private
+
+    def write_subpart(subpart, content)
+      return unless content
+      write_file(content.to_yaml, "#{subpart}.yml")
+    end
+
+  end
+end