dox 1.1.0 → 2.0.0

data/lib/dox/formatters/base.rb

@@ -0,0 +1,19 @@
+module Dox
+  module Formatters
+    class Base
+      def initialize(http_env)
+        @http_env = http_env
+        http_env_body = http_env.body
+        @body = http_env_body.respond_to?(:read) ? http_env_body.read : http_env_body
+      end
+
+      def format
+        raise 'no format method defined in formatter'
+      end
+
+      private
+
+      attr_reader :http_env, :body
+    end
+  end
+end

data/lib/dox/formatters/json.rb

@@ -0,0 +1,14 @@
+module Dox
+  module Formatters
+    class Json < Dox::Formatters::Base
+      def format
+        # in cases where the body isn't valid JSON
+        # and the headers specify the Content-Type is application/json
+        # an error should be raised
+        return '' if body.nil? || body.length < 2
+
+        JSON.pretty_generate(JSON.parse(body))
+      end
+    end
+  end
+end

data/lib/dox/formatters/multipart.rb

@@ -0,0 +1,23 @@
+require 'rack'
+
+module Dox
+  module Formatters
+    class Multipart
+      def initialize(http_env)
+        @http_env = http_env
+      end
+
+      def format
+        JSON.pretty_generate(extracted_multipart)
+      end
+
+      private
+
+      def extracted_multipart
+        Rack::Multipart.extract_multipart(http_env)
+      end
+
+      attr_reader :http_env
+    end
+  end
+end

data/lib/dox/formatters/plain.rb

@@ -0,0 +1,13 @@
+module Dox
+  module Formatters
+    class Plain < Dox::Formatters::Base
+      def format
+        return body if body.encoding == Encoding::UTF_8
+
+        body.encode(Encoding::UTF_8)
+      rescue Encoding::UndefinedConversionError
+        "#{body.encoding} stream"
+      end
+    end
+  end
+end

data/lib/dox/formatters/xml.rb

@@ -0,0 +1,14 @@
+module Dox
+  module Formatters
+    class Xml < Dox::Formatters::Base
+      def format
+        doc = REXML::Document.new(body)
+        formatter = REXML::Formatters::Pretty.new
+        formatter.compact = true
+        result = ''
+        formatter.write(doc, result)
+        result
+      end
+    end
+  end
+end

data/lib/dox/printers/action_printer.rb

@@ -3,44 +3,35 @@ module Dox
     class ActionPrinter < BasePrinter
       def print(action)
         self.action = action
-        @output.puts action_title
-        @output.puts action_uri_params if action.uri_params.present?
+        @action_hash = find_or_add(find_or_add(spec, action.path.to_s), action.verb.downcase.to_sym)
 
-        action.examples.each do |example|
-          example_printer.print(example)
-        end
+        add_action
+        add_action_params
+
+        print_examples
       end
 
       private
 
-      attr_accessor :action
-
-      def action_title
-        <<-HEREDOC
+      attr_accessor :action, :action_hash
 
-### #{action.name} [#{action.verb.upcase} #{action.path}]
-#{print_desc(action.desc)}
-        HEREDOC
+      def add_action
+        action_hash['summary'] = action.name
+        action_hash['tags'] = [action.resource]
+        action_hash['description'] = format_desc(action.desc)
       end
 
-      def action_uri_params
-        <<-HEREDOC
-+ Parameters
-#{formatted_params(action.uri_params)}
-        HEREDOC
-      end
+      def add_action_params
+        return unless action.params.present?
 
-      def example_printer
-        @example_printer ||= ExamplePrinter.new(@output)
+        action_hash['parameters'] = action.params
       end
 
-      def formatted_params(uri_params)
-        uri_params.map do |param, details|
-          desc = "    + #{CGI.escape(param.to_s)}: `#{CGI.escape(details[:value].to_s)}` (#{details[:type]}, #{details[:required]})"
-          desc += " - #{details[:description]}" if details[:description].present?
-          desc += "\n        + Default: #{details[:default]}" if details[:default].present?
-          desc
-        end.flatten.join("\n")
+      def print_examples
+        action.examples.each do |example|
+          ExampleRequestPrinter.new(action_hash).print(example)
+          ExampleResponsePrinter.new(action_hash).print(example)
+        end
       end
     end
   end

data/lib/dox/printers/base_printer.rb

@@ -1,37 +1,56 @@
+require 'rexml/document'
+
 module Dox
   module Printers
     class BasePrinter
-      def initialize(output)
-        @output = output
+      attr_reader :spec
+
+      def initialize(spec)
+        @spec = spec || {}
       end
 
       def print
         raise NotImplementedError
       end
 
-      private
+      def find_or_add(hash, key, default = {})
+        return hash[key] if hash.key?(key)
 
-      def descriptions_folder_path
-        Dox.config.desc_folder_path
+        hash[key] = default
       end
 
-      def print_desc(desc, fullpath = false)
-        return if desc.blank?
+      def read_file(path, root_path: Dox.config.descriptions_location)
+        return '' unless root_path
+
+        File.read(File.join(root_path, path))
+      end
 
-        if desc.to_s =~ /.*\.md$/
-          path = if fullpath
-                   desc
-                 else
-                   descriptions_folder_path.join(desc).to_s
-                 end
-          content(path)
+      def formatted_body(body_str, content_type)
+        case content_type
+        when %r{application\/.*json}
+          JSON.parse(body_str)
+        when /xml/
+          pretty_xml(body_str)
         else
-          desc
+          body_str
         end
       end
 
-      def content(path)
-        File.read(path)
+      def pretty_xml(xml_string)
+        doc = REXML::Document.new(xml_string)
+        formatter = REXML::Formatters::Pretty.new
+        formatter.compact = true
+        result = ''
+        formatter.write(doc, result)
+        result
+      end
+
+      def format_desc(description)
+        desc = description
+        desc = '' if desc.nil?
+        desc = read_file(desc) if desc.end_with?('.md')
+
+        desc
       end
     end
   end

data/lib/dox/printers/document_printer.rb

@@ -1,26 +1,56 @@
 module Dox
   module Printers
     class DocumentPrinter < BasePrinter
+      def initialize(output)
+        super(body)
+        @output = output
+      end
+
       def print(passed_examples)
-        print_meta_info
+        spec['paths'] = {}
+        spec['tags'] = []
+        spec['x-tagGroups'] = []
 
         passed_examples.sort.each do |_, resource_group|
           group_printer.print(resource_group)
         end
+
+        order_groups
+
+        @output.puts(JSON.pretty_generate(spec))
       end
 
       private
 
-      def group_printer
-        @group_printer ||= ResourceGroupPrinter.new(@output)
+      def body
+        {
+          openapi: Dox.config.openapi_version || '3.0.0',
+          info: {
+            title: Dox.config.title || 'API Documentation',
+            description: adjust_description(Dox.config.header_description || ''),
+            version: Dox.config.api_version || '1.0'
+          }
+        }
+      end
+
+      def adjust_description(description)
+        description.end_with?('.md') ? acquire_desc(description) : description
+      end
+
+      def acquire_desc(path)
+        read_file(path)
       end
 
-      def print_meta_info
-        @output.puts(print_desc(api_desc_path))
+      def group_printer
+        @group_printer ||= ResourceGroupPrinter.new(spec)
       end
 
-      def api_desc_path
-        Dox.config.header_file_path
+      def order_groups
+        return if (Dox.config.groups_order || []).empty?
+
+        spec['x-tagGroups'] = spec['x-tagGroups'].sort_by do |tag|
+          Dox.config.groups_order.index(tag[:name]) || 100
+        end
       end
     end
   end

data/lib/dox/printers/example_request_printer.rb

@@ -0,0 +1,69 @@
+module Dox
+  module Printers
+    class ExampleRequestPrinter < BasePrinter
+      def print(example)
+        self.example = example
+        add_example_request
+      end
+
+      private
+
+      attr_accessor :example
+
+      def add_example_request
+        spec['parameters'] = add_new_header_params(find_or_add(spec, 'parameters', []))
+        return if example.request_body.empty?
+
+        add_content(find_or_add(spec, 'requestBody'))
+      end
+
+      def add_content(body)
+        add_content_name(body['content'] = find_or_add(body, 'content'))
+      end
+
+      def add_content_name(body)
+        req_header = find_headers(example.request_headers)
+        add_example(body[req_header] = find_or_add(body, req_header))
+        add_schema(body[req_header], Dox.config.schema_request_folder_path)
+      end
+
+      def add_example(body)
+        add_desc(body['examples'] = find_or_add(body, 'examples'))
+      end
+
+      def add_desc(body)
+        body[example.desc] = { 'summary' => example.desc,
+                               'value' => formatted_body(example.request_body,
+                                                         example.request_content_type) }
+      end
+
+      def add_schema(body, path)
+        return if example.request_schema.nil?
+        return unless path
+
+        file_path = File.join(path, "#{example.request_schema}.json")
+
+        body['schema'] = File.file?(file_path) ? { '$ref' => file_path } : JSON.parse(example.request_schema)
+      end
+
+      def find_headers(headers)
+        headers.find { |key, _| key == 'Accept' }&.last || 'any'
+      end
+
+      def acquire_header_params
+        example.request_headers.map do |key, value|
+          { name: key, in: :header, example: value }
+        end
+      end
+
+      def add_new_header_params(header_params)
+        example.request_headers.each do |key, value|
+          header_params.push(name: key, in: :header, example: value) unless
+            header_params.detect { |hash| hash[:name] == key }
+        end
+
+        header_params
+      end
+    end
+  end
+end

data/lib/dox/printers/example_response_printer.rb

@@ -0,0 +1,86 @@
+module Dox
+  module Printers
+    class ExampleResponsePrinter < BasePrinter
+      def print(example)
+        self.example = example
+        add_example_response
+      end
+
+      private
+
+      attr_accessor :example
+
+      def add_example_response
+        add_statuses(find_or_add(find_or_add(spec, 'responses'), example.response_status.to_s))
+      end
+
+      def add_statuses(body)
+        add_status_desc(body)
+        add_content(body)
+        add_headers(body)
+      end
+
+      def add_status_desc(body)
+        body['description'] = Util::Http::HTTP_STATUS_CODES[example.response_status]
+      end
+
+      def add_content(body)
+        add_content_name(body['content'] = find_or_add(body, 'content'))
+      end
+
+      def add_content_name(body)
+        resp_header = find_headers(example.response_headers)
+
+        add_example(body[resp_header] = find_or_add(body, resp_header))
+        add_schema(body[resp_header], Dox.config.schema_response_folder_path)
+      end
+
+      def add_example(body)
+        return if example.response_body.empty?
+
+        add_desc(body['examples'] = find_or_add(body, 'examples'))
+      end
+
+      def add_desc(body)
+        body[example.desc] = { 'summary' => example.desc,
+                               'value' => formatted_body(example.response_body,
+                                                         find_headers(example.response_headers)) }
+      end
+
+      def add_schema(body, path)
+        return unless path
+
+        schema = find_schema
+
+        return unless schema
+
+        add_schema_to_hash(body, path, schema)
+      end
+
+      def find_schema
+        if example.response_success?
+          example.response_schema_success
+        else
+          example.response_schema_fail || Dox.config.schema_response_fail_file_path
+        end
+      end
+
+      def add_schema_to_hash(body, path, schema)
+        body['schema'] =
+          if schema.is_a?(Pathname)
+            { '$ref' => schema }
+          else
+            { '$ref' => File.join(path, "#{schema}.json") }
+          end
+      end
+
+      def find_headers(headers)
+        headers.find { |key, _| key == 'Content-Type' }&.last || 'any'
+      end
+
+      def add_headers(body)
+        body['headers'] = Hash[example.response_headers.map { |key, value| [key, { description: value }] }]
+      end
+    end
+  end
+end