zero-rails_openapi 1.5.2 → 1.5.3

data/documentation/examples/examples_controller.rb

@@ -54,7 +54,7 @@ class Api::V1::ExamplesController < Api::V1::BaseController
             :name! => String, # <= schema_type is `String`
         :password! => { type: String, pattern: /[0-9]{6,10}/, desc: 'password' },
         # optional
-          :remarks => { type: String, desc: 'remarks' }, # <= schema_type is `String`, and schema_hash is { desc: '..' }
+          :remarks => { type: String, desc: 'remarks' }, # <= schema_type is `String`, and schema_info is { desc: '..' }
     }
   end
 end

data/documentation/parameter.md

@@ -1,4 +1,4 @@
-### More Explanation for `param` and `schema_hash`
+### More Explanation for `param` and `schema_info`
 
 #### param_type (param_location)
 OpenAPI 3.0 distinguishes between the following parameter types based on the parameter location: 
@@ -15,7 +15,7 @@ Parameter's (schema) type. We call it `schema_type` because it is inside SchemaO
 
 Support all [data types](https://github.com/OAI/OpenAPI-Specification/blob/OpenAPI.next/versions/3.0.0.md#dataTypes) defined in OAS.   
 
-In addition, you can use `format` in schema_hash to define in fine detail the data type being used, like: 
+In addition, you can use `format` in schema_info to define in fine detail the data type being used, like: 
 int32, float, date ...  
 All the types you can use as following:
   - **String, 'binary', 'base64'**
@@ -41,7 +41,7 @@ All the types you can use as following:
 #### Schema Hash
 
 The [[schema]](https://github.com/OAI/OpenAPI-Specification/blob/OpenAPI.next/versions/3.0.0.md#schemaObject) defining the type used for the parameter. 
-schema_hash(optional) will be used to generate Schema Object inside Parameter Object.  
+schema_info(optional) will be used to generate Schema Object inside Parameter Object.  
 [source code](https://github.com/zhandao/zero-rails_openapi/blob/master/lib/oas_objs/schema_obj.rb)  
 You can set the schema by following keys (all are optional), the words in parentheses are available aliases of the keys:  
   - **enum (values, allowable_values)**  

data/lib/oas_objs/param_obj.rb

@@ -19,29 +19,18 @@ module OpenApi
       end
 
       def process
-        assign(desc).to_processed 'description'
-        processed.tap { |it| it[:schema] = schema.process }
+        assign(desc).to_processed :description
+        assign(schema.process).to_processed :schema
+        processed
       end
 
       def desc
-        return _desc unless __desc.present?
-        schema.preprocess_with_desc __desc
+        return self[:desc] || self[:description] if (self[:desc!] || self[:description!]).blank?
+        schema.__desc # not a copy of __desc, means desc() will change if schema.__desc changes.
       end
 
-
-      # Getters and Setters of the original values that was passed to param()
-      # This mapping allows user to select the aliases in DSL writing,
-      #   without increasing the complexity of the implementation.
-      { # SELF_MAPPING
-          _range:  %i[ range   number_range ],
-          _length: %i[ length  lth          ],
-          _desc:   %i[ desc    description  ],
-          __desc:  %i[ desc!   description! ],
-      }.each do |key, aliases|
-        define_method key do
-          aliases.each { |alias_name| self[key] ||= self[alias_name] } if self[key].nil?
-          self[key]
-        end
+      def name
+        processed[:name]
       end
     end
   end

data/lib/oas_objs/ref_obj.rb

@@ -13,7 +13,8 @@ module OpenApi
         }
       end
 
-      def process; processed; end
+      def process; processed end
+      def name; nil end
     end
   end
 end

data/lib/oas_objs/schema_obj.rb

@@ -13,55 +13,30 @@ module OpenApi
 
       attr_accessor :processed, :type, :preprocessed
 
-      def initialize(type, schema_hash)
+      def initialize(type, schema_info)
         self.preprocessed = false
         self.processed = { }
-        # [Note] Here is no limit to type, even if the input isn't up to OAS,
-        #          like: double, float, hash.
-        #        My consideration is, OAS can't express some cases like:
-        #          `total_price` should be double, is_a `price`, and match /^.*\..*$/
-        #        However, user can decide how to write --
-        #          `type: number, format: double`, or `type: double`
         self.type = type
-        merge! schema_hash
+        merge! schema_info
       end
 
       def process(options = { inside_desc: false })
-        return processed if preprocessed
-
         processed.merge!(processed_type)
-        reducx(
-            processed_enum_and_length,
-            processed_range,
-            processed_is_and_format,
-            {
-                pattern:    _pattern.is_a?(String)? _pattern : _pattern&.inspect&.delete('/'),
-                default:    _default,
-                examples:   self[:examples].present? ? ExampleObj.new(self[:examples], self[:exp_by]).process : nil
-            },
-            { as: _as, permit: _permit, not_permit: _npermit, req_if: _req_if, opt_if: _opt_if, blankable: _blank },
-        ).then_merge!
-        reducx(processed_desc(options)).then_merge! # TODO
-      end
-
-      def preprocess_with_desc desc
-        self.__desc = desc
-        process
-        self.preprocessed = true
-        __desc
+        reducx(enum_and_length, range, is_and_format, pattern_default_and_other, desc(options)).then_merge!
       end
 
-      def processed_desc(options)
+      def desc(inside_desc:)
         result = __desc ? auto_generate_desc : _desc
-        options[:inside_desc] ? { description: result } : nil
+        return unless inside_desc
+        { description: result }
       end
 
       def processed_type(type = self.type)
         t = type.class.in?([Hash, Array, Symbol]) ? type : type.to_s.downcase
         if t.is_a? Hash
-          processed_hash_type(t)
+          hash_type(t)
         elsif t.is_a? Array
-          processed_array_type(t)
+          array_type(t)
         elsif t.is_a? Symbol
           RefObj.new(:schema, t).process
         elsif t.in? %w[ float double int32 int64 ]
@@ -77,33 +52,17 @@ module OpenApi
         end
       end
 
-      def processed_hash_type(t)
-        # For supporting this:
-        #   form 'desc', type: {
-        #     id!: { type: Integer, enum: 0..5, desc: 'user id' }
-        # }, should have description within schema
-        if t.key?(:type)
-          SchemaObj.new(t[:type], t).process(inside_desc: true)
-
-        # For supporting combined schema in nested schema.
-        elsif (t.keys & %i[ one_of any_of all_of not ]).present?
-          CombinedSchema.new(t).process(inside_desc: true)
-        else
-          processed_obj_type(t)
-        end
-      end
-
-      def processed_enum_and_length
+      def enum_and_length
         process_enum_info
         process_range_enum_and_lth
 
         # generate length range fields by _lth array
-        if (lth = _length || [ ]).is_a?(Array)
+        if (lth = _length || '').is_a?(Array)
           min, max = [lth.first&.to_i, lth.last&.to_i]
         elsif lth['ge']
-          max = lth.to_s.split('_').last.to_i
-        elsif lth['le']
           min = lth.to_s.split('_').last.to_i
+        elsif lth['le']
+          max = lth.to_s.split('_').last.to_i
         end
 
         if processed[:type] == 'array'
@@ -113,23 +72,32 @@ module OpenApi
         end.merge!(enum: _enum).keep_if &value_present
       end
 
-      def processed_range
+      def range
         range = _range || { }
         {
-            minimum: range[:gt] || range[:ge],
+                     minimum: range[:gt] || range[:ge],
             exclusiveMinimum: range[:gt].present? ? true : nil,
-            maximum: range[:lt] || range[:le],
+                     maximum: range[:lt] || range[:le],
             exclusiveMaximum: range[:lt].present? ? true : nil
         }.keep_if &value_present
       end
 
-      def processed_is_and_format
+      def is_and_format
         result = { is: _is }
         # `format` that generated in process_type() may be overwrote here.
         result[:format] = _format || _is if processed[:format].blank? || _format.present?
         result
       end
 
+      def pattern_default_and_other
+        {
+            pattern:    _pattern.is_a?(String)? _pattern : _pattern&.inspect&.delete('/'),
+            default:    _default,
+            examples:   self[:examples].present? ? ExampleObj.new(self[:examples], self[:exp_by]).process : nil,
+            as: _as, permit: _permit, not_permit: _npermit, req_if: _req_if, opt_if: _opt_if, blankable: _blank
+        }
+      end
+
 
       { # SELF_MAPPING
           _enum:    %i[ enum in  values  allowable_values ],
@@ -151,11 +119,7 @@ module OpenApi
       }.each do |key, aliases|
         define_method key do
           return self[key] unless self[key].nil?
-          
-          aliases.each do |alias_name|
-            break if self[key] == false
-            self[key] ||= self[alias_name]
-          end
+          aliases.each { |alias_name| self[key] = self[alias_name] if self[key].nil? }
           self[key]
         end
         define_method "#{key}=" do |value| self[key] = value end

data/lib/oas_objs/schema_obj_helpers.rb

@@ -1,23 +1,23 @@
 module OpenApi
   module DSL
     module SchemaObjHelpers
-      # TODO: more info and desc configure
-      def auto_generate_desc
-        return __desc if processed[:enum].blank?
+      def hash_type(t)
+        # For supporting this:
+        #   form 'desc', type: {
+        #     id!: { type: Integer, enum: 0..5, desc: 'user id' }
+        # }, should have description within schema
+        if t.key?(:type)
+          SchemaObj.new(t[:type], t).process(inside_desc: true)
 
-        if @enum_info.present?
-          @enum_info.each_with_index do |(info, value), index|
-            __desc.concat "<br/>#{index + 1}/ #{info}: #{value}"
-          end
+          # For supporting combined schema in nested schema.
+        elsif (t.keys & %i[ one_of any_of all_of not ]).present?
+          CombinedSchema.new(t).process(inside_desc: true)
         else
-          processed[:enum].each_with_index do |value, index|
-            __desc.concat "<br/>#{index + 1}/ #{value}"
-          end
+          obj_type(t)
         end
-        __desc
       end
 
-      def processed_obj_type(t)
+      def obj_type(t)
         obj_type = { type: 'object', properties: { }, required: [ ] }
 
         t.each do |prop_name, prop_type|
@@ -27,7 +27,7 @@ module OpenApi
         obj_type.keep_if &value_present
       end
 
-      def processed_array_type(t)
+      def array_type(t)
         t = t.size == 1 ? t.first : { one_of: t }
         {
             type: 'array',
@@ -36,16 +36,16 @@ module OpenApi
       end
 
       def process_range_enum_and_lth
-        self[:_enum] = str_range_2a(_enum) if _enum.present? && _enum.is_a?(Range)
-        self[:_length] = str_range_2a(_length) if _length.present? && _length.is_a?(Range)
+        self[:_enum] = str_range_toa(_enum) if _enum.is_a?(Range)
+        self[:_length] = str_range_toa(_length) if _length.is_a?(Range)
 
         values = _enum || _value
         self._enum = Array(values) if truly_present?(values)
       end
 
-      def str_range_2a(val)
+      def str_range_toa(val)
         val_class = val.first.class
-        action = "to_#{val_class.to_s.downcase[0]}".to_sym
+        action = :"to_#{val_class.to_s.downcase[0]}"
         (val.first.to_s..val.last.to_s).to_a.map(&action)
       end
 
@@ -55,10 +55,26 @@ module OpenApi
         #     'all_desc': :all,
         #     'one_desc': :one
         # }
-        self._enum ||= self[:enum!]
-        return unless self[:enum!].is_a? Hash
-        @enum_info = self[:enum!]
-        self._enum = self[:enum!].values
+        self._enum ||= e = self[:enum!]
+        return unless e.is_a? Hash
+        @enum_info = e
+        self._enum = e.values
+      end
+
+      # TODO: more info and desc configure
+      def auto_generate_desc
+        return __desc if _enum.blank?
+
+        if @enum_info.present?
+          @enum_info.each_with_index do |(info, value), index|
+            __desc.concat "<br/>#{index + 1}/ #{info}: #{value}"
+          end
+        else
+          _enum.each_with_index do |value, index|
+            __desc.concat "<br/>#{index + 1}/ #{value}"
+          end
+        end
+        __desc
       end
     end
   end

data/lib/open_api/dsl/api_info.rb

@@ -28,27 +28,22 @@ module OpenApi
         self[:description] = desc
       end
 
-      def param param_type, name, type, required, schema_hash = { }
+      def param param_type, name, type, required, schema_info = { }
         return if param_skip.include?(name)
         return if param_use.present? && param_use.exclude?(name)
 
-        _t = nil
-        schema_hash[:desc]  ||= _t if (_t = param_descs[name]).present?
-        schema_hash[:desc!] ||= _t if (_t = param_descs["#{name}!".to_sym]).present?
-
-        param_obj = ParamObj.new(name, param_type, type, required, schema_hash)
+        schema_info[:desc]  ||= param_descs[name]
+        schema_info[:desc!] ||= param_descs[:"#{name}!"]
+        param_obj = ParamObj.new(name, param_type, type, required, schema_info)
         # The definition of the same name parameter will be overwritten
         fill_in_parameters(param_obj)
       end
 
       # [ header header! path path! query query! cookie cookie! ]
-      def _param_agent name, type = nil, one_of: nil, all_of: nil, any_of: nil, not: nil, **schema_hash
-        combined_schema = one_of || all_of || any_of || (_not = binding.local_variable_get(:not))
-        type = schema_hash[:type] ||= type
-        pp "[ZRO] Syntax Error: param `#{name}` has no schema type!" and return if type.nil? && combined_schema.nil?
-
-        schema_hash = CombinedSchema.new(one_of: one_of, all_of: all_of, any_of: any_of, _not: _not) if combined_schema
-        param @param_type.to_s.delete('!'), name, type, (@param_type['!'] ? :req : :opt), schema_hash
+      def _param_agent name, type = nil, **schema_info
+        schema = process_schema_info(type, schema_info)
+        return puts '    ZRO'.red + " Syntax Error: param `#{name}` has no schema type!" if schema[:illegal?]
+        param @param_type, name, schema[:type], @necessity, schema[:combined] || schema[:info]
       end
 
       # For supporting this: (just like `form '', data: { }` usage)
@@ -58,17 +53,17 @@ module OpenApi
       #   }
       %i[ header header! path path! query query! cookie cookie! ].each do |param_type|
         define_method "do_#{param_type}" do |by:, **common_schema|
-          by.each do |p_name, schema|
-            action = param_type.to_s.delete('!')
+          by.each do |param_name, schema|
+            action = "#{param_type}#{param_name['!']}".sub('!!', '!')
             type, schema = schema.is_a?(Hash) ? [schema[:type], schema] : [schema, { }]
-            args = [ p_name.to_s.delete('!').to_sym, type, schema.reverse_merge!(common_schema) ]
-            param_type['!'] || p_name['!'] ? send("#{action}!", *args) : send(action, *args)
+            args = [ param_name.to_s.delete('!').to_sym, type, schema.reverse_merge!(common_schema) ]
+            send(action, *args)
           end
         end
       end
 
       def param_ref component_key, *keys
-        self[:parameters].concat([component_key].concat(keys).map { |key| RefObj.new(:parameter, key).process })
+        self[:parameters] += [component_key, *keys].map { |key| RefObj.new(:parameter, key) }
       end
 
       # options: `exp_by` and `examples`
@@ -80,7 +75,7 @@ module OpenApi
 
       # [ body body! ]
       def _request_body_agent media_type, data: { }, **options
-        request_body (@method_name['!'] ? :req : :opt), media_type, data: data, **options
+        request_body @necessity, media_type, data: data, **options
       end
 
       def body_ref component_key
@@ -95,9 +90,9 @@ module OpenApi
         body! :form, data: data, **options
       end
 
-      def data name, type = nil, schema_hash = { }
-        schema_hash[:type] = type if type.present?
-        form data: { name => schema_hash }
+      def data name, type = nil, schema_info = { }
+        schema_info[:type] = type if type.present?
+        form data: { name => schema_info }
       end
 
       def file media_type, data: { type: File }, **options
@@ -109,9 +104,7 @@ module OpenApi
       end
 
       def response_ref code_compkey_hash
-        code_compkey_hash.each do |code, component_key|
-          self[:responses][code] = RefObj.new(:response, component_key).process
-        end
+        code_compkey_hash.each { |code, component_key| self[:responses][code] = RefObj.new(:response, component_key) }
       end
 
       def security_require scheme_name, scopes: [ ]
@@ -128,34 +121,24 @@ module OpenApi
 
       def order *param_names
         self.param_order = param_names
-        # use when api_dry
+        # be used when `api_dry`
         self.param_use = param_order if param_use.blank?
         self.param_skip = param_use - param_order
       end
 
       def param_examples exp_by = :all, examples_hash
-        process_objs
-        exp_by = self[:parameters].map { |p| p[:name] } if exp_by == :all
+        exp_by = self[:parameters].map(&:name) if exp_by == :all
         self[:examples] = ExampleObj.new(examples_hash, exp_by).process
       end
 
       alias examples param_examples
 
       def process_objs
-        self[:parameters]&.each_with_index do |p, index|
-          self[:parameters][index] = p.process if p.is_a?(ParamObj)
-        end
+        self[:parameters].map!(&:process)
+        self[:parameters].sort_by! { |param| param_order.index(param[:name]) || Float::INFINITY } if param_order.present?
 
-        # Parameters sorting
-        self[:parameters].clone.each do |p|
-          self[:parameters][param_order.index(p[:name]) || -1] = p
-        end if param_order.present?
-
-        self[:requestBody] = self[:requestBody].try :process
-
-        self[:responses]&.each do |code, obj|
-          self[:responses][code] = obj.process if obj.is_a?(ResponseObj)
-        end
+        self[:requestBody] = self[:requestBody].try(:process)
+        self[:responses].each { |code, response| self[:responses][code] = response.process }
       end
     end
   end

data/lib/open_api/dsl/common_dsl.rb

@@ -12,14 +12,15 @@ module OpenApi
     module CommonDSL
       %i[ header header! path path! query query! cookie cookie! ].each do |param_type|
         define_method param_type do |*args|
-          @param_type = param_type
+          @necessity = param_type['!'] ? :req : :opt
+          @param_type = param_type.to_s.delete('!') # OR: caller[0][/`.*'/][1..-2].to_sym
           _param_agent *args
         end
       end
 
       %i[ body body! ].each do |method|
         define_method method do |*args|
-          @method_name = method
+          @necessity = method['!'] ? :req : :opt
           _request_body_agent *args
         end
       end

data/lib/open_api/dsl/components.rb

@@ -6,51 +6,44 @@ module OpenApi
       include DSL::CommonDSL
       include DSL::Helpers
 
-      def schema component_key, type = nil, one_of: nil, all_of: nil, any_of: nil, not: nil, **schema_hash
-        combined_schema = (_not = binding.local_variable_get(:not)) || one_of || all_of || any_of
-        schema_hash[:type] ||= type
-        schema_hash = load_schema component_key if component_key.try(:superclass) == (Config.active_record_base || ApplicationRecord)
-        pp "[ZRO] Syntax Error: component schema `#{component_key}` has no type!" and return if schema_hash[:type].nil? && combined_schema.nil?
-
-        combined_schema = CombinedSchema.new(one_of: one_of, all_of: all_of, any_of: any_of, _not: _not) if combined_schema
-        (self[:schemas] ||= { })[component_key.to_s.to_sym] = combined_schema&.process || SchemaObj.new(schema_hash, { }).process
+      def schema component_key, type = nil, **schema_info
+        schema = process_schema_info(type, schema_info, model: component_key)
+        return puts '    ZRO'.red + " Syntax Error: component schema `#{component_key}` has no type!" if schema[:illegal?]
+        self[:schemas][component_key.to_s.to_sym] = (schema[:combined] || SchemaObj.new(type = schema[:info], { })).process
       end
+
       arrow_enable :schema
 
       def example component_key, examples_hash
-        (self[:examples] ||= { })[component_key] = ExampleObj.new(examples_hash).process
+        self[:examples][component_key] = ExampleObj.new(examples_hash).process
       end
+
       arrow_enable :example
 
-      def param component_key, param_type, name, type, required, schema_hash = { }
-        (self[:parameters] ||= { })[component_key] = ParamObj.new(name, param_type, type, required, schema_hash).process
+      def param component_key, param_type, name, type, required, schema_info = { }
+        self[:parameters][component_key] = ParamObj.new(name, param_type, type, required, schema_info).process
       end
 
       # [ header header! path path! query query! cookie cookie! ]
-      def _param_agent component_key, name, type = nil, one_of: nil, all_of: nil, any_of: nil, not: nil, **schema_hash
-        combined_schema = one_of || all_of || any_of || (_not = binding.local_variable_get(:not))
-        schema_hash[:type] ||= type
-        pp "[ZRO] Syntax Error: param `#{name}` has no schema type!" and return if schema_hash[:type].nil? && combined_schema.nil?
-
-        combined_schema = one_of || all_of || any_of || (_not = binding.local_variable_get(:not))
-        schema_hash = CombinedSchema.new(one_of: one_of, all_of: all_of, any_of: any_of, _not: _not) if combined_schema
-        param component_key,
-              "#{@param_type}".delete('!'), name, type, (@param_type['!'] ? :req : :opt), schema_hash
+      def _param_agent component_key, name, type = nil, **schema_info
+        schema = process_schema_info(type, schema_info)
+        return puts '    ZRO'.red + " Syntax Error: param `#{name}` has no schema type!" if schema[:illegal?]
+        param component_key, @param_type, name, schema[:type], @necessity, schema[:combined] || schema[:info]
       end
+
       arrow_enable :_param_agent
 
-      def request_body component_key, required, media_type, data: { }, **options
-        desc = options.delete(:desc) || ''
-        cur = (self[:requestBodies] ||= { })[component_key]
+      def request_body component_key, required, media_type, data: { }, desc: '', **options
+        cur = self[:requestBodies][component_key]
         cur = RequestBodyObj.new(required, desc) unless cur.is_a?(RequestBodyObj)
         self[:requestBodies][component_key] = cur.add_or_fusion(media_type, { data: data, **options })
       end
 
       # [ body body! ]
       def _request_body_agent component_key, media_type, data: { }, **options
-        request_body component_key,
-                     (@method_name['!'] ? :req : :opt), media_type, data: data, **options
+        request_body component_key, @necessity, media_type, data: data, **options
       end
+
       arrow_enable :_request_body_agent
 
       arrow_enable :resp # alias_method 竟然也会指向旧的方法？
@@ -58,8 +51,9 @@ module OpenApi
 
       def security_scheme scheme_name, other_info# = { }
         other_info[:description] = other_info.delete(:desc) if other_info[:desc]
-        (self[:securitySchemes] ||= { })[scheme_name] = other_info
+        self[:securitySchemes][scheme_name] = other_info
       end
+
       arrow_enable :security_scheme
 
       alias auth_scheme security_scheme
@@ -67,27 +61,25 @@ module OpenApi
       def base_auth scheme_name, other_info = { }
         security_scheme scheme_name, { type: 'http', scheme: 'basic', **other_info }
       end
+
       arrow_enable :base_auth
 
       def bearer_auth scheme_name, format = 'JWT', other_info = { }
         security_scheme scheme_name, { type: 'http', scheme: 'bearer', bearerFormat: format, **other_info }
       end
+
       arrow_enable :bearer_auth
 
       def api_key scheme_name, field:, in: 'header', **other_info
         _in = binding.local_variable_get(:in)
         security_scheme scheme_name, { type: 'apiKey', name: field, in: _in, **other_info }
       end
+
       arrow_enable :api_key
 
       def process_objs
-        self[:requestBodies]&.each do |key, obj|
-          self[:requestBodies][key] = obj.process
-        end
-
-        self[:responses]&.each do |code, obj|
-          self[:responses][code] = obj.process if obj.is_a?(ResponseObj)
-        end
+        self[:requestBodies].each { |key, body| self[:requestBodies][key] = body.process }
+        self[:responses].each { |code, response| self[:responses][code] = response.process }
       end
     end
   end

data/lib/open_api/dsl/helpers.rb

@@ -6,11 +6,11 @@ module OpenApi
       end
 
       # :nocov:
-      def load_schema(model)
+      def load_schema(model) # TODO: test
         # About `show_attrs`, see:
         #   (1) BuilderSupport module: https://github.com/zhandao/zero-rails/blob/master/app/models/concerns/builder_support.rb
         #   (2) config in model: https://github.com/zhandao/zero-rails/tree/master/app/models/good.rb
-        #   (3) jbuilder file: https://github.com/zhandao/zero-rails/blob/mster/app/views/api/v1/goods/index.json.jbuilder
+        #   (3) jbuilder file: https://github.com/zhandao/zero-rails/blob/master/app/views/api/v1/goods/index.json.jbuilder
         # In a word, BuilderSupport let you control the `output fields and nested association infos` very easily.
         if model.respond_to? :show_attrs
           _load_schema_based_on_show_attr(model)
@@ -41,27 +41,43 @@ module OpenApi
       # :nocov:
 
       def fill_in_parameters(param_obj)
-        name = param_obj.processed[:name]
-        index = self[:parameters].map { |p| p.processed[:name] if p.is_a?(ParamObj) }.index(name)
+        index = self[:parameters].map(&:name).index(param_obj.name)
         index.present? ? self[:parameters][index] = param_obj : self[:parameters] << param_obj
       end
 
+      def _combined_schema(one_of: nil, all_of: nil, any_of: nil, not: nil, **other)
+        input = (_not = binding.local_variable_get(:not)) || one_of || all_of || any_of
+        CombinedSchema.new(one_of: one_of, all_of: all_of, any_of: any_of, _not: _not) if input
+      end
+
+      def process_schema_info(schema_type, schema_info, model: nil)
+        combined_schema = _combined_schema(schema_info)
+        type = schema_info[:type] ||= schema_type
+        schema_info = load_schema(model) if model.try(:superclass) == (Config.active_record_base || ApplicationRecord)
+        {
+            illegal?: type.nil? && combined_schema.nil?,
+            combined: combined_schema,
+            info: schema_info,
+            type: type
+        }
+      end
+
       # Arrow Writing:
       #   response :RespComponent => [ '200', 'success', :json ]
       # It is equivalent to:
       #   response :RespComponent, '200', 'success', :json
       # But I think, in the definition of a component,
-      #   the key-value (arrow) writing is easy to understand.
+      #   the key-value (arrow) writing is more easier to understand.
       def arrow_writing_support
         proc do |args, executor|
-          _args = (args.size == 1 && args.first.is_a?(Hash)) ? args[0].to_a.flatten : args
-          send(executor, *_args)
+          args = (args.size == 1 && args.first.is_a?(Hash)) ? args[0].to_a.flatten : args
+          send(executor, *args)
         end
       end
 
       module ClassMethods
         def arrow_enable method
-          alias_method "_#{method}".to_sym, method
+          alias_method :"_#{method}", method
           define_method method do |*args|
             arrow_writing_support.call(args, "_#{method}")
           end