diff --git a/bin/configs/ruby-extensions-x-auth-id-alias.yaml b/bin/configs/ruby-extensions-x-auth-id-alias.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..7f51216567c49a152291adc4671f932ff25c771d
--- /dev/null
+++ b/bin/configs/ruby-extensions-x-auth-id-alias.yaml
@@ -0,0 +1,8 @@
+generatorName: ruby
+outputDir: samples/openapi3/client/extensions/x-auth-id-alias/ruby-client
+inputSpec: modules/openapi-generator/src/test/resources/3_0/extensions/x-auth-id-alias.yaml
+templateDir: modules/openapi-generator/src/main/resources/ruby-client
+additionalProperties:
+ gemName: x_auth_id_alias
+ gemVersion: 1.0.0
+ moduleName: XAuthIDAlias
\ No newline at end of file
diff --git a/modules/openapi-generator/src/main/resources/ruby-client/README.mustache b/modules/openapi-generator/src/main/resources/ruby-client/README.mustache
index dafacf98ad57d88b7bdad32b062289590ce9ecb5..e35995e6339b01de1493d1c7030801e23bdddbe8 100644
--- a/modules/openapi-generator/src/main/resources/ruby-client/README.mustache
+++ b/modules/openapi-generator/src/main/resources/ruby-client/README.mustache
@@ -72,9 +72,9 @@ require '{{{gemName}}}'
# Configure Bearer authorization{{#bearerFormat}} ({{{.}}}){{/bearerFormat}}: {{{name}}}
config.access_token = 'YOUR_BEARER_TOKEN'{{/isBasicBearer}}{{/isBasic}}{{#isApiKey}}
# Configure API key authorization: {{{name}}}
- config.api_key['{{{keyParamName}}}'] = 'YOUR API KEY'
+ config.api_key['{{{name}}}'] = 'YOUR API KEY'
# Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
- #config.api_key_prefix['{{{keyParamName}}}'] = 'Bearer'{{/isApiKey}}{{#isOAuth}}
+ # config.api_key_prefix['{{{name}}}'] = 'Bearer'{{/isApiKey}}{{#isOAuth}}
# Configure OAuth2 access token for authorization: {{{name}}}
config.access_token = 'YOUR ACCESS TOKEN'{{/isOAuth}}
{{/authMethods}}end
diff --git a/modules/openapi-generator/src/main/resources/ruby-client/api_client.mustache b/modules/openapi-generator/src/main/resources/ruby-client/api_client.mustache
index 6723bb756c664815bc9205bccf249e9a48c66e48..2741a73794ed8dced0a98a06efafcc77cef2ae9a 100644
--- a/modules/openapi-generator/src/main/resources/ruby-client/api_client.mustache
+++ b/modules/openapi-generator/src/main/resources/ruby-client/api_client.mustache
@@ -182,7 +182,7 @@ module {{moduleName}}
case auth_setting[:in]
when 'header' then header_params[auth_setting[:key]] = auth_setting[:value]
when 'query' then query_params[auth_setting[:key]] = auth_setting[:value]
- else fail ArgumentError, 'Authentication token must be in `query` of `header`'
+ else fail ArgumentError, 'Authentication token must be in `query` or `header`'
end
end
end
diff --git a/modules/openapi-generator/src/main/resources/ruby-client/api_doc.mustache b/modules/openapi-generator/src/main/resources/ruby-client/api_doc.mustache
index bdeeb56891220a442b15f1eb19b621e78db3160f..81fc865534d1b202f7a8d79bdb3457e72c49bbad 100644
--- a/modules/openapi-generator/src/main/resources/ruby-client/api_doc.mustache
+++ b/modules/openapi-generator/src/main/resources/ruby-client/api_doc.mustache
@@ -37,9 +37,9 @@ require '{{{gemName}}}'
# Configure Bearer authorization{{#bearerFormat}} ({{{.}}}){{/bearerFormat}}: {{{name}}}
config.access_token = 'YOUR_BEARER_TOKEN'{{/isBasicBearer}}{{/isBasic}}{{#isApiKey}}
# Configure API key authorization: {{{name}}}
- config.api_key['{{{keyParamName}}}'] = 'YOUR API KEY'
+ config.api_key['{{{name}}}'] = 'YOUR API KEY'
# Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
- # config.api_key_prefix['{{{keyParamName}}}'] = 'Bearer'{{/isApiKey}}{{#isOAuth}}
+ # config.api_key_prefix['{{{name}}}'] = 'Bearer'{{/isApiKey}}{{#isOAuth}}
# Configure OAuth2 access token for authorization: {{{name}}}
config.access_token = 'YOUR ACCESS TOKEN'{{/isOAuth}}
{{/authMethods}}end
diff --git a/modules/openapi-generator/src/main/resources/ruby-client/configuration.mustache b/modules/openapi-generator/src/main/resources/ruby-client/configuration.mustache
index fd1ad422ddb1934ef9d0a7203a18191472e3ca19..26d324489b9d2253c565194e452f2eaab9029a80 100644
--- a/modules/openapi-generator/src/main/resources/ruby-client/configuration.mustache
+++ b/modules/openapi-generator/src/main/resources/ruby-client/configuration.mustache
@@ -169,11 +169,13 @@ module {{moduleName}}
# Gets API key (with prefix if set).
# @param [String] param_name the parameter name of API key auth
- def api_key_with_prefix(param_name)
+ def api_key_with_prefix(param_name, param_alias = nil)
+ key = @api_key[param_name]
+ key = @api_key.fetch(param_alias, key) unless param_alias.nil?
if @api_key_prefix[param_name]
- "#{@api_key_prefix[param_name]} #{@api_key[param_name]}"
+ "#{@api_key_prefix[param_name]} #{key}"
else
- @api_key[param_name]
+ key
end
end
@@ -192,7 +194,7 @@ module {{moduleName}}
type: 'api_key',
in: {{#isKeyInHeader}}'header'{{/isKeyInHeader}}{{#isKeyInQuery}}'query'{{/isKeyInQuery}},
key: '{{keyParamName}}',
- value: api_key_with_prefix('{{keyParamName}}')
+ value: api_key_with_prefix('{{name}}'{{#vendorExtensions.x-auth-id-alias}}, '{{.}}'{{/vendorExtensions.x-auth-id-alias}})
},
{{/isApiKey}}
{{#isBasic}}
diff --git a/samples/client/petstore/ruby-faraday/lib/petstore/api_client.rb b/samples/client/petstore/ruby-faraday/lib/petstore/api_client.rb
index f6bad0ebbc551b407cdb76c3067539a725ea7347..ebf4dd9bdf0315a1846716e56bebcfee957ea5e3 100644
--- a/samples/client/petstore/ruby-faraday/lib/petstore/api_client.rb
+++ b/samples/client/petstore/ruby-faraday/lib/petstore/api_client.rb
@@ -313,7 +313,7 @@ module Petstore
case auth_setting[:in]
when 'header' then header_params[auth_setting[:key]] = auth_setting[:value]
when 'query' then query_params[auth_setting[:key]] = auth_setting[:value]
- else fail ArgumentError, 'Authentication token must be in `query` of `header`'
+ else fail ArgumentError, 'Authentication token must be in `query` or `header`'
end
end
end
diff --git a/samples/client/petstore/ruby-faraday/lib/petstore/configuration.rb b/samples/client/petstore/ruby-faraday/lib/petstore/configuration.rb
index 3ae81584f87d39dad9d543d0e1c2ab7c731b94fa..88c35970698a020376967e1e88d43b9d04ff4f88 100644
--- a/samples/client/petstore/ruby-faraday/lib/petstore/configuration.rb
+++ b/samples/client/petstore/ruby-faraday/lib/petstore/configuration.rb
@@ -192,11 +192,13 @@ module Petstore
# Gets API key (with prefix if set).
# @param [String] param_name the parameter name of API key auth
- def api_key_with_prefix(param_name)
+ def api_key_with_prefix(param_name, param_alias = nil)
+ key = @api_key[param_name]
+ key = @api_key.fetch(param_alias, key) unless param_alias.nil?
if @api_key_prefix[param_name]
- "#{@api_key_prefix[param_name]} #{@api_key[param_name]}"
+ "#{@api_key_prefix[param_name]} #{key}"
else
- @api_key[param_name]
+ key
end
end
diff --git a/samples/client/petstore/ruby/lib/petstore/api_client.rb b/samples/client/petstore/ruby/lib/petstore/api_client.rb
index 77986943883a6a8d44c362be1fc566ea31f3752d..507e477dc7d3f67b196a414f02c9c9ecabd1c5ea 100644
--- a/samples/client/petstore/ruby/lib/petstore/api_client.rb
+++ b/samples/client/petstore/ruby/lib/petstore/api_client.rb
@@ -308,7 +308,7 @@ module Petstore
case auth_setting[:in]
when 'header' then header_params[auth_setting[:key]] = auth_setting[:value]
when 'query' then query_params[auth_setting[:key]] = auth_setting[:value]
- else fail ArgumentError, 'Authentication token must be in `query` of `header`'
+ else fail ArgumentError, 'Authentication token must be in `query` or `header`'
end
end
end
diff --git a/samples/client/petstore/ruby/lib/petstore/configuration.rb b/samples/client/petstore/ruby/lib/petstore/configuration.rb
index f9860f4a4d118367ad59b14c1bb03a38c35103a9..fccde677a36ecf7be83cebdc75bdd25401a40464 100644
--- a/samples/client/petstore/ruby/lib/petstore/configuration.rb
+++ b/samples/client/petstore/ruby/lib/petstore/configuration.rb
@@ -197,11 +197,13 @@ module Petstore
# Gets API key (with prefix if set).
# @param [String] param_name the parameter name of API key auth
- def api_key_with_prefix(param_name)
+ def api_key_with_prefix(param_name, param_alias = nil)
+ key = @api_key[param_name]
+ key = @api_key.fetch(param_alias, key) unless param_alias.nil?
if @api_key_prefix[param_name]
- "#{@api_key_prefix[param_name]} #{@api_key[param_name]}"
+ "#{@api_key_prefix[param_name]} #{key}"
else
- @api_key[param_name]
+ key
end
end
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/.gitignore b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..05a17cb8f0a024108df9e50182cb6c1b647a6384
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/.gitignore
@@ -0,0 +1,39 @@
+# Generated by: https://openapi-generator.tech
+#
+
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/.openapi-generator-ignore b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/.openapi-generator-ignore
new file mode 100644
index 0000000000000000000000000000000000000000..7484ee590a3894506cf063799b885428f95a71be
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/.openapi-generator-ignore
@@ -0,0 +1,23 @@
+# OpenAPI Generator Ignore
+# Generated by openapi-generator https://github.com/openapitools/openapi-generator
+
+# Use this file to prevent files from being overwritten by the generator.
+# The patterns follow closely to .gitignore or .dockerignore.
+
+# As an example, the C# client generator defines ApiClient.cs.
+# You can make changes and tell OpenAPI Generator to ignore just this file by uncommenting the following line:
+#ApiClient.cs
+
+# You can match any string of characters against a directory, file or extension with a single asterisk (*):
+#foo/*/qux
+# The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux
+
+# You can recursively match patterns against a directory, file or extension with a double asterisk (**):
+#foo/**/qux
+# This matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux
+
+# You can also negate patterns with an exclamation (!).
+# For example, you can ignore all files in a docs folder with the file extension .md:
+#docs/*.md
+# Then explicitly reverse the ignore rule for a single file:
+#!docs/README.md
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/.openapi-generator/FILES b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/.openapi-generator/FILES
new file mode 100644
index 0000000000000000000000000000000000000000..b6d67848c71d32c1731792e73429c3bd21212de6
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/.openapi-generator/FILES
@@ -0,0 +1,20 @@
+.gitignore
+.rspec
+.rubocop.yml
+.travis.yml
+Gemfile
+README.md
+Rakefile
+docs/UsageApi.md
+git_push.sh
+lib/x_auth_id_alias.rb
+lib/x_auth_id_alias/api/usage_api.rb
+lib/x_auth_id_alias/api_client.rb
+lib/x_auth_id_alias/api_error.rb
+lib/x_auth_id_alias/configuration.rb
+lib/x_auth_id_alias/configuration.rb
+lib/x_auth_id_alias/version.rb
+spec/api_client_spec.rb
+spec/configuration_spec.rb
+spec/spec_helper.rb
+x_auth_id_alias.gemspec
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/.openapi-generator/VERSION b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/.openapi-generator/VERSION
new file mode 100644
index 0000000000000000000000000000000000000000..3fa3b389a57d0ed39fe957762896cc8e8eee80c3
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/.openapi-generator/VERSION
@@ -0,0 +1 @@
+5.0.1-SNAPSHOT
\ No newline at end of file
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/.rspec b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/.rspec
new file mode 100644
index 0000000000000000000000000000000000000000..83e16f80447460c937aeaa44a64d743b27863077
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/.rspec
@@ -0,0 +1,2 @@
+--color
+--require spec_helper
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/.rubocop.yml b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/.rubocop.yml
new file mode 100644
index 0000000000000000000000000000000000000000..d32b2b1cdab5012870d92097ec8878c26b05661b
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/.rubocop.yml
@@ -0,0 +1,148 @@
+# This file is based on https://github.com/rails/rails/blob/master/.rubocop.yml (MIT license)
+# Automatically generated by OpenAPI Generator (https://openapi-generator.tech)
+AllCops:
+ TargetRubyVersion: 2.4
+ # RuboCop has a bunch of cops enabled by default. This setting tells RuboCop
+ # to ignore them, so only the ones explicitly set in this file are enabled.
+ DisabledByDefault: true
+ Exclude:
+ - '**/templates/**/*'
+ - '**/vendor/**/*'
+ - 'actionpack/lib/action_dispatch/journey/parser.rb'
+
+# Prefer &&/|| over and/or.
+Style/AndOr:
+ Enabled: true
+
+# Align `when` with `case`.
+Layout/CaseIndentation:
+ Enabled: true
+
+# Align comments with method definitions.
+Layout/CommentIndentation:
+ Enabled: true
+
+Layout/ElseAlignment:
+ Enabled: true
+
+Layout/EmptyLineAfterMagicComment:
+ Enabled: true
+
+# In a regular class definition, no empty lines around the body.
+Layout/EmptyLinesAroundClassBody:
+ Enabled: true
+
+# In a regular method definition, no empty lines around the body.
+Layout/EmptyLinesAroundMethodBody:
+ Enabled: true
+
+# In a regular module definition, no empty lines around the body.
+Layout/EmptyLinesAroundModuleBody:
+ Enabled: true
+
+Layout/FirstArgumentIndentation:
+ Enabled: true
+
+# Use Ruby >= 1.9 syntax for hashes. Prefer { a: :b } over { :a => :b }.
+Style/HashSyntax:
+ Enabled: false
+
+# Method definitions after `private` or `protected` isolated calls need one
+# extra level of indentation.
+Layout/IndentationConsistency:
+ Enabled: true
+ EnforcedStyle: indented_internal_methods
+
+# Two spaces, no tabs (for indentation).
+Layout/IndentationWidth:
+ Enabled: true
+
+Layout/LeadingCommentSpace:
+ Enabled: true
+
+Layout/SpaceAfterColon:
+ Enabled: true
+
+Layout/SpaceAfterComma:
+ Enabled: true
+
+Layout/SpaceAroundEqualsInParameterDefault:
+ Enabled: true
+
+Layout/SpaceAroundKeyword:
+ Enabled: true
+
+Layout/SpaceAroundOperators:
+ Enabled: true
+
+Layout/SpaceBeforeComma:
+ Enabled: true
+
+Layout/SpaceBeforeFirstArg:
+ Enabled: true
+
+Style/DefWithParentheses:
+ Enabled: true
+
+# Defining a method with parameters needs parentheses.
+Style/MethodDefParentheses:
+ Enabled: true
+
+Style/FrozenStringLiteralComment:
+ Enabled: false
+ EnforcedStyle: always
+
+# Use `foo {}` not `foo{}`.
+Layout/SpaceBeforeBlockBraces:
+ Enabled: true
+
+# Use `foo { bar }` not `foo {bar}`.
+Layout/SpaceInsideBlockBraces:
+ Enabled: true
+
+# Use `{ a: 1 }` not `{a:1}`.
+Layout/SpaceInsideHashLiteralBraces:
+ Enabled: true
+
+Layout/SpaceInsideParens:
+ Enabled: true
+
+# Check quotes usage according to lint rule below.
+#Style/StringLiterals:
+# Enabled: true
+# EnforcedStyle: single_quotes
+
+# Detect hard tabs, no hard tabs.
+Layout/IndentationStyle:
+ Enabled: true
+
+# Blank lines should not have any spaces.
+Layout/TrailingEmptyLines:
+ Enabled: true
+
+# No trailing whitespace.
+Layout/TrailingWhitespace:
+ Enabled: false
+
+# Use quotes for string literals when they are enough.
+Style/RedundantPercentQ:
+ Enabled: true
+
+# Align `end` with the matching keyword or starting expression except for
+# assignments, where it should be aligned with the LHS.
+Layout/EndAlignment:
+ Enabled: true
+ EnforcedStyleAlignWith: variable
+ AutoCorrect: true
+
+# Use my_method(my_arg) not my_method( my_arg ) or my_method my_arg.
+Lint/RequireParentheses:
+ Enabled: true
+
+Style/RedundantReturn:
+ Enabled: true
+ AllowMultipleReturnValues: true
+
+Style/Semicolon:
+ Enabled: true
+ AllowAsExpressionSeparator: true
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/.travis.yml b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..3e97f36d1713cccdd52f7741bba82cca7980eeb0
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/.travis.yml
@@ -0,0 +1,11 @@
+language: ruby
+cache: bundler
+rvm:
+ - 2.3
+ - 2.4
+ - 2.5
+script:
+ - bundle install --path vendor/bundle
+ - bundle exec rspec
+ - gem build x_auth_id_alias.gemspec
+ - gem install ./x_auth_id_alias-1.0.0.gem
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/Gemfile b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/Gemfile
new file mode 100644
index 0000000000000000000000000000000000000000..c2e3127cdcfe3078b722cd19d10274a9ae0c7bf6
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/Gemfile
@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :test do
+ gem 'rake', '~> 13.0.1'
+ gem 'pry-byebug'
+ gem 'rubocop', '~> 0.66.0'
+end
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/README.md b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..185966255071b7d34e1b51d0c8a82bc54dfe776e
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/README.md
@@ -0,0 +1,116 @@
+# x_auth_id_alias
+
+XAuthIDAlias - the Ruby gem for the OpenAPI Extension x-auth-id-alias
+
+This specification shows how to use x-auth-id-alias extension for API keys.
+
+This SDK is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project:
+
+- API version: 1.0.0
+- Package version: 1.0.0
+- Build package: org.openapitools.codegen.languages.RubyClientCodegen
+
+## Installation
+
+### Build a gem
+
+To build the Ruby code into a gem:
+
+```shell
+gem build x_auth_id_alias.gemspec
+```
+
+Then either install the gem locally:
+
+```shell
+gem install ./x_auth_id_alias-1.0.0.gem
+```
+
+(for development, run `gem install --dev ./x_auth_id_alias-1.0.0.gem` to install the development dependencies)
+
+or publish the gem to a gem hosting service, e.g. [RubyGems](https://rubygems.org/).
+
+Finally add this to the Gemfile:
+
+ gem 'x_auth_id_alias', '~> 1.0.0'
+
+### Install from Git
+
+If the Ruby gem is hosted at a git repository: https://github.com/GIT_USER_ID/GIT_REPO_ID, then add the following in the Gemfile:
+
+ gem 'x_auth_id_alias', :git => 'https://github.com/GIT_USER_ID/GIT_REPO_ID.git'
+
+### Include the Ruby code directly
+
+Include the Ruby code directly using `-I` as follows:
+
+```shell
+ruby -Ilib script.rb
+```
+
+## Getting Started
+
+Please follow the [installation](#installation) procedure and then run the following code:
+
+```ruby
+# Load the gem
+require 'x_auth_id_alias'
+
+# Setup authorization
+XAuthIDAlias.configure do |config|
+ # Configure API key authorization: api_key
+ config.api_key['api_key'] = 'YOUR API KEY'
+ # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+ # config.api_key_prefix['api_key'] = 'Bearer'
+
+ # Configure API key authorization: api_key_query
+ config.api_key['api_key_query'] = 'YOUR API KEY'
+ # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+ # config.api_key_prefix['api_key_query'] = 'Bearer'
+end
+
+api_instance = XAuthIDAlias::UsageApi.new
+
+begin
+ #Use any API key
+ result = api_instance.any_key
+ p result
+rescue XAuthIDAlias::ApiError => e
+ puts "Exception when calling UsageApi->any_key: #{e}"
+end
+
+```
+
+## Documentation for API Endpoints
+
+All URIs are relative to *http://petstore.swagger.io:80/v2*
+
+Class | Method | HTTP request | Description
+------------ | ------------- | ------------- | -------------
+*XAuthIDAlias::UsageApi* | [**any_key**](docs/UsageApi.md#any_key) | **GET** /any | Use any API key
+*XAuthIDAlias::UsageApi* | [**both_keys**](docs/UsageApi.md#both_keys) | **GET** /both | Use both API keys
+*XAuthIDAlias::UsageApi* | [**key_in_header**](docs/UsageApi.md#key_in_header) | **GET** /header | Use API key in header
+*XAuthIDAlias::UsageApi* | [**key_in_query**](docs/UsageApi.md#key_in_query) | **GET** /query | Use API key in query
+
+
+## Documentation for Models
+
+
+
+## Documentation for Authorization
+
+
+### api_key
+
+
+- **Type**: API key
+- **API key parameter name**: X-Api-Key
+- **Location**: HTTP header
+
+### api_key_query
+
+
+- **Type**: API key
+- **API key parameter name**: api_key
+- **Location**: URL query string
+
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/Rakefile b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/Rakefile
new file mode 100644
index 0000000000000000000000000000000000000000..c72ca30d454e1d9626eabe9afc37d197102c79cb
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/Rakefile
@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+
+begin
+ require 'rspec/core/rake_task'
+
+ RSpec::Core::RakeTask.new(:spec)
+ task default: :spec
+rescue LoadError
+ # no rspec available
+end
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/docs/UsageApi.md b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/docs/UsageApi.md
new file mode 100644
index 0000000000000000000000000000000000000000..0ec8d9fdfec027a293deb5aa8a2fea389bfb3995
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/docs/UsageApi.md
@@ -0,0 +1,293 @@
+# XAuthIDAlias::UsageApi
+
+All URIs are relative to *http://petstore.swagger.io:80/v2*
+
+| Method | HTTP request | Description |
+| ------ | ------------ | ----------- |
+| [**any_key**](UsageApi.md#any_key) | **GET** /any | Use any API key |
+| [**both_keys**](UsageApi.md#both_keys) | **GET** /both | Use both API keys |
+| [**key_in_header**](UsageApi.md#key_in_header) | **GET** /header | Use API key in header |
+| [**key_in_query**](UsageApi.md#key_in_query) | **GET** /query | Use API key in query |
+
+
+## any_key
+
+> Object any_key
+
+Use any API key
+
+Use any API key
+
+### Examples
+
+```ruby
+require 'time'
+require 'x_auth_id_alias'
+# setup authorization
+XAuthIDAlias.configure do |config|
+ # Configure API key authorization: api_key
+ config.api_key['api_key'] = 'YOUR API KEY'
+ # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+ # config.api_key_prefix['api_key'] = 'Bearer'
+
+ # Configure API key authorization: api_key_query
+ config.api_key['api_key_query'] = 'YOUR API KEY'
+ # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+ # config.api_key_prefix['api_key_query'] = 'Bearer'
+end
+
+api_instance = XAuthIDAlias::UsageApi.new
+
+begin
+ # Use any API key
+ result = api_instance.any_key
+ p result
+rescue XAuthIDAlias::ApiError => e
+ puts "Error when calling UsageApi->any_key: #{e}"
+end
+```
+
+#### Using the any_key_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(Object, Integer, Hash)> any_key_with_http_info
+
+```ruby
+begin
+ # Use any API key
+ data, status_code, headers = api_instance.any_key_with_http_info
+ p status_code # => 2xx
+ p headers # => { ... }
+ p data # => Object
+rescue XAuthIDAlias::ApiError => e
+ puts "Error when calling UsageApi->any_key_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+This endpoint does not need any parameter.
+
+### Return type
+
+**Object**
+
+### Authorization
+
+[api_key](../README.md#api_key), [api_key_query](../README.md#api_key_query)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## both_keys
+
+> Object both_keys
+
+Use both API keys
+
+Use both API keys
+
+### Examples
+
+```ruby
+require 'time'
+require 'x_auth_id_alias'
+# setup authorization
+XAuthIDAlias.configure do |config|
+ # Configure API key authorization: api_key
+ config.api_key['api_key'] = 'YOUR API KEY'
+ # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+ # config.api_key_prefix['api_key'] = 'Bearer'
+
+ # Configure API key authorization: api_key_query
+ config.api_key['api_key_query'] = 'YOUR API KEY'
+ # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+ # config.api_key_prefix['api_key_query'] = 'Bearer'
+end
+
+api_instance = XAuthIDAlias::UsageApi.new
+
+begin
+ # Use both API keys
+ result = api_instance.both_keys
+ p result
+rescue XAuthIDAlias::ApiError => e
+ puts "Error when calling UsageApi->both_keys: #{e}"
+end
+```
+
+#### Using the both_keys_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(Object, Integer, Hash)> both_keys_with_http_info
+
+```ruby
+begin
+ # Use both API keys
+ data, status_code, headers = api_instance.both_keys_with_http_info
+ p status_code # => 2xx
+ p headers # => { ... }
+ p data # => Object
+rescue XAuthIDAlias::ApiError => e
+ puts "Error when calling UsageApi->both_keys_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+This endpoint does not need any parameter.
+
+### Return type
+
+**Object**
+
+### Authorization
+
+[api_key](../README.md#api_key), [api_key_query](../README.md#api_key_query)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## key_in_header
+
+> Object key_in_header
+
+Use API key in header
+
+Use API key in header
+
+### Examples
+
+```ruby
+require 'time'
+require 'x_auth_id_alias'
+# setup authorization
+XAuthIDAlias.configure do |config|
+ # Configure API key authorization: api_key
+ config.api_key['api_key'] = 'YOUR API KEY'
+ # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+ # config.api_key_prefix['api_key'] = 'Bearer'
+end
+
+api_instance = XAuthIDAlias::UsageApi.new
+
+begin
+ # Use API key in header
+ result = api_instance.key_in_header
+ p result
+rescue XAuthIDAlias::ApiError => e
+ puts "Error when calling UsageApi->key_in_header: #{e}"
+end
+```
+
+#### Using the key_in_header_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(Object, Integer, Hash)> key_in_header_with_http_info
+
+```ruby
+begin
+ # Use API key in header
+ data, status_code, headers = api_instance.key_in_header_with_http_info
+ p status_code # => 2xx
+ p headers # => { ... }
+ p data # => Object
+rescue XAuthIDAlias::ApiError => e
+ puts "Error when calling UsageApi->key_in_header_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+This endpoint does not need any parameter.
+
+### Return type
+
+**Object**
+
+### Authorization
+
+[api_key](../README.md#api_key)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## key_in_query
+
+> Object key_in_query
+
+Use API key in query
+
+Use API key in query
+
+### Examples
+
+```ruby
+require 'time'
+require 'x_auth_id_alias'
+# setup authorization
+XAuthIDAlias.configure do |config|
+ # Configure API key authorization: api_key_query
+ config.api_key['api_key_query'] = 'YOUR API KEY'
+ # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+ # config.api_key_prefix['api_key_query'] = 'Bearer'
+end
+
+api_instance = XAuthIDAlias::UsageApi.new
+
+begin
+ # Use API key in query
+ result = api_instance.key_in_query
+ p result
+rescue XAuthIDAlias::ApiError => e
+ puts "Error when calling UsageApi->key_in_query: #{e}"
+end
+```
+
+#### Using the key_in_query_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(Object, Integer, Hash)> key_in_query_with_http_info
+
+```ruby
+begin
+ # Use API key in query
+ data, status_code, headers = api_instance.key_in_query_with_http_info
+ p status_code # => 2xx
+ p headers # => { ... }
+ p data # => Object
+rescue XAuthIDAlias::ApiError => e
+ puts "Error when calling UsageApi->key_in_query_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+This endpoint does not need any parameter.
+
+### Return type
+
+**Object**
+
+### Authorization
+
+[api_key_query](../README.md#api_key_query)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/git_push.sh b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/git_push.sh
new file mode 100644
index 0000000000000000000000000000000000000000..ced3be2b0c7b2349ff06d18da19d4b31435c9fa6
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/git_push.sh
@@ -0,0 +1,58 @@
+#!/bin/sh
+# ref: https://help.github.com/articles/adding-an-existing-project-to-github-using-the-command-line/
+#
+# Usage example: /bin/sh ./git_push.sh wing328 openapi-pestore-perl "minor update" "gitlab.com"
+
+git_user_id=$1
+git_repo_id=$2
+release_note=$3
+git_host=$4
+
+if [ "$git_host" = "" ]; then
+ git_host="github.com"
+ echo "[INFO] No command line input provided. Set \$git_host to $git_host"
+fi
+
+if [ "$git_user_id" = "" ]; then
+ git_user_id="GIT_USER_ID"
+ echo "[INFO] No command line input provided. Set \$git_user_id to $git_user_id"
+fi
+
+if [ "$git_repo_id" = "" ]; then
+ git_repo_id="GIT_REPO_ID"
+ echo "[INFO] No command line input provided. Set \$git_repo_id to $git_repo_id"
+fi
+
+if [ "$release_note" = "" ]; then
+ release_note="Minor update"
+ echo "[INFO] No command line input provided. Set \$release_note to $release_note"
+fi
+
+# Initialize the local directory as a Git repository
+git init
+
+# Adds the files in the local repository and stages them for commit.
+git add .
+
+# Commits the tracked changes and prepares them to be pushed to a remote repository.
+git commit -m "$release_note"
+
+# Sets the new remote
+git_remote=`git remote`
+if [ "$git_remote" = "" ]; then # git remote not defined
+
+ if [ "$GIT_TOKEN" = "" ]; then
+ echo "[INFO] \$GIT_TOKEN (environment variable) is not set. Using the git credential in your environment."
+ git remote add origin https://${git_host}/${git_user_id}/${git_repo_id}.git
+ else
+ git remote add origin https://${git_user_id}:${GIT_TOKEN}@${git_host}/${git_user_id}/${git_repo_id}.git
+ fi
+
+fi
+
+git pull origin master
+
+# Pushes (Forces) the changes in the local repository up to the remote repository
+echo "Git pushing to https://${git_host}/${git_user_id}/${git_repo_id}.git"
+git push origin master 2>&1 | grep -v 'To https'
+
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/lib/x_auth_id_alias.rb b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/lib/x_auth_id_alias.rb
new file mode 100644
index 0000000000000000000000000000000000000000..d6f15e07842aa7108a23e3559cfb57d6db5088ae
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/lib/x_auth_id_alias.rb
@@ -0,0 +1,40 @@
+=begin
+#OpenAPI Extension x-auth-id-alias
+
+#This specification shows how to use x-auth-id-alias extension for API keys.
+
+The version of the OpenAPI document: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 5.0.1-SNAPSHOT
+
+=end
+
+# Common files
+require 'x_auth_id_alias/api_client'
+require 'x_auth_id_alias/api_error'
+require 'x_auth_id_alias/version'
+require 'x_auth_id_alias/configuration'
+
+# Models
+
+# APIs
+require 'x_auth_id_alias/api/usage_api'
+
+module XAuthIDAlias
+ class << self
+ # Customize default settings for the SDK using block.
+ # XAuthIDAlias.configure do |config|
+ # config.username = "xxx"
+ # config.password = "xxx"
+ # end
+ # If no block given, return the default Configuration object.
+ def configure
+ if block_given?
+ yield(Configuration.default)
+ else
+ Configuration.default
+ end
+ end
+ end
+end
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/lib/x_auth_id_alias/api/usage_api.rb b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/lib/x_auth_id_alias/api/usage_api.rb
new file mode 100644
index 0000000000000000000000000000000000000000..dd2e559b1187377061c3be546930a8f880ccc50d
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/lib/x_auth_id_alias/api/usage_api.rb
@@ -0,0 +1,250 @@
+=begin
+#OpenAPI Extension x-auth-id-alias
+
+#This specification shows how to use x-auth-id-alias extension for API keys.
+
+The version of the OpenAPI document: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 5.0.1-SNAPSHOT
+
+=end
+
+require 'cgi'
+
+module XAuthIDAlias
+ class UsageApi
+ attr_accessor :api_client
+
+ def initialize(api_client = ApiClient.default)
+ @api_client = api_client
+ end
+ # Use any API key
+ # Use any API key
+ # @param [Hash] opts the optional parameters
+ # @return [Object]
+ def any_key(opts = {})
+ data, _status_code, _headers = any_key_with_http_info(opts)
+ data
+ end
+
+ # Use any API key
+ # Use any API key
+ # @param [Hash] opts the optional parameters
+ # @return [Array<(Object, Integer, Hash)>] Object data, response status code and response headers
+ def any_key_with_http_info(opts = {})
+ if @api_client.config.debugging
+ @api_client.config.logger.debug 'Calling API: UsageApi.any_key ...'
+ end
+ # resource path
+ local_var_path = '/any'
+
+ # query parameters
+ query_params = opts[:query_params] || {}
+
+ # header parameters
+ header_params = opts[:header_params] || {}
+ # HTTP header 'Accept' (if needed)
+ header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+
+ # form parameters
+ form_params = opts[:form_params] || {}
+
+ # http body (model)
+ post_body = opts[:debug_body]
+
+ # return_type
+ return_type = opts[:debug_return_type] || 'Object'
+
+ # auth_names
+ auth_names = opts[:debug_auth_names] || ['api_key', 'api_key_query']
+
+ new_options = opts.merge(
+ :operation => :"UsageApi.any_key",
+ :header_params => header_params,
+ :query_params => query_params,
+ :form_params => form_params,
+ :body => post_body,
+ :auth_names => auth_names,
+ :return_type => return_type
+ )
+
+ data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+ if @api_client.config.debugging
+ @api_client.config.logger.debug "API called: UsageApi#any_key\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+ end
+ return data, status_code, headers
+ end
+
+ # Use both API keys
+ # Use both API keys
+ # @param [Hash] opts the optional parameters
+ # @return [Object]
+ def both_keys(opts = {})
+ data, _status_code, _headers = both_keys_with_http_info(opts)
+ data
+ end
+
+ # Use both API keys
+ # Use both API keys
+ # @param [Hash] opts the optional parameters
+ # @return [Array<(Object, Integer, Hash)>] Object data, response status code and response headers
+ def both_keys_with_http_info(opts = {})
+ if @api_client.config.debugging
+ @api_client.config.logger.debug 'Calling API: UsageApi.both_keys ...'
+ end
+ # resource path
+ local_var_path = '/both'
+
+ # query parameters
+ query_params = opts[:query_params] || {}
+
+ # header parameters
+ header_params = opts[:header_params] || {}
+ # HTTP header 'Accept' (if needed)
+ header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+
+ # form parameters
+ form_params = opts[:form_params] || {}
+
+ # http body (model)
+ post_body = opts[:debug_body]
+
+ # return_type
+ return_type = opts[:debug_return_type] || 'Object'
+
+ # auth_names
+ auth_names = opts[:debug_auth_names] || ['api_key', 'api_key_query']
+
+ new_options = opts.merge(
+ :operation => :"UsageApi.both_keys",
+ :header_params => header_params,
+ :query_params => query_params,
+ :form_params => form_params,
+ :body => post_body,
+ :auth_names => auth_names,
+ :return_type => return_type
+ )
+
+ data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+ if @api_client.config.debugging
+ @api_client.config.logger.debug "API called: UsageApi#both_keys\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+ end
+ return data, status_code, headers
+ end
+
+ # Use API key in header
+ # Use API key in header
+ # @param [Hash] opts the optional parameters
+ # @return [Object]
+ def key_in_header(opts = {})
+ data, _status_code, _headers = key_in_header_with_http_info(opts)
+ data
+ end
+
+ # Use API key in header
+ # Use API key in header
+ # @param [Hash] opts the optional parameters
+ # @return [Array<(Object, Integer, Hash)>] Object data, response status code and response headers
+ def key_in_header_with_http_info(opts = {})
+ if @api_client.config.debugging
+ @api_client.config.logger.debug 'Calling API: UsageApi.key_in_header ...'
+ end
+ # resource path
+ local_var_path = '/header'
+
+ # query parameters
+ query_params = opts[:query_params] || {}
+
+ # header parameters
+ header_params = opts[:header_params] || {}
+ # HTTP header 'Accept' (if needed)
+ header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+
+ # form parameters
+ form_params = opts[:form_params] || {}
+
+ # http body (model)
+ post_body = opts[:debug_body]
+
+ # return_type
+ return_type = opts[:debug_return_type] || 'Object'
+
+ # auth_names
+ auth_names = opts[:debug_auth_names] || ['api_key']
+
+ new_options = opts.merge(
+ :operation => :"UsageApi.key_in_header",
+ :header_params => header_params,
+ :query_params => query_params,
+ :form_params => form_params,
+ :body => post_body,
+ :auth_names => auth_names,
+ :return_type => return_type
+ )
+
+ data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+ if @api_client.config.debugging
+ @api_client.config.logger.debug "API called: UsageApi#key_in_header\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+ end
+ return data, status_code, headers
+ end
+
+ # Use API key in query
+ # Use API key in query
+ # @param [Hash] opts the optional parameters
+ # @return [Object]
+ def key_in_query(opts = {})
+ data, _status_code, _headers = key_in_query_with_http_info(opts)
+ data
+ end
+
+ # Use API key in query
+ # Use API key in query
+ # @param [Hash] opts the optional parameters
+ # @return [Array<(Object, Integer, Hash)>] Object data, response status code and response headers
+ def key_in_query_with_http_info(opts = {})
+ if @api_client.config.debugging
+ @api_client.config.logger.debug 'Calling API: UsageApi.key_in_query ...'
+ end
+ # resource path
+ local_var_path = '/query'
+
+ # query parameters
+ query_params = opts[:query_params] || {}
+
+ # header parameters
+ header_params = opts[:header_params] || {}
+ # HTTP header 'Accept' (if needed)
+ header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+
+ # form parameters
+ form_params = opts[:form_params] || {}
+
+ # http body (model)
+ post_body = opts[:debug_body]
+
+ # return_type
+ return_type = opts[:debug_return_type] || 'Object'
+
+ # auth_names
+ auth_names = opts[:debug_auth_names] || ['api_key_query']
+
+ new_options = opts.merge(
+ :operation => :"UsageApi.key_in_query",
+ :header_params => header_params,
+ :query_params => query_params,
+ :form_params => form_params,
+ :body => post_body,
+ :auth_names => auth_names,
+ :return_type => return_type
+ )
+
+ data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+ if @api_client.config.debugging
+ @api_client.config.logger.debug "API called: UsageApi#key_in_query\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+ end
+ return data, status_code, headers
+ end
+ end
+end
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/lib/x_auth_id_alias/api_client.rb b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/lib/x_auth_id_alias/api_client.rb
new file mode 100644
index 0000000000000000000000000000000000000000..139bf5eb779f16c6bd5775f122ef94fb76debae0
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/lib/x_auth_id_alias/api_client.rb
@@ -0,0 +1,390 @@
+=begin
+#OpenAPI Extension x-auth-id-alias
+
+#This specification shows how to use x-auth-id-alias extension for API keys.
+
+The version of the OpenAPI document: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 5.0.1-SNAPSHOT
+
+=end
+
+require 'date'
+require 'json'
+require 'logger'
+require 'tempfile'
+require 'time'
+require 'typhoeus'
+
+module XAuthIDAlias
+ class ApiClient
+ # The Configuration object holding settings to be used in the API client.
+ attr_accessor :config
+
+ # Defines the headers to be used in HTTP requests of all API calls by default.
+ #
+ # @return [Hash]
+ attr_accessor :default_headers
+
+ # Initializes the ApiClient
+ # @option config [Configuration] Configuration for initializing the object, default to Configuration.default
+ def initialize(config = Configuration.default)
+ @config = config
+ @user_agent = "OpenAPI-Generator/#{VERSION}/ruby"
+ @default_headers = {
+ 'Content-Type' => 'application/json',
+ 'User-Agent' => @user_agent
+ }
+ end
+
+ def self.default
+ @@default ||= ApiClient.new
+ end
+
+ # Call an API with given options.
+ #
+ # @return [Array<(Object, Integer, Hash)>] an array of 3 elements:
+ # the data deserialized from response body (could be nil), response status code and response headers.
+ def call_api(http_method, path, opts = {})
+ request = build_request(http_method, path, opts)
+ response = request.run
+
+ if @config.debugging
+ @config.logger.debug "HTTP response body ~BEGIN~\n#{response.body}\n~END~\n"
+ end
+
+ unless response.success?
+ if response.timed_out?
+ fail ApiError.new('Connection timed out')
+ elsif response.code == 0
+ # Errors from libcurl will be made visible here
+ fail ApiError.new(:code => 0,
+ :message => response.return_message)
+ else
+ fail ApiError.new(:code => response.code,
+ :response_headers => response.headers,
+ :response_body => response.body),
+ response.status_message
+ end
+ end
+
+ if opts[:return_type]
+ data = deserialize(response, opts[:return_type])
+ else
+ data = nil
+ end
+ return data, response.code, response.headers
+ end
+
+ # Builds the HTTP request
+ #
+ # @param [String] http_method HTTP method/verb (e.g. POST)
+ # @param [String] path URL path (e.g. /account/new)
+ # @option opts [Hash] :header_params Header parameters
+ # @option opts [Hash] :query_params Query parameters
+ # @option opts [Hash] :form_params Query parameters
+ # @option opts [Object] :body HTTP body (JSON/XML)
+ # @return [Typhoeus::Request] A Typhoeus Request
+ def build_request(http_method, path, opts = {})
+ url = build_request_url(path, opts)
+ http_method = http_method.to_sym.downcase
+
+ header_params = @default_headers.merge(opts[:header_params] || {})
+ query_params = opts[:query_params] || {}
+ form_params = opts[:form_params] || {}
+
+ update_params_for_auth! header_params, query_params, opts[:auth_names]
+
+ # set ssl_verifyhosts option based on @config.verify_ssl_host (true/false)
+ _verify_ssl_host = @config.verify_ssl_host ? 2 : 0
+
+ req_opts = {
+ :method => http_method,
+ :headers => header_params,
+ :params => query_params,
+ :params_encoding => @config.params_encoding,
+ :timeout => @config.timeout,
+ :ssl_verifypeer => @config.verify_ssl,
+ :ssl_verifyhost => _verify_ssl_host,
+ :sslcert => @config.cert_file,
+ :sslkey => @config.key_file,
+ :verbose => @config.debugging
+ }
+
+ # set custom cert, if provided
+ req_opts[:cainfo] = @config.ssl_ca_cert if @config.ssl_ca_cert
+
+ if [:post, :patch, :put, :delete].include?(http_method)
+ req_body = build_request_body(header_params, form_params, opts[:body])
+ req_opts.update :body => req_body
+ if @config.debugging
+ @config.logger.debug "HTTP request body param ~BEGIN~\n#{req_body}\n~END~\n"
+ end
+ end
+
+ request = Typhoeus::Request.new(url, req_opts)
+ download_file(request) if opts[:return_type] == 'File'
+ request
+ end
+
+ # Builds the HTTP request body
+ #
+ # @param [Hash] header_params Header parameters
+ # @param [Hash] form_params Query parameters
+ # @param [Object] body HTTP body (JSON/XML)
+ # @return [String] HTTP body data in the form of string
+ def build_request_body(header_params, form_params, body)
+ # http form
+ if header_params['Content-Type'] == 'application/x-www-form-urlencoded' ||
+ header_params['Content-Type'] == 'multipart/form-data'
+ data = {}
+ form_params.each do |key, value|
+ case value
+ when ::File, ::Array, nil
+ # let typhoeus handle File, Array and nil parameters
+ data[key] = value
+ else
+ data[key] = value.to_s
+ end
+ end
+ elsif body
+ data = body.is_a?(String) ? body : body.to_json
+ else
+ data = nil
+ end
+ data
+ end
+
+ # Save response body into a file in (the defined) temporary folder, using the filename
+ # from the "Content-Disposition" header if provided, otherwise a random filename.
+ # The response body is written to the file in chunks in order to handle files which
+ # size is larger than maximum Ruby String or even larger than the maximum memory a Ruby
+ # process can use.
+ #
+ # @see Configuration#temp_folder_path
+ def download_file(request)
+ tempfile = nil
+ encoding = nil
+ request.on_headers do |response|
+ content_disposition = response.headers['Content-Disposition']
+ if content_disposition && content_disposition =~ /filename=/i
+ filename = content_disposition[/filename=['"]?([^'"\s]+)['"]?/, 1]
+ prefix = sanitize_filename(filename)
+ else
+ prefix = 'download-'
+ end
+ prefix = prefix + '-' unless prefix.end_with?('-')
+ encoding = response.body.encoding
+ tempfile = Tempfile.open(prefix, @config.temp_folder_path, encoding: encoding)
+ @tempfile = tempfile
+ end
+ request.on_body do |chunk|
+ chunk.force_encoding(encoding)
+ tempfile.write(chunk)
+ end
+ request.on_complete do |response|
+ if tempfile
+ tempfile.close
+ @config.logger.info "Temp file written to #{tempfile.path}, please copy the file to a proper folder "\
+ "with e.g. `FileUtils.cp(tempfile.path, '/new/file/path')` otherwise the temp file "\
+ "will be deleted automatically with GC. It's also recommended to delete the temp file "\
+ "explicitly with `tempfile.delete`"
+ end
+ end
+ end
+
+ # Check if the given MIME is a JSON MIME.
+ # JSON MIME examples:
+ # application/json
+ # application/json; charset=UTF8
+ # APPLICATION/JSON
+ # */*
+ # @param [String] mime MIME
+ # @return [Boolean] True if the MIME is application/json
+ def json_mime?(mime)
+ (mime == '*/*') || !(mime =~ /Application\/.*json(?!p)(;.*)?/i).nil?
+ end
+
+ # Deserialize the response to the given return type.
+ #
+ # @param [Response] response HTTP response
+ # @param [String] return_type some examples: "User", "Array<User>", "Hash<String, Integer>"
+ def deserialize(response, return_type)
+ body = response.body
+
+ # handle file downloading - return the File instance processed in request callbacks
+ # note that response body is empty when the file is written in chunks in request on_body callback
+ return @tempfile if return_type == 'File'
+
+ return nil if body.nil? || body.empty?
+
+ # return response body directly for String return type
+ return body if return_type == 'String'
+
+ # ensuring a default content type
+ content_type = response.headers['Content-Type'] || 'application/json'
+
+ fail "Content-Type is not supported: #{content_type}" unless json_mime?(content_type)
+
+ begin
+ data = JSON.parse("[#{body}]", :symbolize_names => true)[0]
+ rescue JSON::ParserError => e
+ if %w(String Date Time).include?(return_type)
+ data = body
+ else
+ raise e
+ end
+ end
+
+ convert_to_type data, return_type
+ end
+
+ # Convert data to the given return type.
+ # @param [Object] data Data to be converted
+ # @param [String] return_type Return type
+ # @return [Mixed] Data in a particular type
+ def convert_to_type(data, return_type)
+ return nil if data.nil?
+ case return_type
+ when 'String'
+ data.to_s
+ when 'Integer'
+ data.to_i
+ when 'Float'
+ data.to_f
+ when 'Boolean'
+ data == true
+ when 'Time'
+ # parse date time (expecting ISO 8601 format)
+ Time.parse data
+ when 'Date'
+ # parse date time (expecting ISO 8601 format)
+ Date.parse data
+ when 'Object'
+ # generic object (usually a Hash), return directly
+ data
+ when /\AArray<(.+)>\z/
+ # e.g. Array<Pet>
+ sub_type = $1
+ data.map { |item| convert_to_type(item, sub_type) }
+ when /\AHash\<String, (.+)\>\z/
+ # e.g. Hash<String, Integer>
+ sub_type = $1
+ {}.tap do |hash|
+ data.each { |k, v| hash[k] = convert_to_type(v, sub_type) }
+ end
+ else
+ # models (e.g. Pet) or oneOf
+ klass = XAuthIDAlias.const_get(return_type)
+ klass.respond_to?(:openapi_one_of) ? klass.build(data) : klass.build_from_hash(data)
+ end
+ end
+
+ # Sanitize filename by removing path.
+ # e.g. ../../sun.gif becomes sun.gif
+ #
+ # @param [String] filename the filename to be sanitized
+ # @return [String] the sanitized filename
+ def sanitize_filename(filename)
+ filename.gsub(/.*[\/\\]/, '')
+ end
+
+ def build_request_url(path, opts = {})
+ # Add leading and trailing slashes to path
+ path = "/#{path}".gsub(/\/+/, '/')
+ @config.base_url(opts[:operation]) + path
+ end
+
+ # Update hearder and query params based on authentication settings.
+ #
+ # @param [Hash] header_params Header parameters
+ # @param [Hash] query_params Query parameters
+ # @param [String] auth_names Authentication scheme name
+ def update_params_for_auth!(header_params, query_params, auth_names)
+ Array(auth_names).each do |auth_name|
+ auth_setting = @config.auth_settings[auth_name]
+ next unless auth_setting
+ case auth_setting[:in]
+ when 'header' then header_params[auth_setting[:key]] = auth_setting[:value]
+ when 'query' then query_params[auth_setting[:key]] = auth_setting[:value]
+ else fail ArgumentError, 'Authentication token must be in `query` or `header`'
+ end
+ end
+ end
+
+ # Sets user agent in HTTP header
+ #
+ # @param [String] user_agent User agent (e.g. openapi-generator/ruby/1.0.0)
+ def user_agent=(user_agent)
+ @user_agent = user_agent
+ @default_headers['User-Agent'] = @user_agent
+ end
+
+ # Return Accept header based on an array of accepts provided.
+ # @param [Array] accepts array for Accept
+ # @return [String] the Accept header (e.g. application/json)
+ def select_header_accept(accepts)
+ return nil if accepts.nil? || accepts.empty?
+ # use JSON when present, otherwise use all of the provided
+ json_accept = accepts.find { |s| json_mime?(s) }
+ json_accept || accepts.join(',')
+ end
+
+ # Return Content-Type header based on an array of content types provided.
+ # @param [Array] content_types array for Content-Type
+ # @return [String] the Content-Type header (e.g. application/json)
+ def select_header_content_type(content_types)
+ # use application/json by default
+ return 'application/json' if content_types.nil? || content_types.empty?
+ # use JSON when present, otherwise use the first one
+ json_content_type = content_types.find { |s| json_mime?(s) }
+ json_content_type || content_types.first
+ end
+
+ # Convert object (array, hash, object, etc) to JSON string.
+ # @param [Object] model object to be converted into JSON string
+ # @return [String] JSON string representation of the object
+ def object_to_http_body(model)
+ return model if model.nil? || model.is_a?(String)
+ local_body = nil
+ if model.is_a?(Array)
+ local_body = model.map { |m| object_to_hash(m) }
+ else
+ local_body = object_to_hash(model)
+ end
+ local_body.to_json
+ end
+
+ # Convert object(non-array) to hash.
+ # @param [Object] obj object to be converted into JSON string
+ # @return [String] JSON string representation of the object
+ def object_to_hash(obj)
+ if obj.respond_to?(:to_hash)
+ obj.to_hash
+ else
+ obj
+ end
+ end
+
+ # Build parameter value according to the given collection format.
+ # @param [String] collection_format one of :csv, :ssv, :tsv, :pipes and :multi
+ def build_collection_param(param, collection_format)
+ case collection_format
+ when :csv
+ param.join(',')
+ when :ssv
+ param.join(' ')
+ when :tsv
+ param.join("\t")
+ when :pipes
+ param.join('|')
+ when :multi
+ # return the array directly as typhoeus will handle it as expected
+ param
+ else
+ fail "unknown collection format: #{collection_format.inspect}"
+ end
+ end
+ end
+end
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/lib/x_auth_id_alias/api_error.rb b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/lib/x_auth_id_alias/api_error.rb
new file mode 100644
index 0000000000000000000000000000000000000000..08ff5e865203f92d0da0be6e3812ebfb81cfc6fe
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/lib/x_auth_id_alias/api_error.rb
@@ -0,0 +1,57 @@
+=begin
+#OpenAPI Extension x-auth-id-alias
+
+#This specification shows how to use x-auth-id-alias extension for API keys.
+
+The version of the OpenAPI document: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 5.0.1-SNAPSHOT
+
+=end
+
+module XAuthIDAlias
+ class ApiError < StandardError
+ attr_reader :code, :response_headers, :response_body
+
+ # Usage examples:
+ # ApiError.new
+ # ApiError.new("message")
+ # ApiError.new(:code => 500, :response_headers => {}, :response_body => "")
+ # ApiError.new(:code => 404, :message => "Not Found")
+ def initialize(arg = nil)
+ if arg.is_a? Hash
+ if arg.key?(:message) || arg.key?('message')
+ super(arg[:message] || arg['message'])
+ else
+ super arg
+ end
+
+ arg.each do |k, v|
+ instance_variable_set "@#{k}", v
+ end
+ else
+ super arg
+ end
+ end
+
+ # Override to_s to display a friendly error message
+ def to_s
+ message
+ end
+
+ def message
+ if @message.nil?
+ msg = "Error message: the server returns an error"
+ else
+ msg = @message
+ end
+
+ msg += "\nHTTP status code: #{code}" if code
+ msg += "\nResponse headers: #{response_headers}" if response_headers
+ msg += "\nResponse body: #{response_body}" if response_body
+
+ msg
+ end
+ end
+end
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/lib/x_auth_id_alias/configuration.rb b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/lib/x_auth_id_alias/configuration.rb
new file mode 100644
index 0000000000000000000000000000000000000000..b2dc6bfef65a3cf1e0f9187d99362c96e4bbe171
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/lib/x_auth_id_alias/configuration.rb
@@ -0,0 +1,317 @@
+=begin
+#OpenAPI Extension x-auth-id-alias
+
+#This specification shows how to use x-auth-id-alias extension for API keys.
+
+The version of the OpenAPI document: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 5.0.1-SNAPSHOT
+
+=end
+
+module XAuthIDAlias
+ class Configuration
+ # Defines url scheme
+ attr_accessor :scheme
+
+ # Defines url host
+ attr_accessor :host
+
+ # Defines url base path
+ attr_accessor :base_path
+
+ # Define server configuration index
+ attr_accessor :server_index
+
+ # Define server operation configuration index
+ attr_accessor :server_operation_index
+
+ # Default server variables
+ attr_accessor :server_variables
+
+ # Default server operation variables
+ attr_accessor :server_operation_variables
+
+ # Defines API keys used with API Key authentications.
+ #
+ # @return [Hash] key: parameter name, value: parameter value (API key)
+ #
+ # @example parameter name is "api_key", API key is "xxx" (e.g. "api_key=xxx" in query string)
+ # config.api_key['api_key'] = 'xxx'
+ attr_accessor :api_key
+
+ # Defines API key prefixes used with API Key authentications.
+ #
+ # @return [Hash] key: parameter name, value: API key prefix
+ #
+ # @example parameter name is "Authorization", API key prefix is "Token" (e.g. "Authorization: Token xxx" in headers)
+ # config.api_key_prefix['api_key'] = 'Token'
+ attr_accessor :api_key_prefix
+
+ # Defines the username used with HTTP basic authentication.
+ #
+ # @return [String]
+ attr_accessor :username
+
+ # Defines the password used with HTTP basic authentication.
+ #
+ # @return [String]
+ attr_accessor :password
+
+ # Defines the access token (Bearer) used with OAuth2.
+ attr_accessor :access_token
+
+ # Set this to enable/disable debugging. When enabled (set to true), HTTP request/response
+ # details will be logged with `logger.debug` (see the `logger` attribute).
+ # Default to false.
+ #
+ # @return [true, false]
+ attr_accessor :debugging
+
+ # Defines the logger used for debugging.
+ # Default to `Rails.logger` (when in Rails) or logging to STDOUT.
+ #
+ # @return [#debug]
+ attr_accessor :logger
+
+ # Defines the temporary folder to store downloaded files
+ # (for API endpoints that have file response).
+ # Default to use `Tempfile`.
+ #
+ # @return [String]
+ attr_accessor :temp_folder_path
+
+ # The time limit for HTTP request in seconds.
+ # Default to 0 (never times out).
+ attr_accessor :timeout
+
+ # Set this to false to skip client side validation in the operation.
+ # Default to true.
+ # @return [true, false]
+ attr_accessor :client_side_validation
+
+ ### TLS/SSL setting
+ # Set this to false to skip verifying SSL certificate when calling API from https server.
+ # Default to true.
+ #
+ # @note Do NOT set it to false in production code, otherwise you would face multiple types of cryptographic attacks.
+ #
+ # @return [true, false]
+ attr_accessor :verify_ssl
+
+ ### TLS/SSL setting
+ # Set this to false to skip verifying SSL host name
+ # Default to true.
+ #
+ # @note Do NOT set it to false in production code, otherwise you would face multiple types of cryptographic attacks.
+ #
+ # @return [true, false]
+ attr_accessor :verify_ssl_host
+
+ ### TLS/SSL setting
+ # Set this to customize the certificate file to verify the peer.
+ #
+ # @return [String] the path to the certificate file
+ #
+ # @see The `cainfo` option of Typhoeus, `--cert` option of libcurl. Related source code:
+ # https://github.com/typhoeus/typhoeus/blob/master/lib/typhoeus/easy_factory.rb#L145
+ attr_accessor :ssl_ca_cert
+
+ ### TLS/SSL setting
+ # Client certificate file (for client certificate)
+ attr_accessor :cert_file
+
+ ### TLS/SSL setting
+ # Client private key file (for client certificate)
+ attr_accessor :key_file
+
+ # Set this to customize parameters encoding of array parameter with multi collectionFormat.
+ # Default to nil.
+ #
+ # @see The params_encoding option of Ethon. Related source code:
+ # https://github.com/typhoeus/ethon/blob/master/lib/ethon/easy/queryable.rb#L96
+ attr_accessor :params_encoding
+
+ attr_accessor :inject_format
+
+ attr_accessor :force_ending_format
+
+ def initialize
+ @scheme = 'http'
+ @host = 'petstore.swagger.io'
+ @base_path = '/v2'
+ @server_index = 0
+ @server_operation_index = {}
+ @server_variables = {}
+ @server_operation_variables = {}
+ @api_key = {}
+ @api_key_prefix = {}
+ @timeout = 0
+ @client_side_validation = true
+ @verify_ssl = true
+ @verify_ssl_host = true
+ @params_encoding = nil
+ @cert_file = nil
+ @key_file = nil
+ @debugging = false
+ @inject_format = false
+ @force_ending_format = false
+ @logger = defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
+
+ yield(self) if block_given?
+ end
+
+ # The default Configuration object.
+ def self.default
+ @@default ||= Configuration.new
+ end
+
+ def configure
+ yield(self) if block_given?
+ end
+
+ def scheme=(scheme)
+ # remove :// from scheme
+ @scheme = scheme.sub(/:\/\//, '')
+ end
+
+ def host=(host)
+ # remove http(s):// and anything after a slash
+ @host = host.sub(/https?:\/\//, '').split('/').first
+ end
+
+ def base_path=(base_path)
+ # Add leading and trailing slashes to base_path
+ @base_path = "/#{base_path}".gsub(/\/+/, '/')
+ @base_path = '' if @base_path == '/'
+ end
+
+ # Returns base URL for specified operation based on server settings
+ def base_url(operation = nil)
+ index = server_operation_index.fetch(operation, server_index)
+ return "#{scheme}://#{[host, base_path].join('/').gsub(/\/+/, '/')}".sub(/\/+\z/, '') if index == nil
+
+ server_url(index, server_operation_variables.fetch(operation, server_variables), operation_server_settings[operation])
+ end
+
+ # Gets API key (with prefix if set).
+ # @param [String] param_name the parameter name of API key auth
+ def api_key_with_prefix(param_name, param_alias = nil)
+ key = @api_key[param_name]
+ key = @api_key.fetch(param_alias, key) unless param_alias.nil?
+ if @api_key_prefix[param_name]
+ "#{@api_key_prefix[param_name]} #{key}"
+ else
+ key
+ end
+ end
+
+ # Gets Basic Auth token string
+ def basic_auth_token
+ 'Basic ' + ["#{username}:#{password}"].pack('m').delete("\r\n")
+ end
+
+ # Returns Auth Settings hash for api client.
+ def auth_settings
+ {
+ 'api_key' =>
+ {
+ type: 'api_key',
+ in: 'header',
+ key: 'X-Api-Key',
+ value: api_key_with_prefix('api_key')
+ },
+ 'api_key_query' =>
+ {
+ type: 'api_key',
+ in: 'query',
+ key: 'api_key',
+ value: api_key_with_prefix('api_key_query', 'api_key')
+ },
+ }
+ end
+
+ # Returns an array of Server setting
+ def server_settings
+ [
+ {
+ url: "http://{server}.swagger.io:{port}/v2",
+ description: "petstore server",
+ variables: {
+ server: {
+ description: "No description provided",
+ default_value: "petstore",
+ enum_values: [
+ "petstore",
+ "qa-petstore",
+ "dev-petstore"
+ ]
+ },
+ port: {
+ description: "No description provided",
+ default_value: "80",
+ enum_values: [
+ "80",
+ "8080"
+ ]
+ }
+ }
+ },
+ {
+ url: "https://localhost:8080/{version}",
+ description: "The local server",
+ variables: {
+ version: {
+ description: "No description provided",
+ default_value: "v2",
+ enum_values: [
+ "v1",
+ "v2"
+ ]
+ }
+ }
+ }
+ ]
+ end
+
+ def operation_server_settings
+ {
+ }
+ end
+
+ # Returns URL based on server settings
+ #
+ # @param index array index of the server settings
+ # @param variables hash of variable and the corresponding value
+ def server_url(index, variables = {}, servers = nil)
+ servers = server_settings if servers == nil
+
+ # check array index out of bound
+ if (index < 0 || index >= servers.size)
+ fail ArgumentError, "Invalid index #{index} when selecting the server. Must be less than #{servers.size}"
+ end
+
+ server = servers[index]
+ url = server[:url]
+
+ return url unless server.key? :variables
+
+ # go through variable and assign a value
+ server[:variables].each do |name, variable|
+ if variables.key?(name)
+ if (!server[:variables][name].key?(:enum_values) || server[:variables][name][:enum_values].include?(variables[name]))
+ url.gsub! "{" + name.to_s + "}", variables[name]
+ else
+ fail ArgumentError, "The variable `#{name}` in the server URL has invalid value #{variables[name]}. Must be #{server[:variables][name][:enum_values]}."
+ end
+ else
+ # use default value
+ url.gsub! "{" + name.to_s + "}", server[:variables][name][:default_value]
+ end
+ end
+
+ url
+ end
+ end
+end
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/lib/x_auth_id_alias/version.rb b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/lib/x_auth_id_alias/version.rb
new file mode 100644
index 0000000000000000000000000000000000000000..f427b102c228ef54f67b5e8352a5099f5f7e8546
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/lib/x_auth_id_alias/version.rb
@@ -0,0 +1,15 @@
+=begin
+#OpenAPI Extension x-auth-id-alias
+
+#This specification shows how to use x-auth-id-alias extension for API keys.
+
+The version of the OpenAPI document: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 5.0.1-SNAPSHOT
+
+=end
+
+module XAuthIDAlias
+ VERSION = '1.0.0'
+end
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/spec/api/usage_api_spec.rb b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/spec/api/usage_api_spec.rb
new file mode 100644
index 0000000000000000000000000000000000000000..03e3ed32596b1be05b2d488651bbcb1639858761
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/spec/api/usage_api_spec.rb
@@ -0,0 +1,79 @@
+=begin
+#OpenAPI Extension x-auth-id-alias
+
+#This specification shows how to use x-auth-id-alias extension for API keys.
+
+The version of the OpenAPI document: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 5.0.0-SNAPSHOT
+
+=end
+
+require 'spec_helper'
+require 'json'
+
+# Unit tests for XAuthIDAlias::UsageApi
+# Automatically generated by openapi-generator (https://openapi-generator.tech)
+# Please update as you see appropriate
+describe 'UsageApi' do
+ before do
+ # run before each test
+ @api_instance = XAuthIDAlias::UsageApi.new
+ end
+
+ after do
+ # run after each test
+ end
+
+ describe 'test an instance of UsageApi' do
+ it 'should create an instance of UsageApi' do
+ expect(@api_instance).to be_instance_of(XAuthIDAlias::UsageApi)
+ end
+ end
+
+ # unit tests for any_key
+ # Use any API key
+ # Use any API key
+ # @param [Hash] opts the optional parameters
+ # @return [Object]
+ describe 'any_key test' do
+ it 'should work' do
+ # assertion here. ref: https://www.relishapp.com/rspec/rspec-expectations/docs/built-in-matchers
+ end
+ end
+
+ # unit tests for both_keys
+ # Use both API keys
+ # Use both API keys
+ # @param [Hash] opts the optional parameters
+ # @return [Object]
+ describe 'both_keys test' do
+ it 'should work' do
+ # assertion here. ref: https://www.relishapp.com/rspec/rspec-expectations/docs/built-in-matchers
+ end
+ end
+
+ # unit tests for key_in_header
+ # Use API key in header
+ # Use API key in header
+ # @param [Hash] opts the optional parameters
+ # @return [Object]
+ describe 'key_in_header test' do
+ it 'should work' do
+ # assertion here. ref: https://www.relishapp.com/rspec/rspec-expectations/docs/built-in-matchers
+ end
+ end
+
+ # unit tests for key_in_query
+ # Use API key in query
+ # Use API key in query
+ # @param [Hash] opts the optional parameters
+ # @return [Object]
+ describe 'key_in_query test' do
+ it 'should work' do
+ # assertion here. ref: https://www.relishapp.com/rspec/rspec-expectations/docs/built-in-matchers
+ end
+ end
+
+end
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/spec/api_client_spec.rb b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/spec/api_client_spec.rb
new file mode 100644
index 0000000000000000000000000000000000000000..ed1139f8dfaa6a333faa085d161e347ae6d332cf
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/spec/api_client_spec.rb
@@ -0,0 +1,226 @@
+=begin
+#OpenAPI Extension x-auth-id-alias
+
+#This specification shows how to use x-auth-id-alias extension for API keys.
+
+The version of the OpenAPI document: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 5.0.1-SNAPSHOT
+
+=end
+
+require 'spec_helper'
+
+describe XAuthIDAlias::ApiClient do
+ context 'initialization' do
+ context 'URL stuff' do
+ context 'host' do
+ it 'removes http from host' do
+ XAuthIDAlias.configure { |c| c.host = 'http://example.com' }
+ expect(XAuthIDAlias::Configuration.default.host).to eq('example.com')
+ end
+
+ it 'removes https from host' do
+ XAuthIDAlias.configure { |c| c.host = 'https://wookiee.com' }
+ expect(XAuthIDAlias::ApiClient.default.config.host).to eq('wookiee.com')
+ end
+
+ it 'removes trailing path from host' do
+ XAuthIDAlias.configure { |c| c.host = 'hobo.com/v4' }
+ expect(XAuthIDAlias::Configuration.default.host).to eq('hobo.com')
+ end
+ end
+
+ context 'base_path' do
+ it "prepends a slash to base_path" do
+ XAuthIDAlias.configure { |c| c.base_path = 'v4/dog' }
+ expect(XAuthIDAlias::Configuration.default.base_path).to eq('/v4/dog')
+ end
+
+ it "doesn't prepend a slash if one is already there" do
+ XAuthIDAlias.configure { |c| c.base_path = '/v4/dog' }
+ expect(XAuthIDAlias::Configuration.default.base_path).to eq('/v4/dog')
+ end
+
+ it "ends up as a blank string if nil" do
+ XAuthIDAlias.configure { |c| c.base_path = nil }
+ expect(XAuthIDAlias::Configuration.default.base_path).to eq('')
+ end
+ end
+ end
+ end
+
+ describe 'params_encoding in #build_request' do
+ let(:config) { XAuthIDAlias::Configuration.new }
+ let(:api_client) { XAuthIDAlias::ApiClient.new(config) }
+
+ it 'defaults to nil' do
+ expect(XAuthIDAlias::Configuration.default.params_encoding).to eq(nil)
+ expect(config.params_encoding).to eq(nil)
+
+ request = api_client.build_request(:get, '/test')
+ expect(request.options[:params_encoding]).to eq(nil)
+ end
+
+ it 'can be customized' do
+ config.params_encoding = :multi
+ request = api_client.build_request(:get, '/test')
+ expect(request.options[:params_encoding]).to eq(:multi)
+ end
+ end
+
+ describe 'timeout in #build_request' do
+ let(:config) { XAuthIDAlias::Configuration.new }
+ let(:api_client) { XAuthIDAlias::ApiClient.new(config) }
+
+ it 'defaults to 0' do
+ expect(XAuthIDAlias::Configuration.default.timeout).to eq(0)
+ expect(config.timeout).to eq(0)
+
+ request = api_client.build_request(:get, '/test')
+ expect(request.options[:timeout]).to eq(0)
+ end
+
+ it 'can be customized' do
+ config.timeout = 100
+ request = api_client.build_request(:get, '/test')
+ expect(request.options[:timeout]).to eq(100)
+ end
+ end
+
+ describe '#deserialize' do
+ it "handles Array<Integer>" do
+ api_client = XAuthIDAlias::ApiClient.new
+ headers = { 'Content-Type' => 'application/json' }
+ response = double('response', headers: headers, body: '[12, 34]')
+ data = api_client.deserialize(response, 'Array<Integer>')
+ expect(data).to be_instance_of(Array)
+ expect(data).to eq([12, 34])
+ end
+
+ it 'handles Array<Array<Integer>>' do
+ api_client = XAuthIDAlias::ApiClient.new
+ headers = { 'Content-Type' => 'application/json' }
+ response = double('response', headers: headers, body: '[[12, 34], [56]]')
+ data = api_client.deserialize(response, 'Array<Array<Integer>>')
+ expect(data).to be_instance_of(Array)
+ expect(data).to eq([[12, 34], [56]])
+ end
+
+ it 'handles Hash<String, String>' do
+ api_client = XAuthIDAlias::ApiClient.new
+ headers = { 'Content-Type' => 'application/json' }
+ response = double('response', headers: headers, body: '{"message": "Hello"}')
+ data = api_client.deserialize(response, 'Hash<String, String>')
+ expect(data).to be_instance_of(Hash)
+ expect(data).to eq(:message => 'Hello')
+ end
+ end
+
+ describe "#object_to_hash" do
+ it 'ignores nils and includes empty arrays' do
+ # uncomment below to test object_to_hash for model
+ # api_client = XAuthIDAlias::ApiClient.new
+ # _model = XAuthIDAlias::ModelName.new
+ # update the model attribute below
+ # _model.id = 1
+ # update the expected value (hash) below
+ # expected = {id: 1, name: '', tags: []}
+ # expect(api_client.object_to_hash(_model)).to eq(expected)
+ end
+ end
+
+ describe '#build_collection_param' do
+ let(:param) { ['aa', 'bb', 'cc'] }
+ let(:api_client) { XAuthIDAlias::ApiClient.new }
+
+ it 'works for csv' do
+ expect(api_client.build_collection_param(param, :csv)).to eq('aa,bb,cc')
+ end
+
+ it 'works for ssv' do
+ expect(api_client.build_collection_param(param, :ssv)).to eq('aa bb cc')
+ end
+
+ it 'works for tsv' do
+ expect(api_client.build_collection_param(param, :tsv)).to eq("aa\tbb\tcc")
+ end
+
+ it 'works for pipes' do
+ expect(api_client.build_collection_param(param, :pipes)).to eq('aa|bb|cc')
+ end
+
+ it 'works for multi' do
+ expect(api_client.build_collection_param(param, :multi)).to eq(['aa', 'bb', 'cc'])
+ end
+
+ it 'fails for invalid collection format' do
+ expect { api_client.build_collection_param(param, :INVALID) }.to raise_error(RuntimeError, 'unknown collection format: :INVALID')
+ end
+ end
+
+ describe '#json_mime?' do
+ let(:api_client) { XAuthIDAlias::ApiClient.new }
+
+ it 'works' do
+ expect(api_client.json_mime?(nil)).to eq false
+ expect(api_client.json_mime?('')).to eq false
+
+ expect(api_client.json_mime?('application/json')).to eq true
+ expect(api_client.json_mime?('application/json; charset=UTF8')).to eq true
+ expect(api_client.json_mime?('APPLICATION/JSON')).to eq true
+
+ expect(api_client.json_mime?('application/xml')).to eq false
+ expect(api_client.json_mime?('text/plain')).to eq false
+ expect(api_client.json_mime?('application/jsonp')).to eq false
+ end
+ end
+
+ describe '#select_header_accept' do
+ let(:api_client) { XAuthIDAlias::ApiClient.new }
+
+ it 'works' do
+ expect(api_client.select_header_accept(nil)).to be_nil
+ expect(api_client.select_header_accept([])).to be_nil
+
+ expect(api_client.select_header_accept(['application/json'])).to eq('application/json')
+ expect(api_client.select_header_accept(['application/xml', 'application/json; charset=UTF8'])).to eq('application/json; charset=UTF8')
+ expect(api_client.select_header_accept(['APPLICATION/JSON', 'text/html'])).to eq('APPLICATION/JSON')
+
+ expect(api_client.select_header_accept(['application/xml'])).to eq('application/xml')
+ expect(api_client.select_header_accept(['text/html', 'application/xml'])).to eq('text/html,application/xml')
+ end
+ end
+
+ describe '#select_header_content_type' do
+ let(:api_client) { XAuthIDAlias::ApiClient.new }
+
+ it 'works' do
+ expect(api_client.select_header_content_type(nil)).to eq('application/json')
+ expect(api_client.select_header_content_type([])).to eq('application/json')
+
+ expect(api_client.select_header_content_type(['application/json'])).to eq('application/json')
+ expect(api_client.select_header_content_type(['application/xml', 'application/json; charset=UTF8'])).to eq('application/json; charset=UTF8')
+ expect(api_client.select_header_content_type(['APPLICATION/JSON', 'text/html'])).to eq('APPLICATION/JSON')
+ expect(api_client.select_header_content_type(['application/xml'])).to eq('application/xml')
+ expect(api_client.select_header_content_type(['text/plain', 'application/xml'])).to eq('text/plain')
+ end
+ end
+
+ describe '#sanitize_filename' do
+ let(:api_client) { XAuthIDAlias::ApiClient.new }
+
+ it 'works' do
+ expect(api_client.sanitize_filename('sun')).to eq('sun')
+ expect(api_client.sanitize_filename('sun.gif')).to eq('sun.gif')
+ expect(api_client.sanitize_filename('../sun.gif')).to eq('sun.gif')
+ expect(api_client.sanitize_filename('/var/tmp/sun.gif')).to eq('sun.gif')
+ expect(api_client.sanitize_filename('./sun.gif')).to eq('sun.gif')
+ expect(api_client.sanitize_filename('..\sun.gif')).to eq('sun.gif')
+ expect(api_client.sanitize_filename('\var\tmp\sun.gif')).to eq('sun.gif')
+ expect(api_client.sanitize_filename('c:\var\tmp\sun.gif')).to eq('sun.gif')
+ expect(api_client.sanitize_filename('.\sun.gif')).to eq('sun.gif')
+ end
+ end
+end
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/spec/configuration_spec.rb b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/spec/configuration_spec.rb
new file mode 100644
index 0000000000000000000000000000000000000000..c287861dd409b8bdf6a3df3779b5bf931af46f6e
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/spec/configuration_spec.rb
@@ -0,0 +1,42 @@
+=begin
+#OpenAPI Extension x-auth-id-alias
+
+#This specification shows how to use x-auth-id-alias extension for API keys.
+
+The version of the OpenAPI document: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 5.0.1-SNAPSHOT
+
+=end
+
+require 'spec_helper'
+
+describe XAuthIDAlias::Configuration do
+ let(:config) { XAuthIDAlias::Configuration.default }
+
+ before(:each) do
+ # uncomment below to setup host and base_path
+ # require 'URI'
+ # uri = URI.parse("http://petstore.swagger.io:80/v2")
+ # XAuthIDAlias.configure do |c|
+ # c.host = uri.host
+ # c.base_path = uri.path
+ # end
+ end
+
+ describe '#base_url' do
+ it 'should have the default value' do
+ # uncomment below to test default value of the base path
+ # expect(config.base_url).to eq("http://petstore.swagger.io:80/v2")
+ end
+
+ it 'should remove trailing slashes' do
+ [nil, '', '/', '//'].each do |base_path|
+ config.base_path = base_path
+ # uncomment below to test trailing slashes
+ # expect(config.base_url).to eq("http://petstore.swagger.io:80/v2")
+ end
+ end
+ end
+end
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/spec/spec_helper.rb b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/spec/spec_helper.rb
new file mode 100644
index 0000000000000000000000000000000000000000..7cacc73a72a627bb2b6651d210f1286b7c31e469
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/spec/spec_helper.rb
@@ -0,0 +1,111 @@
+=begin
+#OpenAPI Extension x-auth-id-alias
+
+#This specification shows how to use x-auth-id-alias extension for API keys.
+
+The version of the OpenAPI document: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 5.0.1-SNAPSHOT
+
+=end
+
+# load the gem
+require 'x_auth_id_alias'
+
+# The following was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+ # rspec-expectations config goes here. You can use an alternate
+ # assertion/expectation library such as wrong or the stdlib/minitest
+ # assertions if you prefer.
+ config.expect_with :rspec do |expectations|
+ # This option will default to `true` in RSpec 4. It makes the `description`
+ # and `failure_message` of custom matchers include text for helper methods
+ # defined using `chain`, e.g.:
+ # be_bigger_than(2).and_smaller_than(4).description
+ # # => "be bigger than 2 and smaller than 4"
+ # ...rather than:
+ # # => "be bigger than 2"
+ expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+ end
+
+ # rspec-mocks config goes here. You can use an alternate test double
+ # library (such as bogus or mocha) by changing the `mock_with` option here.
+ config.mock_with :rspec do |mocks|
+ # Prevents you from mocking or stubbing a method that does not exist on
+ # a real object. This is generally recommended, and will default to
+ # `true` in RSpec 4.
+ mocks.verify_partial_doubles = true
+ end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+ # These two settings work together to allow you to limit a spec run
+ # to individual examples or groups you care about by tagging them with
+ # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+ # get run.
+ config.filter_run :focus
+ config.run_all_when_everything_filtered = true
+
+ # Allows RSpec to persist some state between runs in order to support
+ # the `--only-failures` and `--next-failure` CLI options. We recommend
+ # you configure your source control system to ignore this file.
+ config.example_status_persistence_file_path = "spec/examples.txt"
+
+ # Limits the available syntax to the non-monkey patched syntax that is
+ # recommended. For more details, see:
+ # - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+ # - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+ # - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+ config.disable_monkey_patching!
+
+ # This setting enables warnings. It's recommended, but in some cases may
+ # be too noisy due to issues in dependencies.
+ config.warnings = true
+
+ # Many RSpec users commonly either run the entire suite or an individual
+ # file, and it's useful to allow more verbose output when running an
+ # individual spec file.
+ if config.files_to_run.one?
+ # Use the documentation formatter for detailed output,
+ # unless a formatter has already been configured
+ # (e.g. via a command-line flag).
+ config.default_formatter = 'doc'
+ end
+
+ # Print the 10 slowest examples and example groups at the
+ # end of the spec run, to help surface which specs are running
+ # particularly slow.
+ config.profile_examples = 10
+
+ # Run specs in random order to surface order dependencies. If you find an
+ # order dependency and want to debug it, you can fix the order by providing
+ # the seed, which is printed after each run.
+ # --seed 1234
+ config.order = :random
+
+ # Seed global randomization in this process using the `--seed` CLI option.
+ # Setting this allows you to use `--seed` to deterministically reproduce
+ # test failures related to randomization by passing the same `--seed` value
+ # as the one that triggered the failure.
+ Kernel.srand config.seed
+=end
+end
diff --git a/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/x_auth_id_alias.gemspec b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/x_auth_id_alias.gemspec
new file mode 100644
index 0000000000000000000000000000000000000000..10d468d7757a79ce382419b9f0df38d416bf1814
--- /dev/null
+++ b/samples/openapi3/client/extensions/x-auth-id-alias/ruby-client/x_auth_id_alias.gemspec
@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+
+=begin
+#OpenAPI Extension x-auth-id-alias
+
+#This specification shows how to use x-auth-id-alias extension for API keys.
+
+The version of the OpenAPI document: 1.0.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 5.0.1-SNAPSHOT
+
+=end
+
+$:.push File.expand_path("../lib", __FILE__)
+require "x_auth_id_alias/version"
+
+Gem::Specification.new do |s|
+ s.name = "x_auth_id_alias"
+ s.version = XAuthIDAlias::VERSION
+ s.platform = Gem::Platform::RUBY
+ s.authors = ["OpenAPI-Generator"]
+ s.email = [""]
+ s.homepage = "https://openapi-generator.tech"
+ s.summary = "OpenAPI Extension x-auth-id-alias Ruby Gem"
+ s.description = "This specification shows how to use x-auth-id-alias extension for API keys."
+ s.license = "Unlicense"
+ s.required_ruby_version = ">= 2.4"
+
+ s.add_runtime_dependency 'typhoeus', '~> 1.0', '>= 1.0.1'
+
+ s.add_development_dependency 'rspec', '~> 3.6', '>= 3.6.0'
+
+ s.files = `find *`.split("\n").uniq.sort.select { |f| !f.empty? }
+ s.test_files = `find spec/*`.split("\n")
+ s.executables = []
+ s.require_paths = ["lib"]
+end
diff --git a/samples/openapi3/client/features/dynamic-servers/ruby/lib/dynamic_servers/api_client.rb b/samples/openapi3/client/features/dynamic-servers/ruby/lib/dynamic_servers/api_client.rb
index d98eebebd50e85a66d77763f950d2f162a3fea42..4504d8781886b6f0a0fccfb37c081be00c4d7798 100644
--- a/samples/openapi3/client/features/dynamic-servers/ruby/lib/dynamic_servers/api_client.rb
+++ b/samples/openapi3/client/features/dynamic-servers/ruby/lib/dynamic_servers/api_client.rb
@@ -307,7 +307,7 @@ module DynamicServers
case auth_setting[:in]
when 'header' then header_params[auth_setting[:key]] = auth_setting[:value]
when 'query' then query_params[auth_setting[:key]] = auth_setting[:value]
- else fail ArgumentError, 'Authentication token must be in `query` of `header`'
+ else fail ArgumentError, 'Authentication token must be in `query` or `header`'
end
end
end
diff --git a/samples/openapi3/client/features/dynamic-servers/ruby/lib/dynamic_servers/configuration.rb b/samples/openapi3/client/features/dynamic-servers/ruby/lib/dynamic_servers/configuration.rb
index 9a82693f0f2a301ecc2467a807ff8420e1ef0f01..46deb12617ecde6c9a7b59989f3cbbbf6e84468d 100644
--- a/samples/openapi3/client/features/dynamic-servers/ruby/lib/dynamic_servers/configuration.rb
+++ b/samples/openapi3/client/features/dynamic-servers/ruby/lib/dynamic_servers/configuration.rb
@@ -197,11 +197,13 @@ module DynamicServers
# Gets API key (with prefix if set).
# @param [String] param_name the parameter name of API key auth
- def api_key_with_prefix(param_name)
+ def api_key_with_prefix(param_name, param_alias = nil)
+ key = @api_key[param_name]
+ key = @api_key.fetch(param_alias, key) unless param_alias.nil?
if @api_key_prefix[param_name]
- "#{@api_key_prefix[param_name]} #{@api_key[param_name]}"
+ "#{@api_key_prefix[param_name]} #{key}"
else
- @api_key[param_name]
+ key
end
end
diff --git a/samples/openapi3/client/features/generate-alias-as-model/ruby-client/lib/petstore/api_client.rb b/samples/openapi3/client/features/generate-alias-as-model/ruby-client/lib/petstore/api_client.rb
index 8cdc763037905832dbcc7a3d2663f4aed6eb8e21..f88d96182a1e0d6ae4e0d50d18361f5c97d9c757 100644
--- a/samples/openapi3/client/features/generate-alias-as-model/ruby-client/lib/petstore/api_client.rb
+++ b/samples/openapi3/client/features/generate-alias-as-model/ruby-client/lib/petstore/api_client.rb
@@ -307,7 +307,7 @@ module Petstore
case auth_setting[:in]
when 'header' then header_params[auth_setting[:key]] = auth_setting[:value]
when 'query' then query_params[auth_setting[:key]] = auth_setting[:value]
- else fail ArgumentError, 'Authentication token must be in `query` of `header`'
+ else fail ArgumentError, 'Authentication token must be in `query` or `header`'
end
end
end
diff --git a/samples/openapi3/client/features/generate-alias-as-model/ruby-client/lib/petstore/configuration.rb b/samples/openapi3/client/features/generate-alias-as-model/ruby-client/lib/petstore/configuration.rb
index 587ccece09e5c989e4003951e891b3fcfe48f594..effc08965ac493beb5d28439aae1325aa72bfaae 100644
--- a/samples/openapi3/client/features/generate-alias-as-model/ruby-client/lib/petstore/configuration.rb
+++ b/samples/openapi3/client/features/generate-alias-as-model/ruby-client/lib/petstore/configuration.rb
@@ -197,11 +197,13 @@ module Petstore
# Gets API key (with prefix if set).
# @param [String] param_name the parameter name of API key auth
- def api_key_with_prefix(param_name)
+ def api_key_with_prefix(param_name, param_alias = nil)
+ key = @api_key[param_name]
+ key = @api_key.fetch(param_alias, key) unless param_alias.nil?
if @api_key_prefix[param_name]
- "#{@api_key_prefix[param_name]} #{@api_key[param_name]}"
+ "#{@api_key_prefix[param_name]} #{key}"
else
- @api_key[param_name]
+ key
end
end