require and optional with block

First a part of my definition code,

      params do
        requires :id, type: Integer
        optional :text, type: String, regexp: /\A[a-z]+\z/
        group :group_params, type: Hash do
          requires :require_param
          optional :optional_param
        end
        requires :requires_params, type: Hash do
          optional :optional_param1
          optional :optional_param2
        end
        optional :optional_params, type: Hash do
          requires :require_param
          optional :optional_param
        end
      end

From my perspective,

• group_params[require_param] is required,
• group_params[optional_param], require_params[optional_param1], require_params[optional_param2], optional_params[require_param] and optional_params[optional_param] is not required.
• If I pass optional_params[optional_param], then optional_params[require_param] is required.

Part of the instance variable @options of API

   :forward_match => nil,
           :suffix => "(.:format)",
           :params => {
                                      "id" => {
            :required => true,
                :type => "Integer"
        },
                                    "text" => {
            :required => false,
                :type => "String"
        },
                            "group_params" => {
            :required => true,
                :type => "Hash"
        },
             "group_params[require_param]" => {
            :required => true
        },
            "group_params[optional_param]" => {
            :required => false
        },
                         "requires_params" => {
            :required => true,
                :type => "Hash"
        },
        "requires_params[optional_param1]" => {
            :required => false
        },
        "requires_params[optional_param2]" => {
            :required => false
        },
                         "optional_params" => {
            :required => false,
                :type => "Hash"
        },
          "optional_params[require_param]" => {
            :required => true
        },
         "optional_params[optional_param]" => {
            :required => false
        }
    }

But what I got from the swagger documentation was as below:

parameters": [

    {
        "in": "query",
        "name": "id",
        "type": "integer",
        "format": "int32",
        "required": true
    },
    {
        "in": "query",
        "name": "text",
        "type": "string",
        "required": false
    },
    {
        "in": "query",
        "name": "group_params[require_param]",
        "type": "string",
        "required": true
    },
    {
        "in": "query",
        "name": "group_params[optional_param]",
        "type": "string",
        "required": false
    },
    {
        "in": "query",
        "name": "requires_params[optional_param1]",
        "type": "string",
        "required": false
    },
    {
        "in": "query",
        "name": "requires_params[optional_param2]",
        "type": "string",
        "required": false
    },
    {
        "in": "query",
        "name": "optional_params[require_param]",
        "type": "string",
        "required": true
    },
    {
        "in": "query",
        "name": "optional_params[optional_param]",
        "type": "string",
        "required": false
    }

],

The report does not name a source file or test. Start from handling of nested Grape group, requires, and optional blocks, then trace the Swagger parameter generation that produces the shown list. Verify the generated documentation against the stated required and conditional requirements; done means the output matches those cases.