r2-oas 0.3.0 → 0.4.0

data/lib/r2-oas/schema/v3/object/from_files/components/schema_object.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'r2-oas/shared/callable'
+require 'r2-oas/errors'
+require_relative '../base_object'
+require_relative '../utils/all'
+
+module R2OAS
+  module Schema
+    module V3
+      module FromFiles
+        module Components
+          class SchemaObject < ::R2OAS::Schema::V3::FromFiles::BaseObject
+            include ::R2OAS::Callable
+            include DeepMethods
+
+            def initialize(doc, ref, opts)
+              super(opts)
+              @doc = doc
+              @parent_ref = Components::SchemaRef.new(ref)
+              resolve_dependencies!
+            end
+
+            def to_doc
+              call_ref_path!
+
+              # MEMO:
+              # If it is overwritten, it may lead to unexpected problems, so give a copy
+              execute_transform_plugins(:components_schema, @doc, ref_dup)
+              @doc
+            end
+
+            def resolve_dependencies!
+              deep_replace!(@doc, '$ref') do |ref_path|
+                schema_obj, schema_type, pure_schema_name = ref_path.split('/').slice(1..-1)
+                schema_doc = root_doc&.fetch(schema_obj, nil)&.fetch(schema_type, nil)&.fetch(pure_schema_name, nil) || {}
+
+                ref = create_child_ref(pure_schema_name)
+                obj = Components::SchemaObject.new(schema_doc, ref, opts)
+
+                obj_store.add('components/schemas', pure_schema_name, obj)
+                obj
+              end
+            end
+
+            def call_ref_path!
+              callback = proc { |obj| obj.ref_path }
+              deep_call(@doc, '$ref', callback)
+            end
+
+            def schema_name
+              return @resolved_schema_name if @resolved_schema_name.present?
+
+              before_schema_name = ref_dup[:schema_name]
+
+              _ref_dup = ref_dup
+              execute_transform_plugins(:components_schema_name, _ref_dup)
+              @resolved_schema_name = _ref_dup[:schema_name]
+
+              if before_schema_name != @resolved_schema_name
+                if reserved_schema_name_list.include?(@resolved_schema_name)
+                  raise DepulicateSchemaNameError, "Transformed schema name: '#{@resolved_schema_name}' cannot be used. It already exists."
+                else
+                  obj_store.appended_components_schema_name_list.push(@resolved_schema_name)
+                end
+              end
+
+              @resolved_schema_name
+            end
+
+            def ref_path
+              "#/components/schemas/#{schema_name}"
+            end
+
+            private
+
+            def ref_dup
+              @parent_ref.dup
+            end
+
+            def reserved_schema_name_list
+              (
+                obj_store.components_schema_name_list +
+                obj_store.appended_components_schema_name_list
+              ).uniq
+            end
+
+            def create_child_ref(schema_name)
+              local_ref_hash = ref_dup.to_h
+              parent_schema_name = local_ref_hash[:schema_name]
+              depth = local_ref_hash[:depth] + 1
+              ref_data = local_ref_hash.merge({ from: :schema, schema_name: schema_name, parent_schema_name: parent_schema_name, depth: depth })
+              ref = Components::SchemaRef.new(ref_data)
+              ref.send(:parent=, ref_dup)
+              ref
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/object/from_files/components_object.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'base_object'
+require_relative 'components/schema_object'
+require_relative 'components/request_body_object'
+
+module R2OAS
+  module Schema
+    module V3
+      module FromFiles
+        class ComponentsObject < BaseObject
+          def initialize(doc, opts = {})
+            super(opts)
+            @doc = doc
+          end
+
+          def to_doc
+            create_doc
+            @doc
+          end
+
+          private
+
+          def create_doc
+            create_components_schema_docs!
+            create_components_request_body_docs!
+          end
+
+          def create_components_schema_docs!
+            result = obj_store.gets('components/schemas').each_with_object({}) do |obj, data|
+              data[obj.schema_name] = obj.to_doc
+            end
+            @doc.merge!('schemas' => result) if result.present?
+          end
+
+          def create_components_request_body_docs!
+            result = obj_store.gets('components/requestBodies').each_with_object({}) do |obj, data|
+              data[obj.schema_name] = obj.to_doc
+            end
+            @doc.merge!('requestBodies' => result) if result.present?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'base_object'
+
+module R2OAS
+  module Schema
+    module V3
+      module FromFiles
+        class ExternalDocumentObject < BaseObject
+          def initialize(doc, opts = {})
+            super(opts)
+            @doc = doc
+          end
+
+          def to_doc
+            execute_transform_plugins(:external_document, @doc)
+            @doc
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'base_object'
+
+module R2OAS
+  module Schema
+    module V3
+      module FromFiles
+        class InfoObject < BaseObject
+          def initialize(doc, opts = {})
+            super(opts)
+            @doc = doc
+          end
+
+          def to_doc
+            execute_transform_plugins(:info, @doc)
+            @doc
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative 'base_object'
+require_relative 'info_object'
+require_relative 'paths_object'
+require_relative 'external_document_object'
+require_relative 'components_object'
+
+module R2OAS
+  module Schema
+    module V3
+      module FromFiles
+        class OpenapiObject < BaseObject
+          def initialize(doc, opts = {})
+            super(opts)
+            @doc = doc
+            set_root_doc(doc)
+            set_components_name_list(doc)
+          end
+
+          def to_doc
+            execute_transform_plugins(:setup)
+            # MEMO:
+            # Make sure paths_doc is run first
+            # This is because the components object is stored in the store by executing paths_doc
+            # and it is looped to generate the component document.
+            result = {
+              'openapi' => '3.0.0',
+              'info' => info_doc,
+              'tags' => @doc['tags'],
+              'paths' => paths_doc,
+              'externalDocs' => external_docs_doc,
+              'servers' => @doc['servers'],
+              'components' => components_doc
+            }
+            execute_transform_plugins(:teardown)
+            result
+          end
+
+          private
+
+          def info_doc
+            InfoObject.new(@doc['info'], @opts).to_doc
+          end
+
+          def paths_doc
+            PathsObject.new(@doc['paths'], @opts).to_doc
+          end
+
+          def external_docs_doc
+            ExternalDocumentObject.new(@doc['externalDocs'], @opts).to_doc
+          end
+
+          def components_doc
+            ComponentsObject.new(@doc['components'], @opts).to_doc
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'r2-oas/shared/callable'
+require_relative 'base_object'
+require_relative 'components/schema_object'
+require_relative 'components/request_body_object'
+require_relative 'utils/all'
+
+module R2OAS
+  module Schema
+    module V3
+      module FromFiles
+        class PathItemObject < BaseObject
+          include ::R2OAS::Callable
+          include DeepMethods
+
+          def initialize(doc, ref, opts = {})
+            super(opts)
+            @doc = doc
+            @parent_ref = PathRef.new(ref)
+            resolve_dependencies!
+          end
+
+          def to_doc
+            call_ref_path!
+
+            # MEMO:
+            # If it is overwritten, it may lead to unexpected problems, so give a copy
+            execute_transform_plugins(:path_item, @doc, ref_dup)
+            @doc
+          end
+
+          # Breaking changes to @doc
+          def resolve_dependencies!
+            local_ref_hash = ref_dup.to_h
+
+            @doc.each do |verb, data_when_verb|
+              local_ref_hash[:verb] = verb
+              local_ref_hash[:tag_name] = data_when_verb['tags'].first
+
+              resolve_dependencies_at_schema!(@doc, verb, data_when_verb, local_ref_hash)
+              resolve_dependencies_at_request_body!(@doc, verb, data_when_verb, local_ref_hash)
+            end
+          end
+
+          def call_ref_path!
+            callback = proc { |obj| obj.ref_path }
+            deep_call(@doc, '$ref', callback)
+          end
+
+          private
+
+          def ref_dup
+            @parent_ref.dup
+          end
+
+          def resolve_dependencies_at_schema!(data, verb, data_when_verb, local_ref_hash)
+            data_when_verb['responses'].each do |http_status, data_when_http_status|
+              local_ref_hash[:http_status] = http_status
+
+              deep_replace!(data_when_http_status, '$ref') do |ref_path|
+                schema_obj, schema_type, schema_name = ref_path.split('/').slice(1..-1)
+                schema_doc = root_doc&.fetch(schema_obj, nil)&.fetch(schema_type, nil)&.fetch(schema_name, nil) || {}
+
+                ref = create_child_schema_ref(schema_name, local_ref_hash)
+                obj = Components::SchemaObject.new(schema_doc, ref, opts)
+
+                obj_store.add('components/schemas', schema_name, obj)
+                obj
+              end
+
+              data[verb]['responses'][http_status] = data_when_http_status
+            end
+          end
+
+          def resolve_dependencies_at_request_body!(data, verb, data_when_verb, local_ref_hash)
+            deep_replace!(data_when_verb['requestBody'], '$ref') do |ref_path|
+              schema_obj, schema_type, schema_name = ref_path.split('/').slice(1..-1)
+              schema_doc = root_doc&.fetch(schema_obj, nil)&.fetch(schema_type, nil)&.fetch(schema_name, nil) || {}
+
+              ref = create_child_request_body_ref(schema_name, local_ref_hash)
+              obj = Components::RequestBodyObject.new(schema_doc, ref, opts)
+
+              obj_store.add('components/requestBodies', schema_name, obj)
+
+              data[verb]['requestBody']['$ref'] = obj
+              obj
+            end
+          end
+
+          def create_child_schema_ref(schema_name, local_ref_hash)
+            local_ref_hash_dup = local_ref_hash.dup
+            ref_data = local_ref_hash_dup.merge({ from: :path_item, schema_name: schema_name, depth: 0 })
+            ref = Components::SchemaRef.new(ref_data)
+          end
+
+          def create_child_request_body_ref(schema_name, local_ref_hash)
+            local_ref_hash_dup = local_ref_hash.dup
+            # MEMO:
+            # requestBody does not depend on http_status
+            local_ref_hash_dup.delete(:http_status)
+
+            ref_data = local_ref_hash_dup.merge({ from: :path_item, schema_name: schema_name, depth: 0 })
+            ref = Components::RequestBodyRef.new(ref_data)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'base_object'
+require_relative 'path_item_object'
+
+module R2OAS
+  module Schema
+    module V3
+      module FromFiles
+        class PathsObject < BaseObject
+          def initialize(doc, opts = {})
+            super(opts)
+            @doc = doc
+          end
+
+          def to_doc
+            create_doc
+            @doc
+          end
+
+          private
+
+          def create_doc
+            @doc.each do |path, doc_when_path|
+              ref = { path: path }
+              @doc[path] = PathItemObject.new(doc_when_path, ref, opts).to_doc
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/object/from_files/utils/all.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'deep_methods'
+require_relative 'refs'

data/lib/r2-oas/schema/v3/object/from_files/utils/deep_methods.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module R2OAS
+  module Schema
+    module V3
+      module FromFiles
+        module DeepMethods
+          def deep_replace!(data, target, &blk)
+            return unless data.is_a?(Hash)
+
+            data.each do |key, value|
+              if key.eql? target
+                # MEMO:
+                # When using the same schema, it has already been replaced by an object
+                if value.is_a?(String)
+                  data[key] = block_given? ? yield(value) : value
+                end
+              else
+                deep_replace!(value, target, &blk)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r2-oas/schema/v3/object/from_files/utils/refs.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'r2-oas/errors'
+
+module R2OAS
+  module Schema
+    module V3
+      module FromFiles
+        class BaseRef
+          def pretty_print(q)
+            pp_hash(q, to_h)
+          end
+
+          attr_reader :parent
+
+          def []=(key, value)
+            if writable_keys.include?(key)
+              send(:"#{key}=", value)
+              value
+            else
+              display_key = key.is_a?(Symbol) ? ":#{key}" : key
+              raise ::R2OAS::RefInvalidAssignment, "invalid method `[#{display_key}]=' called for #{self}"
+            end
+          end
+
+          def [](key)
+            send(key)
+          end
+
+          def to_h
+            valid_keys.each_with_object({}) do |key, result|
+              result[key] = send(key)
+            end
+          end
+
+          private
+
+          # MEMO:
+          # https://apidock.com/ruby/v1_9_3_392/PP/PPMethods/pp_hash
+          def pp_hash(q, obj)
+            q.group(1, '{', '}') do
+              q.seplist(obj, nil, :each_pair) do |k, v|
+                q.group do
+                  q.pp k
+                  q.text '=>'
+                  q.group(1) do
+                    q.breakable ''
+                    q.pp v
+                  end
+                end
+              end
+            end
+          end
+
+          def build(ref_or_data, merge_data = {})
+            data = ref_or_data.to_h.merge(merge_data)
+            data.keys.each do |key|
+              instance_variable_set(:"@#{key}", data[key])
+            end
+
+            @parent = ref_or_data if ref_or_data.respond_to?(:parent)
+          end
+
+          attr_writer :parent
+
+          def valid_keys
+            raise NoImplementError, 'Please implement in inherited class.'
+          end
+
+          def writable_keys
+            raise NoImplementError, 'Please implement in inherited class.'
+          end
+        end
+
+        class PathRef < BaseRef
+          VALID_KEYS = %i[type path].freeze
+
+          attr_reader(*VALID_KEYS)
+
+          def initialize(data)
+            build(data, { type: :path_item })
+          end
+
+          private
+
+          attr_writer(*VALID_KEYS)
+
+          def valid_keys
+            VALID_KEYS
+          end
+
+          def writable_keys
+            []
+          end
+        end
+
+        module Components
+          class SchemaRef < BaseRef
+            READONLY_KEYS = %i[type path parent_schema_name depth tag_name verb http_status from].freeze
+            WRITABLE_KEYS = [:schema_name].freeze
+            VALID_KEYS = READONLY_KEYS + WRITABLE_KEYS
+
+            attr_reader(*VALID_KEYS)
+            attr_writer(*WRITABLE_KEYS)
+
+            def initialize(ref_or_data)
+              build(ref_or_data, { type: :schema })
+            end
+
+            private
+
+            attr_writer(*READONLY_KEYS)
+
+            def valid_keys
+              VALID_KEYS
+            end
+
+            def writable_keys
+              WRITABLE_KEYS
+            end
+          end
+
+          class RequestBodyRef < BaseRef
+            READONLY_KEYS = %i[type path parent_schema_name depth tag_name verb from].freeze
+            WRITABLE_KEYS = [:schema_name].freeze
+            VALID_KEYS = READONLY_KEYS + WRITABLE_KEYS
+
+            attr_accessor(*VALID_KEYS)
+            attr_writer(*WRITABLE_KEYS)
+
+            def initialize(ref_or_data)
+              build(ref_or_data, { type: :request_body })
+            end
+
+            private
+
+            attr_writer(*READONLY_KEYS)
+
+            def valid_keys
+              VALID_KEYS
+            end
+
+            def writable_keys
+              WRITABLE_KEYS
+            end
+          end
+        end
+      end
+    end
+  end
+end