r2-oas 0.1.0

data/lib/r2-oas/schema/v3/object/external_document_object.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'r2-oas/plugins/schema/v3/object/hookable_base_object'
+
+module R2OAS
+  module Schema
+    module V3
+      class ExternalDocumentObject < R2OAS::Plugins::Schema::V3::HookableBaseObject
+        def create_doc
+          result = {
+            'description' => '',
+            'url' => ''
+          }
+          doc.merge!(result)
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/object/info_object.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'r2-oas/plugins/schema/v3/object/hookable_base_object'
+
+module R2OAS
+  module Schema
+    module V3
+      class InfoObject < R2OAS::Plugins::Schema::V3::HookableBaseObject
+        def create_doc
+          result = {
+            'title' => 'OAS API Document Title',
+            'description' => "This is a sample server Petstore server.  You can find out more about
+            Swagger at [http://swagger.io](http://swagger.io) or on [irc.freenode.net,
+            #swagger](http://swagger.io/irc/).  For this sample, you can use the api key
+            `special-key` to test the authorization filters.",
+            'termsOfService' => 'http://swagger.io/terms/',
+            # Contact Object
+            'contact' => {
+              'name' => '',
+              'url' => ''
+            },
+            # License Object
+            'license' => {
+              'name' => '',
+              'url' => ''
+            },
+            'version' => '1.0.0'
+          }
+          doc.merge!(result)
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/object/openapi_object.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative 'base_object'
+require_relative 'tag_object'
+require_relative 'server_object'
+
+module R2OAS
+  module Schema
+    module V3
+      class OpenapiObject < BaseObject
+        def initialize(routes_data, tags_data, schemas_data)
+          super()
+          @routes_data  = routes_data
+          @tags_data    = tags_data
+          @schemas_data = schemas_data
+        end
+
+        def to_doc
+          {
+            'openapi' => '3.0.0',
+            'info' => info_doc,
+            'tags' => tags_doc,
+            'paths' => paths_doc,
+            'externalDocs' => external_docs_doc,
+            'servers' => servers_doc,
+            'components' => components_doc
+          }
+        end
+
+        private
+
+        def info_doc
+          info_object_class.new.to_doc
+        end
+
+        def tags_doc
+          TagObject.new(@tags_data).to_doc
+        end
+
+        def paths_doc
+          paths_object_class.new(@routes_data).to_doc
+        end
+
+        def external_docs_doc
+          external_document_object_class.new.to_doc
+        end
+
+        def servers_doc
+          ServerObject.new.to_doc
+        end
+
+        def components_doc
+          components_object_class.new(@routes_data).to_doc
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/object/path_item_object.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'r2-oas/plugins/schema/v3/object/hookable_base_object'
+require 'r2-oas/routing/components/path_component'
+
+module R2OAS
+  module Schema
+    module V3
+      class PathItemObject < R2OAS::Plugins::Schema::V3::HookableBaseObject
+        extend Forwardable
+        # reference
+        # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#path-item-object
+        # Support Field Name: get, put, post, delete, patch
+        SUPPORT_FIELD_NAME = %w[get put post delete patch].freeze
+
+        def_delegators :@http_status_manager, :http_statuses
+
+        def initialize(route_data, path)
+          super()
+          @path_comp                      = Routing::PathComponent.new(path)
+          @path                           = @path_comp.symbol_to_brace
+          @route_data                     = route_data
+          @verb                           = route_data[:verb]
+          @tag_name                       = route_data[:tag_name]
+          @schema_name                    = route_data[:schema_name]
+          @required_parameters            = route_data[:required_parameters]
+          @format_name                    = create_format_name
+          @http_status_manager            = HttpStatusManager.new(@path, @verb, http_statuses_when_http_method)
+          @components_schema_object       = components_schema_object_class.new(route_data, path)
+          @components_request_body_object = components_request_body_object_class.new(route_data, path)
+          support_field_name? if route_data.key?(:verb)
+        end
+
+        def to_doc
+          execute_before_create(@path)
+          create_doc
+          execute_after_create(@path)
+          doc
+        end
+
+        def create_doc
+          result = { @verb.to_s => data_when_verb }
+          attach_request_body!(result)
+          attach_media_type!(result)
+          attach_parameters!(result)
+          doc.merge!(result)
+        end
+
+        private
+
+        def data_when_verb
+          result = {
+            'tags' => [@tag_name.to_s],
+            'summary' => "#{@verb} summary",
+            'description' => "#{@verb} description",
+            # Response Object
+            'responses' => {},
+            'deprecated' => false
+          }
+          result['responses'].deep_merge!(responses_when_http_status)
+          result
+        end
+
+        def responses_when_http_status
+          http_statuses.each_with_object({}) do |http_status, result|
+            result.deep_merge!(
+              http_status => {
+                'description' => "#{@tag_name} description",
+                'content' => {
+                  'application/json' => {
+                    'schema' => {
+                      '$ref' => "#/components/schemas/#{_components_schema_name(http_status)}"
+                    }
+                  }
+                }
+              }
+            )
+          end
+        end
+
+        def _components_schema_name(http_status)
+          @components_schema_object.send(:_components_schema_name, http_status)
+        end
+
+        def _components_request_body_name
+          @components_request_body_object.send(:_components_request_body_name)
+        end
+
+        def create_format_name
+          format_name = @route_data[:format_name]
+          if format_name.blank?
+            ''
+          else
+            "application/#{format_name}"
+          end
+        end
+
+        def attach_request_body!(schema)
+          return schema unless @components_request_body_object.generate?
+
+          merge_schema = {
+            '$ref' => "#/components/requestBodies/#{_components_request_body_name}"
+          }
+          schema[@verb.to_s]['requestBody'] = {}
+          schema[@verb.to_s]['requestBody'].deep_merge!(merge_schema)
+          schema
+        end
+
+        def attach_media_type!(schema)
+          return schema if @format_name.blank?
+
+          merge_schema = {
+            '200' => {
+              'description' => 'responses description',
+              'content' => {
+                @format_name.to_s => {}
+              }
+            }
+          }
+          schema[@verb.to_s]['responses'].deep_merge!(merge_schema)
+          schema
+        end
+
+        def attach_parameters!(schema)
+          return schema if @required_parameters.blank?
+
+          content = @required_parameters.each_with_object([]) do |(parameter_name, parameter_data), result|
+            result.push(
+              'name' => parameter_name.to_s,
+              'in' => 'path',
+              'description' => parameter_name.to_s,
+              'required' => true,
+              'schema' => {
+                'type' => parameter_data[:type]
+              }
+            )
+          end
+
+          merge_schema = {
+            'parameters' => content
+          }
+
+          schema[@verb.to_s].deep_merge!(merge_schema)
+          schema
+        end
+
+        def support_field_name?
+          raise "Invalid filed name #{field_name}" unless SUPPORT_FIELD_NAME.include?(@verb)
+        end
+
+        class HttpStatusManager
+          def initialize(path, verb, http_statuses_when_http_method)
+            @path_comp                      = Routing::PathComponent.new(path)
+            @verb                           = verb
+            @http_statuses_when_http_method = http_statuses_when_http_method
+          end
+
+          def http_statuses
+            key = @path_comp.exist_path_parameters? ? :path_parameter : :default
+            @http_statuses_when_http_method[@verb.to_sym][key]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/object/paths_object.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'r2-oas/plugins/schema/v3/object/hookable_base_object'
+
+module R2OAS
+  module Schema
+    module V3
+      class PathsObject < R2OAS::Plugins::Schema::V3::HookableBaseObject
+        def initialize(routes_data)
+          super()
+          @routes_data = routes_data
+          define_hookable_tmp_object_class
+        end
+
+        def create_doc
+          if unit_paths_file_path.present?
+            unit_paths_data = YAML.load_file(unit_paths_file_path)['paths']
+            result = unit_paths_data.each_with_object({}) do |(path, path_item_doc), docs|
+              docs[path] = HookableTmpObjectClass.new(path_item_doc, path).to_doc
+            end
+          else
+            result = path_item_docs.each_with_object({}) do |(path, path_item_doc), docs|
+              docs[path] = path_item_doc
+            end
+          end
+          doc.merge!(result)
+        end
+
+        private
+
+        def define_hookable_tmp_object_class
+          klass = Class.new(path_item_object_class) do |_c|
+            def initialize(data, path)
+              super
+              @data = data
+              @path = path
+              use_superclass_hook
+            end
+
+            def create_doc
+              doc.merge!(@data)
+            end
+
+            def to_doc
+              execute_before_create(@path)
+              create_doc
+              execute_after_create(@path)
+              doc
+            end
+          end
+          Object.const_set(:HookableTmpObjectClass, klass) unless defined?(HookableTmpObjectClass)
+        end
+
+        def path_item_docs
+          # e.x.)
+          # [
+          #  { path: "/tasks", data: {:verb=>"get", :path=>"/tasks", :tag_name=>"task" } },
+          # ]
+          @routes_data.each_with_object({}) do |(route_el), data|
+            path = route_el[:path]
+            route_data = route_el[:data]
+
+            path_item_doc = path_item_object_class.new(route_data, path).to_doc
+            if data[path].present?
+              data[path].merge!(path_item_doc)
+            else
+              data[path] = path_item_doc
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/object/public.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'info_object'
+require_relative 'paths_object'
+require_relative 'path_item_object'
+require_relative 'external_document_object'
+require_relative 'components_object'
+require_relative 'components/schema_object'
+require_relative 'components/request_body_object'

data/lib/r2-oas/schema/v3/object/server_object.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'base_object'
+
+module R2OAS
+  module Schema
+    module V3
+      class ServerObject < BaseObject
+        def to_doc
+          server.data.each_with_object([]) do |server, result|
+            result.push(
+              'url' => (server[:url]).to_s,
+              'description' => (server[:description]).to_s
+            )
+            # Do not Server Variable Object
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/object/tag_object.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'base_object'
+require_relative 'path_item_object'
+
+module R2OAS
+  module Schema
+    module V3
+      class TagObject < BaseObject
+        def initialize(tags_data)
+          @tags_data = tags_data
+        end
+
+        def to_doc
+          @tags_data.each_with_object([]) do |tag_name, result|
+            result.push(create_doc(tag_name))
+          end
+        end
+
+        private
+
+        def create_doc(tag_name)
+          {
+            'name' => tag_name,
+            'description' => "#{tag_name} description",
+            # External Docs Object
+            'externalDocs' => {
+              'description' => 'description',
+              'url' => 'url'
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/squeezer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'squeezer/base_squeezer'
+require_relative 'squeezer/tag_squeezer'
+require_relative 'squeezer/path_squeezer'
+
+module R2OAS
+  module Schema
+    module V3
+      class Squeezer < BaseSqueezer
+        def squeeze_docs
+          except_paths_schema = @schema_data.except('paths', 'tags', 'components')
+          components_schemas = @schema_data.slice('components')
+
+          path_squeezer = PathSqueezer.new(@schema_data, many_paths_file_paths: many_paths_file_paths)
+          tag_squeezer = TagSqueezer.new(@schema_data, many_paths_file_paths: many_paths_file_paths)
+
+          # To make components merge after paths
+          slice_schemas = [
+            tag_squeezer.squeeze_docs,
+            path_squeezer.squeeze_docs,
+            components_schemas
+          ]
+          slice_schemas.each_with_object(except_paths_schema) { |slice_schema, result| result.deep_merge!(slice_schema) }
+        end
+      end
+    end
+  end
+end