loafle/openapi-generator
3
0
Fork 0
forked from loafle/openapi-generator-original
Code Pull Requests Activity

[Ruby] add useAutoload option to use autoload instead of require (#13153)

Browse Source 
* [Ruby] Use Ruby autoload to lower memory usage and load times

Fixes #12648

Requiring all models up front can be very expensive in both time and
memory if there are many models. In an example client with 6000 models,
this would consume nearly 400MB of memory and take about 7 seconds to
load. This is mostly unnecessary as most users of the client library
will only actually use a small percentage of the library.

The changes in this commit use Ruby's autoload capability to defer the
loading until the constant is actually used. In that same example client
with 6000 models, when initially requiring the library, the memory
usage dropped to ~20MB and loaded in 0.3 seconds. As the constants are
loaded on-demand, the memory would increase towards that 400MB ceiling,
but if only a few constants are actually used, then memory will never
actually hit that ceiling.

An additional side effect of using Ruby's autoload is that the order of
declaring the constants is not important, as Ruby will naturally load
them in the correct order when they are needed. Thus, this commit obviates
PR #9103 and fixes #4690.

* add option to use autoload in ruby client

* test ruby clients only

* add tests

* update samples

* Revert "test ruby clients only"

This reverts commit 0aaf71cd4cc5d266f824b261a4d312f07bd589e5.

* update doc

Co-authored-by: Jason Frey <fryguy9@gmail.com>
This commit is contained in:
William Cheng 2022-08-11 12:45:13 +08:00 committed by GitHub
parent 5662d6136f
commit c5a0374d2b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
194 changed files with 22735 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
bin/configs/ruby-autoload.yaml Normal file
View File

@ -0,0 +1,12 @@
generatorName: ruby
outputDir: samples/client/petstore/ruby-autoload
library: typhoeus
inputSpec: modules/openapi-generator/src/test/resources/3_0/petstore-with-fake-endpoints-models-for-testing.yaml
templateDir: modules/openapi-generator/src/main/resources/ruby-client
additionalProperties:
gemVersion: 1.0.0
moduleName: Petstore
gemName: petstore
skipFormModel: "true"
useAutoload: true
strictSpecBehavior: false

1
docs/generators/ruby.md
View File

@ -38,6 +38,7 @@ These options may be applied as additional-properties (cli) or configOptions (pl
|prependFormOrBodyParameters|Add form or body parameters to the beginning of the parameter list.| |false|
|sortModelPropertiesByRequiredFlag|Sort model properties to place required parameters before optional parameters.| |true|
|sortParamsByRequiredFlag|Sort method arguments to place required parameters before optional parameters.| |true|
|useAutoload|Use autoload instead of require to load modules.| |false|
## IMPORT MAPPING

15
modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/RubyClientCodegen.java
View File

@ -45,6 +45,7 @@ public class RubyClientCodegen extends AbstractRubyCodegen {
public static final String GEM_AUTHOR_EMAIL = "gemAuthorEmail";
public static final String FARADAY = "faraday";
public static final String TYPHOEUS = "typhoeus";
public static final String USE_AUTOLOAD = "useAutoload";
private final Logger LOGGER = LoggerFactory.getLogger(RubyClientCodegen.class);
private static final String NUMERIC_ENUM_PREFIX = "N";
protected static int emptyMethodNameCounter = 0;
@ -62,6 +63,7 @@ public class RubyClientCodegen extends AbstractRubyCodegen {
protected String gemAuthorEmail = "";
protected String apiDocPath = "docs/";
protected String modelDocPath = "docs/";
protected boolean useAutoload = false;
private Map<String, String> schemaKeyToModelNameCache = new HashMap<>();
@ -165,6 +167,9 @@ public class RubyClientCodegen extends AbstractRubyCodegen {
cliOptions.add(new CliOption(CodegenConstants.HIDE_GENERATION_TIMESTAMP, CodegenConstants.HIDE_GENERATION_TIMESTAMP_DESC).
defaultValue(Boolean.TRUE.toString()));
cliOptions.add(CliOption.newBoolean(USE_AUTOLOAD, "Use autoload instead of require to load modules.").
defaultValue(Boolean.FALSE.toString()));
supportedLibraries.put(FARADAY, "Faraday (https://github.com/lostisland/faraday) (Beta support)");
supportedLibraries.put(TYPHOEUS, "Typhoeus >= 1.0.1 (https://github.com/typhoeus/typhoeus)");
@ -234,6 +239,10 @@ public class RubyClientCodegen extends AbstractRubyCodegen {
setGemAuthorEmail((String) additionalProperties.get(GEM_AUTHOR_EMAIL));
}
if (additionalProperties.containsKey(USE_AUTOLOAD)) {
setUseAutoload(convertPropertyToBooleanAndWriteBack(USE_AUTOLOAD));
}
// make api and model doc path available in mustache template
additionalProperties.put("apiDocPath", apiDocPath);
additionalProperties.put("modelDocPath", modelDocPath);
@ -297,7 +306,6 @@ public class RubyClientCodegen extends AbstractRubyCodegen {
* Generate Ruby module name from the gem name, e.g. use "OpenAPIClient" for "openapi_client".
*
* @param gemName Ruby gem name
*
* @return Ruby module name
*/
@SuppressWarnings("static-method")
@ -309,7 +317,6 @@ public class RubyClientCodegen extends AbstractRubyCodegen {
* Generate Ruby gem name from the module name, e.g. use "openapi_client" for "OpenAPIClient".
*
* @param moduleName Ruby module name
*
* @return Ruby gem name
*/
@SuppressWarnings("static-method")
@ -583,6 +590,10 @@ public class RubyClientCodegen extends AbstractRubyCodegen {
this.gemAuthorEmail = gemAuthorEmail;
}
public void setUseAutoload(boolean useAutoload) {
this.useAutoload = useAutoload;
}
@Override
protected void addAdditionPropertiesToCodeGenModel(CodegenModel codegenModel, Schema schema) {
final Schema additionalProperties = getAdditionalProperties(schema);

14
modules/openapi-generator/src/main/resources/ruby-client/gem.mustache vendored
View File

@ -9,6 +9,7 @@ require '{{gemName}}/version'
require '{{gemName}}/configuration'
# Models
{{^useAutoload}}
{{#models}}
{{#model}}
{{^parent}}
@ -23,11 +24,24 @@ require '{{gemName}}/{{modelPackage}}/{{classFilename}}'
{{/parent}}
{{/model}}
{{/models}}
{{/useAutoload}}
{{#useAutoload}}
{{#models}}
{{#model}}
{{moduleName}}.autoload :{{classname}}, '{{gemName}}/{{modelPackage}}/{{classFilename}}'
{{/model}}
{{/models}}
{{/useAutoload}}
# APIs
{{#apiInfo}}
{{#apis}}
{{^useAutoload}}
require '{{importPath}}'
{{/useAutoload}}
{{#useAutoload}}
{{moduleName}}.autoload :{{classname}}, '{{importPath}}'
{{/useAutoload}}
{{/apis}}
{{/apiInfo}}

8
modules/openapi-generator/src/test/java/org/openapitools/codegen/options/RubyClientOptionsProvider.java
View File

@ -24,8 +24,8 @@ import org.openapitools.codegen.languages.RubyClientCodegen;
import java.util.Map;
public class RubyClientOptionsProvider implements OptionsProvider {
public static final String GEM_NAME_VALUE = "swagger_client_ruby";
public static final String MODULE_NAME_VALUE = "SwaggerClientRuby";
public static final String GEM_NAME_VALUE = "openapi_client_ruby";
public static final String MODULE_NAME_VALUE = "OpenApiClientRuby";
public static final String GEM_VERSION_VALUE = "1.0.0-SNAPSHOT";
public static final String SORT_PARAMS_VALUE = "false";
public static final String SORT_MODEL_PROPERTIES_VALUE = "false";
@ -35,12 +35,13 @@ public class RubyClientOptionsProvider implements OptionsProvider {
public static final String GEM_HOMEPAGE_VALUE = "homepage";
public static final String GEM_SUMMARY_VALUE = "summary";
public static final String GEM_DESCRIPTION_VALUE = "description";
public static final String GEM_AUTHOR_VALUE = "foo";
public static final String GEM_AUTHOR_VALUE = "foo";
public static final String GEM_AUTHOR_EMAIL_VALUE = "foo";
public static final String ALLOW_UNICODE_IDENTIFIERS_VALUE = "false";
public static final String PREPEND_FORM_OR_BODY_PARAMETERS_VALUE = "true";
public static final String LIBRARY = "typhoeus";
public static final String ENUM_UNKNOWN_DEFAULT_CASE_VALUE = "false";
public static final String USE_AUTOLOAD_VALUE = "true";
@Override
public String getLanguage() {
@ -70,6 +71,7 @@ public class RubyClientOptionsProvider implements OptionsProvider {
.put(CodegenConstants.LEGACY_DISCRIMINATOR_BEHAVIOR, "true")
.put(CodegenConstants.DISALLOW_ADDITIONAL_PROPERTIES_IF_NOT_PRESENT, "true")
.put(CodegenConstants.ENUM_UNKNOWN_DEFAULT_CASE, ENUM_UNKNOWN_DEFAULT_CASE_VALUE)
.put(RubyClientCodegen.USE_AUTOLOAD, USE_AUTOLOAD_VALUE)
.build();
}

1
modules/openapi-generator/src/test/java/org/openapitools/codegen/ruby/RubyClientOptionsTest.java
View File

@ -51,5 +51,6 @@ public class RubyClientOptionsTest extends AbstractOptionsTest {
verify(clientCodegen).setGemAuthor(RubyClientOptionsProvider.GEM_AUTHOR_VALUE);
verify(clientCodegen).setGemAuthorEmail(RubyClientOptionsProvider.GEM_AUTHOR_EMAIL_VALUE);
verify(clientCodegen).setEnumUnknownDefaultCase(Boolean.parseBoolean(RubyClientOptionsProvider.ENUM_UNKNOWN_DEFAULT_CASE_VALUE));
verify(clientCodegen).setUseAutoload(Boolean.parseBoolean(RubyClientOptionsProvider.USE_AUTOLOAD_VALUE));
}
}

1
pom.xml
View File

@ -1146,6 +1146,7 @@
<!--<module>samples/client/petstore/bash</module>-->
<module>samples/client/petstore/ruby-faraday</module>
<module>samples/client/petstore/ruby</module>
<module>samples/client/petstore/ruby-autoload</module>
<!-- comment out as it's not working as the moment
<module>samples/client/petstore/c</module>
-->

39
samples/client/petstore/ruby-autoload/.gitignore vendored Normal file
View File

@ -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

26
samples/client/petstore/ruby-autoload/.gitlab-ci.yml Normal file
View File

@ -0,0 +1,26 @@
.ruby: &ruby
variables:
LANG: "C.UTF-8"
before_script:
- ruby -v
- bundle config set --local deployment true
- bundle install -j $(nproc)
parallel:
matrix:
- RUBY_VERSION: ['2.3', '2.4', '2.5', '2.6', '2.7', '3.0']
image: "ruby:$RUBY_VERSION"
cache:
paths:
- vendor/ruby
key: 'ruby-$RUBY_VERSION'
gem:
extends: .ruby
script:
- bundle exec rspec
- bundle exec rake build
- bundle exec rake install
artifacts:
paths:
- pkg/*.gem

23
samples/client/petstore/ruby-autoload/.openapi-generator-ignore Normal file
View File

@ -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

128
samples/client/petstore/ruby-autoload/.openapi-generator/FILES Normal file
View File

@ -0,0 +1,128 @@
.gitignore
.gitlab-ci.yml
.rspec
.rubocop.yml
.travis.yml
Gemfile
README.md
Rakefile
docs/AdditionalPropertiesClass.md
docs/AllOfWithSingleRef.md
docs/Animal.md
docs/AnotherFakeApi.md
docs/ApiResponse.md
docs/ArrayOfArrayOfNumberOnly.md
docs/ArrayOfNumberOnly.md
docs/ArrayTest.md
docs/Capitalization.md
docs/Cat.md
docs/CatAllOf.md
docs/Category.md
docs/ClassModel.md
docs/Client.md
docs/DefaultApi.md
docs/DeprecatedObject.md
docs/Dog.md
docs/DogAllOf.md
docs/EnumArrays.md
docs/EnumClass.md
docs/EnumTest.md
docs/FakeApi.md
docs/FakeClassnameTags123Api.md
docs/File.md
docs/FileSchemaTestClass.md
docs/Foo.md
docs/FooGetDefaultResponse.md
docs/FormatTest.md
docs/HasOnlyReadOnly.md
docs/HealthCheckResult.md
docs/List.md
docs/MapTest.md
docs/MixedPropertiesAndAdditionalPropertiesClass.md
docs/Model200Response.md
docs/ModelReturn.md
docs/Name.md
docs/NullableClass.md
docs/NumberOnly.md
docs/ObjectWithDeprecatedFields.md
docs/Order.md
docs/OuterComposite.md
docs/OuterEnum.md
docs/OuterEnumDefaultValue.md
docs/OuterEnumInteger.md
docs/OuterEnumIntegerDefaultValue.md
docs/OuterObjectWithEnumProperty.md
docs/Pet.md
docs/PetApi.md
docs/ReadOnlyFirst.md
docs/SingleRefType.md
docs/SpecialModelName.md
docs/StoreApi.md
docs/Tag.md
docs/User.md
docs/UserApi.md
git_push.sh
lib/petstore.rb
lib/petstore/api/another_fake_api.rb
lib/petstore/api/default_api.rb
lib/petstore/api/fake_api.rb
lib/petstore/api/fake_classname_tags123_api.rb
lib/petstore/api/pet_api.rb
lib/petstore/api/store_api.rb
lib/petstore/api/user_api.rb
lib/petstore/api_client.rb
lib/petstore/api_error.rb
lib/petstore/configuration.rb
lib/petstore/models/additional_properties_class.rb
lib/petstore/models/all_of_with_single_ref.rb
lib/petstore/models/animal.rb
lib/petstore/models/api_response.rb
lib/petstore/models/array_of_array_of_number_only.rb
lib/petstore/models/array_of_number_only.rb
lib/petstore/models/array_test.rb
lib/petstore/models/capitalization.rb
lib/petstore/models/cat.rb
lib/petstore/models/cat_all_of.rb
lib/petstore/models/category.rb
lib/petstore/models/class_model.rb
lib/petstore/models/client.rb
lib/petstore/models/deprecated_object.rb
lib/petstore/models/dog.rb
lib/petstore/models/dog_all_of.rb
lib/petstore/models/enum_arrays.rb
lib/petstore/models/enum_class.rb
lib/petstore/models/enum_test.rb
lib/petstore/models/file.rb
lib/petstore/models/file_schema_test_class.rb
lib/petstore/models/foo.rb
lib/petstore/models/foo_get_default_response.rb
lib/petstore/models/format_test.rb
lib/petstore/models/has_only_read_only.rb
lib/petstore/models/health_check_result.rb
lib/petstore/models/list.rb
lib/petstore/models/map_test.rb
lib/petstore/models/mixed_properties_and_additional_properties_class.rb
lib/petstore/models/model200_response.rb
lib/petstore/models/model_return.rb
lib/petstore/models/name.rb
lib/petstore/models/nullable_class.rb
lib/petstore/models/number_only.rb
lib/petstore/models/object_with_deprecated_fields.rb
lib/petstore/models/order.rb
lib/petstore/models/outer_composite.rb
lib/petstore/models/outer_enum.rb
lib/petstore/models/outer_enum_default_value.rb
lib/petstore/models/outer_enum_integer.rb
lib/petstore/models/outer_enum_integer_default_value.rb
lib/petstore/models/outer_object_with_enum_property.rb
lib/petstore/models/pet.rb
lib/petstore/models/read_only_first.rb
lib/petstore/models/single_ref_type.rb
lib/petstore/models/special_model_name.rb
lib/petstore/models/tag.rb
lib/petstore/models/user.rb
lib/petstore/version.rb
petstore.gemspec
spec/api_client_spec.rb
spec/configuration_spec.rb
spec/spec_helper.rb

1
samples/client/petstore/ruby-autoload/.openapi-generator/VERSION Normal file
View File

@ -0,0 +1 @@
6.1.0-SNAPSHOT

2
samples/client/petstore/ruby-autoload/.rspec Normal file
View File

@ -0,0 +1,2 @@
--color
--require spec_helper

148
samples/client/petstore/ruby-autoload/.rubocop.yml Normal file
View File

@ -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

14
samples/client/petstore/ruby-autoload/.travis.yml Normal file
View File

@ -0,0 +1,14 @@
language: ruby
cache: bundler
rvm:
- 2.3
- 2.4
- 2.5
- 2.6
- 2.7
- 3.0
script:
- bundle install --path vendor/bundle
- bundle exec rspec
- gem build petstore.gemspec
- gem install ./petstore-1.0.0.gem

9
samples/client/petstore/ruby-autoload/Gemfile Normal file
View File

@ -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

210
samples/client/petstore/ruby-autoload/README.md Normal file
View File

@ -0,0 +1,210 @@
# petstore
Petstore - the Ruby gem for the OpenAPI Petstore
This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
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 petstore.gemspec
```
Then either install the gem locally:
```shell
gem install ./petstore-1.0.0.gem
```
(for development, run `gem install --dev ./petstore-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 'petstore', '~> 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 'petstore', :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 'petstore'
api_instance = Petstore::AnotherFakeApi.new
client = Petstore::Client.new # Client | client model
begin
#To test special tags
result = api_instance.call_123_test_special_tags(client)
p result
rescue Petstore::ApiError => e
puts "Exception when calling AnotherFakeApi->call_123_test_special_tags: #{e}"
end
```
## Documentation for API Endpoints
All URIs are relative to *http://petstore.swagger.io:80/v2*
Class | Method | HTTP request | Description
------------ | ------------- | ------------- | -------------
*Petstore::AnotherFakeApi* | [**call_123_test_special_tags**](docs/AnotherFakeApi.md#call_123_test_special_tags) | **PATCH** /another-fake/dummy | To test special tags
*Petstore::DefaultApi* | [**foo_get**](docs/DefaultApi.md#foo_get) | **GET** /foo |
*Petstore::FakeApi* | [**fake_health_get**](docs/FakeApi.md#fake_health_get) | **GET** /fake/health | Health check endpoint
*Petstore::FakeApi* | [**fake_http_signature_test**](docs/FakeApi.md#fake_http_signature_test) | **GET** /fake/http-signature-test | test http signature authentication
*Petstore::FakeApi* | [**fake_outer_boolean_serialize**](docs/FakeApi.md#fake_outer_boolean_serialize) | **POST** /fake/outer/boolean |
*Petstore::FakeApi* | [**fake_outer_composite_serialize**](docs/FakeApi.md#fake_outer_composite_serialize) | **POST** /fake/outer/composite |
*Petstore::FakeApi* | [**fake_outer_number_serialize**](docs/FakeApi.md#fake_outer_number_serialize) | **POST** /fake/outer/number |
*Petstore::FakeApi* | [**fake_outer_string_serialize**](docs/FakeApi.md#fake_outer_string_serialize) | **POST** /fake/outer/string |
*Petstore::FakeApi* | [**fake_property_enum_integer_serialize**](docs/FakeApi.md#fake_property_enum_integer_serialize) | **POST** /fake/property/enum-int |
*Petstore::FakeApi* | [**test_body_with_binary**](docs/FakeApi.md#test_body_with_binary) | **PUT** /fake/body-with-binary |
*Petstore::FakeApi* | [**test_body_with_file_schema**](docs/FakeApi.md#test_body_with_file_schema) | **PUT** /fake/body-with-file-schema |
*Petstore::FakeApi* | [**test_body_with_query_params**](docs/FakeApi.md#test_body_with_query_params) | **PUT** /fake/body-with-query-params |
*Petstore::FakeApi* | [**test_client_model**](docs/FakeApi.md#test_client_model) | **PATCH** /fake | To test \"client\" model
*Petstore::FakeApi* | [**test_endpoint_parameters**](docs/FakeApi.md#test_endpoint_parameters) | **POST** /fake | Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트
*Petstore::FakeApi* | [**test_enum_parameters**](docs/FakeApi.md#test_enum_parameters) | **GET** /fake | To test enum parameters
*Petstore::FakeApi* | [**test_group_parameters**](docs/FakeApi.md#test_group_parameters) | **DELETE** /fake | Fake endpoint to test group parameters (optional)
*Petstore::FakeApi* | [**test_inline_additional_properties**](docs/FakeApi.md#test_inline_additional_properties) | **POST** /fake/inline-additionalProperties | test inline additionalProperties
*Petstore::FakeApi* | [**test_json_form_data**](docs/FakeApi.md#test_json_form_data) | **GET** /fake/jsonFormData | test json serialization of form data
*Petstore::FakeApi* | [**test_query_parameter_collection_format**](docs/FakeApi.md#test_query_parameter_collection_format) | **PUT** /fake/test-query-parameters |
*Petstore::FakeClassnameTags123Api* | [**test_classname**](docs/FakeClassnameTags123Api.md#test_classname) | **PATCH** /fake_classname_test | To test class name in snake case
*Petstore::PetApi* | [**add_pet**](docs/PetApi.md#add_pet) | **POST** /pet | Add a new pet to the store
*Petstore::PetApi* | [**delete_pet**](docs/PetApi.md#delete_pet) | **DELETE** /pet/{petId} | Deletes a pet
*Petstore::PetApi* | [**find_pets_by_status**](docs/PetApi.md#find_pets_by_status) | **GET** /pet/findByStatus | Finds Pets by status
*Petstore::PetApi* | [**find_pets_by_tags**](docs/PetApi.md#find_pets_by_tags) | **GET** /pet/findByTags | Finds Pets by tags
*Petstore::PetApi* | [**get_pet_by_id**](docs/PetApi.md#get_pet_by_id) | **GET** /pet/{petId} | Find pet by ID
*Petstore::PetApi* | [**update_pet**](docs/PetApi.md#update_pet) | **PUT** /pet | Update an existing pet
*Petstore::PetApi* | [**update_pet_with_form**](docs/PetApi.md#update_pet_with_form) | **POST** /pet/{petId} | Updates a pet in the store with form data
*Petstore::PetApi* | [**upload_file**](docs/PetApi.md#upload_file) | **POST** /pet/{petId}/uploadImage | uploads an image
*Petstore::PetApi* | [**upload_file_with_required_file**](docs/PetApi.md#upload_file_with_required_file) | **POST** /fake/{petId}/uploadImageWithRequiredFile | uploads an image (required)
*Petstore::StoreApi* | [**delete_order**](docs/StoreApi.md#delete_order) | **DELETE** /store/order/{order_id} | Delete purchase order by ID
*Petstore::StoreApi* | [**get_inventory**](docs/StoreApi.md#get_inventory) | **GET** /store/inventory | Returns pet inventories by status
*Petstore::StoreApi* | [**get_order_by_id**](docs/StoreApi.md#get_order_by_id) | **GET** /store/order/{order_id} | Find purchase order by ID
*Petstore::StoreApi* | [**place_order**](docs/StoreApi.md#place_order) | **POST** /store/order | Place an order for a pet
*Petstore::UserApi* | [**create_user**](docs/UserApi.md#create_user) | **POST** /user | Create user
*Petstore::UserApi* | [**create_users_with_array_input**](docs/UserApi.md#create_users_with_array_input) | **POST** /user/createWithArray | Creates list of users with given input array
*Petstore::UserApi* | [**create_users_with_list_input**](docs/UserApi.md#create_users_with_list_input) | **POST** /user/createWithList | Creates list of users with given input array
*Petstore::UserApi* | [**delete_user**](docs/UserApi.md#delete_user) | **DELETE** /user/{username} | Delete user
*Petstore::UserApi* | [**get_user_by_name**](docs/UserApi.md#get_user_by_name) | **GET** /user/{username} | Get user by user name
*Petstore::UserApi* | [**login_user**](docs/UserApi.md#login_user) | **GET** /user/login | Logs user into the system
*Petstore::UserApi* | [**logout_user**](docs/UserApi.md#logout_user) | **GET** /user/logout | Logs out current logged in user session
*Petstore::UserApi* | [**update_user**](docs/UserApi.md#update_user) | **PUT** /user/{username} | Updated user
## Documentation for Models
- [Petstore::AdditionalPropertiesClass](docs/AdditionalPropertiesClass.md)
- [Petstore::AllOfWithSingleRef](docs/AllOfWithSingleRef.md)
- [Petstore::Animal](docs/Animal.md)
- [Petstore::ApiResponse](docs/ApiResponse.md)
- [Petstore::ArrayOfArrayOfNumberOnly](docs/ArrayOfArrayOfNumberOnly.md)
- [Petstore::ArrayOfNumberOnly](docs/ArrayOfNumberOnly.md)
- [Petstore::ArrayTest](docs/ArrayTest.md)
- [Petstore::Capitalization](docs/Capitalization.md)
- [Petstore::Cat](docs/Cat.md)
- [Petstore::CatAllOf](docs/CatAllOf.md)
- [Petstore::Category](docs/Category.md)
- [Petstore::ClassModel](docs/ClassModel.md)
- [Petstore::Client](docs/Client.md)
- [Petstore::DeprecatedObject](docs/DeprecatedObject.md)
- [Petstore::Dog](docs/Dog.md)
- [Petstore::DogAllOf](docs/DogAllOf.md)
- [Petstore::EnumArrays](docs/EnumArrays.md)
- [Petstore::EnumClass](docs/EnumClass.md)
- [Petstore::EnumTest](docs/EnumTest.md)
- [Petstore::File](docs/File.md)
- [Petstore::FileSchemaTestClass](docs/FileSchemaTestClass.md)
- [Petstore::Foo](docs/Foo.md)
- [Petstore::FooGetDefaultResponse](docs/FooGetDefaultResponse.md)
- [Petstore::FormatTest](docs/FormatTest.md)
- [Petstore::HasOnlyReadOnly](docs/HasOnlyReadOnly.md)
- [Petstore::HealthCheckResult](docs/HealthCheckResult.md)
- [Petstore::List](docs/List.md)
- [Petstore::MapTest](docs/MapTest.md)
- [Petstore::MixedPropertiesAndAdditionalPropertiesClass](docs/MixedPropertiesAndAdditionalPropertiesClass.md)
- [Petstore::Model200Response](docs/Model200Response.md)
- [Petstore::ModelReturn](docs/ModelReturn.md)
- [Petstore::Name](docs/Name.md)
- [Petstore::NullableClass](docs/NullableClass.md)
- [Petstore::NumberOnly](docs/NumberOnly.md)
- [Petstore::ObjectWithDeprecatedFields](docs/ObjectWithDeprecatedFields.md)
- [Petstore::Order](docs/Order.md)
- [Petstore::OuterComposite](docs/OuterComposite.md)
- [Petstore::OuterEnum](docs/OuterEnum.md)
- [Petstore::OuterEnumDefaultValue](docs/OuterEnumDefaultValue.md)
- [Petstore::OuterEnumInteger](docs/OuterEnumInteger.md)
- [Petstore::OuterEnumIntegerDefaultValue](docs/OuterEnumIntegerDefaultValue.md)
- [Petstore::OuterObjectWithEnumProperty](docs/OuterObjectWithEnumProperty.md)
- [Petstore::Pet](docs/Pet.md)
- [Petstore::ReadOnlyFirst](docs/ReadOnlyFirst.md)
- [Petstore::SingleRefType](docs/SingleRefType.md)
- [Petstore::SpecialModelName](docs/SpecialModelName.md)
- [Petstore::Tag](docs/Tag.md)
- [Petstore::User](docs/User.md)
## Documentation for Authorization
### api_key
- **Type**: API key
- **API key parameter name**: api_key
- **Location**: HTTP header
### api_key_query
- **Type**: API key
- **API key parameter name**: api_key_query
- **Location**: URL query string
### bearer_test
- **Type**: Bearer authentication (JWT)
### http_basic_test
- **Type**: HTTP basic authentication
### http_signature_test
### petstore_auth
- **Type**: OAuth
- **Flow**: implicit
- **Authorization URL**: http://petstore.swagger.io/api/oauth/dialog
- **Scopes**:
- write:pets: modify pets in your account
- read:pets: read your pets

10
samples/client/petstore/ruby-autoload/Rakefile Normal file
View File

@ -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

20
samples/client/petstore/ruby-autoload/docs/AdditionalPropertiesClass.md Normal file
View File

@ -0,0 +1,20 @@
# Petstore::AdditionalPropertiesClass
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **map_property** | **Hash&lt;String, String&gt;** | | [optional] |
| **map_of_map_property** | **Hash&lt;String, Hash&lt;String, String&gt;&gt;** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::AdditionalPropertiesClass.new(
map_property: null,
map_of_map_property: null
)
```

20
samples/client/petstore/ruby-autoload/docs/AllOfWithSingleRef.md Normal file
View File

@ -0,0 +1,20 @@
# Petstore::AllOfWithSingleRef
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **username** | **String** | | [optional] |
| **single_ref_type** | [**SingleRefType**](SingleRefType.md) | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::AllOfWithSingleRef.new(
username: null,
single_ref_type: null
)
```

20
samples/client/petstore/ruby-autoload/docs/Animal.md Normal file
View File

@ -0,0 +1,20 @@
# Petstore::Animal
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **class_name** | **String** | | |
| **color** | **String** | | [optional][default to &#39;red&#39;] |
## Example
```ruby
require 'petstore'
instance = Petstore::Animal.new(
class_name: null,
color: null
)
```

72
samples/client/petstore/ruby-autoload/docs/AnotherFakeApi.md Normal file
View File

@ -0,0 +1,72 @@
# Petstore::AnotherFakeApi
All URIs are relative to *http://petstore.swagger.io:80/v2*
| Method | HTTP request | Description |
| ------ | ------------ | ----------- |
| [**call_123_test_special_tags**](AnotherFakeApi.md#call_123_test_special_tags) | **PATCH** /another-fake/dummy | To test special tags |
## call_123_test_special_tags
> <Client> call_123_test_special_tags(client)
To test special tags
To test special tags and operation ID starting with number
### Examples
```ruby
require 'time'
require 'petstore'
api_instance = Petstore::AnotherFakeApi.new
client = Petstore::Client.new # Client | client model
begin
# To test special tags
result = api_instance.call_123_test_special_tags(client)
p result
rescue Petstore::ApiError => e
puts "Error when calling AnotherFakeApi->call_123_test_special_tags: #{e}"
end
```
#### Using the call_123_test_special_tags_with_http_info variant
This returns an Array which contains the response data, status code and headers.
> <Array(<Client>, Integer, Hash)> call_123_test_special_tags_with_http_info(client)
```ruby
begin
# To test special tags
data, status_code, headers = api_instance.call_123_test_special_tags_with_http_info(client)
p status_code # => 2xx
p headers # => { ... }
p data # => <Client>
rescue Petstore::ApiError => e
puts "Error when calling AnotherFakeApi->call_123_test_special_tags_with_http_info: #{e}"
end
```
### Parameters
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **client** | [**Client**](Client.md) | client model | |
### Return type
[**Client**](Client.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: application/json
- **Accept**: application/json

22
samples/client/petstore/ruby-autoload/docs/ApiResponse.md Normal file
View File

@ -0,0 +1,22 @@
# Petstore::ApiResponse
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **code** | **Integer** | | [optional] |
| **type** | **String** | | [optional] |
| **message** | **String** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::ApiResponse.new(
code: null,
type: null,
message: null
)
```

18
samples/client/petstore/ruby-autoload/docs/ArrayOfArrayOfNumberOnly.md Normal file
View File

@ -0,0 +1,18 @@
# Petstore::ArrayOfArrayOfNumberOnly
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **array_array_number** | **Array&lt;Array&lt;Float&gt;&gt;** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::ArrayOfArrayOfNumberOnly.new(
array_array_number: null
)
```

18
samples/client/petstore/ruby-autoload/docs/ArrayOfNumberOnly.md Normal file
View File

@ -0,0 +1,18 @@
# Petstore::ArrayOfNumberOnly
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **array_number** | **Array&lt;Float&gt;** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::ArrayOfNumberOnly.new(
array_number: null
)
```

22
samples/client/petstore/ruby-autoload/docs/ArrayTest.md Normal file
View File

@ -0,0 +1,22 @@
# Petstore::ArrayTest
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **array_of_string** | **Array&lt;String&gt;** | | [optional] |
| **array_array_of_integer** | **Array&lt;Array&lt;Integer&gt;&gt;** | | [optional] |
| **array_array_of_model** | **Array&lt;Array&lt;ReadOnlyFirst&gt;&gt;** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::ArrayTest.new(
array_of_string: null,
array_array_of_integer: null,
array_array_of_model: null
)
```

28
samples/client/petstore/ruby-autoload/docs/Capitalization.md Normal file
View File

@ -0,0 +1,28 @@
# Petstore::Capitalization
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **small_camel** | **String** | | [optional] |
| **capital_camel** | **String** | | [optional] |
| **small_snake** | **String** | | [optional] |
| **capital_snake** | **String** | | [optional] |
| **sca_eth_flow_points** | **String** | | [optional] |
| **att_name** | **String** | Name of the pet | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::Capitalization.new(
small_camel: null,
capital_camel: null,
small_snake: null,
capital_snake: null,
sca_eth_flow_points: null,
att_name: null
)
```

18
samples/client/petstore/ruby-autoload/docs/Cat.md Normal file
View File

@ -0,0 +1,18 @@
# Petstore::Cat
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **declawed** | **Boolean** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::Cat.new(
declawed: null
)
```

18
samples/client/petstore/ruby-autoload/docs/CatAllOf.md Normal file
View File

@ -0,0 +1,18 @@
# Petstore::CatAllOf
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **declawed** | **Boolean** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::CatAllOf.new(
declawed: null
)
```

20
samples/client/petstore/ruby-autoload/docs/Category.md Normal file
View File

@ -0,0 +1,20 @@
# Petstore::Category
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **id** | **Integer** | | [optional] |
| **name** | **String** | | [default to &#39;default-name&#39;] |
## Example
```ruby
require 'petstore'
instance = Petstore::Category.new(
id: null,
name: null
)
```

18
samples/client/petstore/ruby-autoload/docs/ClassModel.md Normal file
View File

@ -0,0 +1,18 @@
# Petstore::ClassModel
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **_class** | **String** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::ClassModel.new(
_class: null
)
```

18
samples/client/petstore/ruby-autoload/docs/Client.md Normal file
View File

@ -0,0 +1,18 @@
# Petstore::Client
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **client** | **String** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::Client.new(
client: null
)
```

67
samples/client/petstore/ruby-autoload/docs/DefaultApi.md Normal file
View File

@ -0,0 +1,67 @@
# Petstore::DefaultApi
All URIs are relative to *http://petstore.swagger.io:80/v2*
| Method | HTTP request | Description |
| ------ | ------------ | ----------- |
| [**foo_get**](DefaultApi.md#foo_get) | **GET** /foo | |
## foo_get
> <FooGetDefaultResponse> foo_get
### Examples
```ruby
require 'time'
require 'petstore'
api_instance = Petstore::DefaultApi.new
begin
result = api_instance.foo_get
p result
rescue Petstore::ApiError => e
puts "Error when calling DefaultApi->foo_get: #{e}"
end
```
#### Using the foo_get_with_http_info variant
This returns an Array which contains the response data, status code and headers.
> <Array(<FooGetDefaultResponse>, Integer, Hash)> foo_get_with_http_info
```ruby
begin
data, status_code, headers = api_instance.foo_get_with_http_info
p status_code # => 2xx
p headers # => { ... }
p data # => <FooGetDefaultResponse>
rescue Petstore::ApiError => e
puts "Error when calling DefaultApi->foo_get_with_http_info: #{e}"
end
```
### Parameters
This endpoint does not need any parameter.
### Return type
[**FooGetDefaultResponse**](FooGetDefaultResponse.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json

18
samples/client/petstore/ruby-autoload/docs/DeprecatedObject.md Normal file
View File

@ -0,0 +1,18 @@
# Petstore::DeprecatedObject
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **name** | **String** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::DeprecatedObject.new(
name: null
)
```

18
samples/client/petstore/ruby-autoload/docs/Dog.md Normal file
View File

@ -0,0 +1,18 @@
# Petstore::Dog
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **breed** | **String** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::Dog.new(
breed: null
)
```

18
samples/client/petstore/ruby-autoload/docs/DogAllOf.md Normal file
View File

@ -0,0 +1,18 @@
# Petstore::DogAllOf
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **breed** | **String** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::DogAllOf.new(
breed: null
)
```

20
samples/client/petstore/ruby-autoload/docs/EnumArrays.md Normal file
View File

@ -0,0 +1,20 @@
# Petstore::EnumArrays
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **just_symbol** | **String** | | [optional] |
| **array_enum** | **Array&lt;String&gt;** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::EnumArrays.new(
just_symbol: null,
array_enum: null
)
```

15
samples/client/petstore/ruby-autoload/docs/EnumClass.md Normal file
View File

@ -0,0 +1,15 @@
# Petstore::EnumClass
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
## Example
```ruby
require 'petstore'
instance = Petstore::EnumClass.new()
```

32
samples/client/petstore/ruby-autoload/docs/EnumTest.md Normal file
View File

@ -0,0 +1,32 @@
# Petstore::EnumTest
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **enum_string** | **String** | | [optional] |
| **enum_string_required** | **String** | | |
| **enum_integer** | **Integer** | | [optional] |
| **enum_number** | **Float** | | [optional] |
| **outer_enum** | [**OuterEnum**](OuterEnum.md) | | [optional] |
| **outer_enum_integer** | [**OuterEnumInteger**](OuterEnumInteger.md) | | [optional] |
| **outer_enum_default_value** | [**OuterEnumDefaultValue**](OuterEnumDefaultValue.md) | | [optional][default to &#39;placed&#39;] |
| **outer_enum_integer_default_value** | [**OuterEnumIntegerDefaultValue**](OuterEnumIntegerDefaultValue.md) | | [optional][default to OuterEnumIntegerDefaultValue::N0] |
## Example
```ruby
require 'petstore'
instance = Petstore::EnumTest.new(
enum_string: null,
enum_string_required: null,
enum_integer: null,
enum_number: null,
outer_enum: null,
outer_enum_integer: null,
outer_enum_default_value: null,
outer_enum_integer_default_value: null
)
```

1197
samples/client/petstore/ruby-autoload/docs/FakeApi.md Normal file
View File

File diff suppressed because it is too large Load Diff

79
samples/client/petstore/ruby-autoload/docs/FakeClassnameTags123Api.md Normal file
View File

@ -0,0 +1,79 @@
# Petstore::FakeClassnameTags123Api
All URIs are relative to *http://petstore.swagger.io:80/v2*
| Method | HTTP request | Description |
| ------ | ------------ | ----------- |
| [**test_classname**](FakeClassnameTags123Api.md#test_classname) | **PATCH** /fake_classname_test | To test class name in snake case |
## test_classname
> <Client> test_classname(client)
To test class name in snake case
To test class name in snake case
### Examples
```ruby
require 'time'
require 'petstore'
# setup authorization
Petstore.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 = Petstore::FakeClassnameTags123Api.new
client = Petstore::Client.new # Client | client model
begin
# To test class name in snake case
result = api_instance.test_classname(client)
p result
rescue Petstore::ApiError => e
puts "Error when calling FakeClassnameTags123Api->test_classname: #{e}"
end
```
#### Using the test_classname_with_http_info variant
This returns an Array which contains the response data, status code and headers.
> <Array(<Client>, Integer, Hash)> test_classname_with_http_info(client)
```ruby
begin
# To test class name in snake case
data, status_code, headers = api_instance.test_classname_with_http_info(client)
p status_code # => 2xx
p headers # => { ... }
p data # => <Client>
rescue Petstore::ApiError => e
puts "Error when calling FakeClassnameTags123Api->test_classname_with_http_info: #{e}"
end
```
### Parameters
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **client** | [**Client**](Client.md) | client model | |
### Return type
[**Client**](Client.md)
### Authorization
[api_key_query](../README.md#api_key_query)
### HTTP request headers
- **Content-Type**: application/json
- **Accept**: application/json

18
samples/client/petstore/ruby-autoload/docs/File.md Normal file
View File

@ -0,0 +1,18 @@
# Petstore::File
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **source_uri** | **String** | Test capitalization | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::File.new(
source_uri: null
)
```

20
samples/client/petstore/ruby-autoload/docs/FileSchemaTestClass.md Normal file
View File

@ -0,0 +1,20 @@
# Petstore::FileSchemaTestClass
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **file** | **File** | | [optional] |
| **files** | **Array&lt;File&gt;** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::FileSchemaTestClass.new(
file: null,
files: null
)
```

18
samples/client/petstore/ruby-autoload/docs/Foo.md Normal file
View File

@ -0,0 +1,18 @@
# Petstore::Foo
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **bar** | **String** | | [optional][default to &#39;bar&#39;] |
## Example
```ruby
require 'petstore'
instance = Petstore::Foo.new(
bar: null
)
```

18
samples/client/petstore/ruby-autoload/docs/FooGetDefaultResponse.md Normal file
View File

@ -0,0 +1,18 @@
# Petstore::FooGetDefaultResponse
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **string** | [**Foo**](Foo.md) | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::FooGetDefaultResponse.new(
string: null
)
```

48
samples/client/petstore/ruby-autoload/docs/FormatTest.md Normal file
View File

@ -0,0 +1,48 @@
# Petstore::FormatTest
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **integer** | **Integer** | | [optional] |
| **int32** | **Integer** | | [optional] |
| **int64** | **Integer** | | [optional] |
| **number** | **Float** | | |
| **float** | **Float** | | [optional] |
| **double** | **Float** | | [optional] |
| **decimal** | **Float** | | [optional] |
| **string** | **String** | | [optional] |
| **byte** | **String** | | |
| **binary** | **File** | | [optional] |
| **date** | **Date** | | |
| **date_time** | **Time** | | [optional] |
| **uuid** | **String** | | [optional] |
| **password** | **String** | | |
| **pattern_with_digits** | **String** | A string that is a 10 digit number. Can have leading zeros. | [optional] |
| **pattern_with_digits_and_delimiter** | **String** | A string starting with &#39;image_&#39; (case insensitive) and one to three digits following i.e. Image_01. | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::FormatTest.new(
integer: null,
int32: null,
int64: null,
number: null,
float: null,
double: null,
decimal: null,
string: null,
byte: null,
binary: null,
date: null,
date_time: null,
uuid: 72f98069-206d-4f12-9f12-3d1e525a8e84,
password: null,
pattern_with_digits: null,
pattern_with_digits_and_delimiter: null
)
```

20
samples/client/petstore/ruby-autoload/docs/HasOnlyReadOnly.md Normal file
View File

@ -0,0 +1,20 @@
# Petstore::HasOnlyReadOnly
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **bar** | **String** | | [optional][readonly] |
| **foo** | **String** | | [optional][readonly] |
## Example
```ruby
require 'petstore'
instance = Petstore::HasOnlyReadOnly.new(
bar: null,
foo: null
)
```

18
samples/client/petstore/ruby-autoload/docs/HealthCheckResult.md Normal file
View File

@ -0,0 +1,18 @@
# Petstore::HealthCheckResult
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **nullable_message** | **String** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::HealthCheckResult.new(
nullable_message: null
)
```

18
samples/client/petstore/ruby-autoload/docs/List.md Normal file
View File

@ -0,0 +1,18 @@
# Petstore::List
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **_123_list** | **String** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::List.new(
_123_list: null
)
```

24
samples/client/petstore/ruby-autoload/docs/MapTest.md Normal file
View File

@ -0,0 +1,24 @@
# Petstore::MapTest
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **map_map_of_string** | **Hash&lt;String, Hash&lt;String, String&gt;&gt;** | | [optional] |
| **map_of_enum_string** | **Hash&lt;String, String&gt;** | | [optional] |
| **direct_map** | **Hash&lt;String, Boolean&gt;** | | [optional] |
| **indirect_map** | **Hash&lt;String, Boolean&gt;** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::MapTest.new(
map_map_of_string: null,
map_of_enum_string: null,
direct_map: null,
indirect_map: null
)
```

22
samples/client/petstore/ruby-autoload/docs/MixedPropertiesAndAdditionalPropertiesClass.md Normal file
View File

@ -0,0 +1,22 @@
# Petstore::MixedPropertiesAndAdditionalPropertiesClass
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **uuid** | **String** | | [optional] |
| **date_time** | **Time** | | [optional] |
| **map** | [**Hash&lt;String, Animal&gt;**](Animal.md) | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::MixedPropertiesAndAdditionalPropertiesClass.new(
uuid: null,
date_time: null,
map: null
)
```

20
samples/client/petstore/ruby-autoload/docs/Model200Response.md Normal file
View File

@ -0,0 +1,20 @@
# Petstore::Model200Response
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **name** | **Integer** | | [optional] |
| **_class** | **String** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::Model200Response.new(
name: null,
_class: null
)
```

18
samples/client/petstore/ruby-autoload/docs/ModelReturn.md Normal file
View File

@ -0,0 +1,18 @@
# Petstore::ModelReturn
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **_return** | **Integer** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::ModelReturn.new(
_return: null
)
```

24
samples/client/petstore/ruby-autoload/docs/Name.md Normal file
View File

@ -0,0 +1,24 @@
# Petstore::Name
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **name** | **Integer** | | |
| **snake_case** | **Integer** | | [optional][readonly] |
| **property** | **String** | | [optional] |
| **_123_number** | **Integer** | | [optional][readonly] |
## Example
```ruby
require 'petstore'
instance = Petstore::Name.new(
name: null,
snake_case: null,
property: null,
_123_number: null
)
```

40
samples/client/petstore/ruby-autoload/docs/NullableClass.md Normal file
View File

@ -0,0 +1,40 @@
# Petstore::NullableClass
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **integer_prop** | **Integer** | | [optional] |
| **number_prop** | **Float** | | [optional] |
| **boolean_prop** | **Boolean** | | [optional] |
| **string_prop** | **String** | | [optional] |
| **date_prop** | **Date** | | [optional] |
| **datetime_prop** | **Time** | | [optional] |
| **array_nullable_prop** | **Array&lt;Object&gt;** | | [optional] |
| **array_and_items_nullable_prop** | **Array&lt;Object&gt;** | | [optional] |
| **array_items_nullable** | **Array&lt;Object&gt;** | | [optional] |
| **object_nullable_prop** | **Hash&lt;String, Object&gt;** | | [optional] |
| **object_and_items_nullable_prop** | **Hash&lt;String, Object&gt;** | | [optional] |
| **object_items_nullable** | **Hash&lt;String, Object&gt;** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::NullableClass.new(
integer_prop: null,
number_prop: null,
boolean_prop: null,
string_prop: null,
date_prop: null,
datetime_prop: null,
array_nullable_prop: null,
array_and_items_nullable_prop: null,
array_items_nullable: null,
object_nullable_prop: null,
object_and_items_nullable_prop: null,
object_items_nullable: null
)
```

18
samples/client/petstore/ruby-autoload/docs/NumberOnly.md Normal file
View File

@ -0,0 +1,18 @@
# Petstore::NumberOnly
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **just_number** | **Float** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::NumberOnly.new(
just_number: null
)
```

24
samples/client/petstore/ruby-autoload/docs/ObjectWithDeprecatedFields.md Normal file
View File

@ -0,0 +1,24 @@
# Petstore::ObjectWithDeprecatedFields
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **uuid** | **String** | | [optional] |
| **id** | **Float** | | [optional] |
| **deprecated_ref** | [**DeprecatedObject**](DeprecatedObject.md) | | [optional] |
| **bars** | **Array&lt;String&gt;** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::ObjectWithDeprecatedFields.new(
uuid: null,
id: null,
deprecated_ref: null,
bars: null
)
```

28
samples/client/petstore/ruby-autoload/docs/Order.md Normal file
View File

@ -0,0 +1,28 @@
# Petstore::Order
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **id** | **Integer** | | [optional] |
| **pet_id** | **Integer** | | [optional] |
| **quantity** | **Integer** | | [optional] |
| **ship_date** | **Time** | | [optional] |
| **status** | **String** | Order Status | [optional] |
| **complete** | **Boolean** | | [optional][default to false] |
## Example
```ruby
require 'petstore'
instance = Petstore::Order.new(
id: null,
pet_id: null,
quantity: null,
ship_date: null,
status: null,
complete: null
)
```

22
samples/client/petstore/ruby-autoload/docs/OuterComposite.md Normal file
View File

@ -0,0 +1,22 @@
# Petstore::OuterComposite
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **my_number** | **Float** | | [optional] |
| **my_string** | **String** | | [optional] |
| **my_boolean** | **Boolean** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::OuterComposite.new(
my_number: null,
my_string: null,
my_boolean: null
)
```

15
samples/client/petstore/ruby-autoload/docs/OuterEnum.md Normal file
View File

@ -0,0 +1,15 @@
# Petstore::OuterEnum
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
## Example
```ruby
require 'petstore'
instance = Petstore::OuterEnum.new()
```

15
samples/client/petstore/ruby-autoload/docs/OuterEnumDefaultValue.md Normal file
View File

@ -0,0 +1,15 @@
# Petstore::OuterEnumDefaultValue
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
## Example
```ruby
require 'petstore'
instance = Petstore::OuterEnumDefaultValue.new()
```

15
samples/client/petstore/ruby-autoload/docs/OuterEnumInteger.md Normal file
View File

@ -0,0 +1,15 @@
# Petstore::OuterEnumInteger
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
## Example
```ruby
require 'petstore'
instance = Petstore::OuterEnumInteger.new()
```

15
samples/client/petstore/ruby-autoload/docs/OuterEnumIntegerDefaultValue.md Normal file
View File

@ -0,0 +1,15 @@
# Petstore::OuterEnumIntegerDefaultValue
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
## Example
```ruby
require 'petstore'
instance = Petstore::OuterEnumIntegerDefaultValue.new()
```

18
samples/client/petstore/ruby-autoload/docs/OuterObjectWithEnumProperty.md Normal file
View File

@ -0,0 +1,18 @@
# Petstore::OuterObjectWithEnumProperty
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **value** | [**OuterEnumInteger**](OuterEnumInteger.md) | | |
## Example
```ruby
require 'petstore'
instance = Petstore::OuterObjectWithEnumProperty.new(
value: null
)
```

28
samples/client/petstore/ruby-autoload/docs/Pet.md Normal file
View File

@ -0,0 +1,28 @@
# Petstore::Pet
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **id** | **Integer** | | [optional] |
| **category** | [**Category**](Category.md) | | [optional] |
| **name** | **String** | | |
| **photo_urls** | **Array&lt;String&gt;** | | |
| **tags** | [**Array&lt;Tag&gt;**](Tag.md) | | [optional] |
| **status** | **String** | pet status in the store | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::Pet.new(
id: null,
category: null,
name: doggie,
photo_urls: null,
tags: null,
status: null
)
```

657
samples/client/petstore/ruby-autoload/docs/PetApi.md Normal file
View File

@ -0,0 +1,657 @@
# Petstore::PetApi
All URIs are relative to *http://petstore.swagger.io:80/v2*
| Method | HTTP request | Description |
| ------ | ------------ | ----------- |
| [**add_pet**](PetApi.md#add_pet) | **POST** /pet | Add a new pet to the store |
| [**delete_pet**](PetApi.md#delete_pet) | **DELETE** /pet/{petId} | Deletes a pet |
| [**find_pets_by_status**](PetApi.md#find_pets_by_status) | **GET** /pet/findByStatus | Finds Pets by status |
| [**find_pets_by_tags**](PetApi.md#find_pets_by_tags) | **GET** /pet/findByTags | Finds Pets by tags |
| [**get_pet_by_id**](PetApi.md#get_pet_by_id) | **GET** /pet/{petId} | Find pet by ID |
| [**update_pet**](PetApi.md#update_pet) | **PUT** /pet | Update an existing pet |
| [**update_pet_with_form**](PetApi.md#update_pet_with_form) | **POST** /pet/{petId} | Updates a pet in the store with form data |
| [**upload_file**](PetApi.md#upload_file) | **POST** /pet/{petId}/uploadImage | uploads an image |
| [**upload_file_with_required_file**](PetApi.md#upload_file_with_required_file) | **POST** /fake/{petId}/uploadImageWithRequiredFile | uploads an image (required) |
## add_pet
> add_pet(pet)
Add a new pet to the store
### Examples
```ruby
require 'time'
require 'petstore'
# setup authorization
Petstore.configure do |config|
# Configure OAuth2 access token for authorization: petstore_auth
config.access_token = 'YOUR ACCESS TOKEN'
end
api_instance = Petstore::PetApi.new
pet = Petstore::Pet.new({name: 'doggie', photo_urls: ['photo_urls_example']}) # Pet | Pet object that needs to be added to the store
begin
# Add a new pet to the store
api_instance.add_pet(pet)
rescue Petstore::ApiError => e
puts "Error when calling PetApi->add_pet: #{e}"
end
```
#### Using the add_pet_with_http_info variant
This returns an Array which contains the response data (`nil` in this case), status code and headers.
> <Array(nil, Integer, Hash)> add_pet_with_http_info(pet)
```ruby
begin
# Add a new pet to the store
data, status_code, headers = api_instance.add_pet_with_http_info(pet)
p status_code # => 2xx
p headers # => { ... }
p data # => nil
rescue Petstore::ApiError => e
puts "Error when calling PetApi->add_pet_with_http_info: #{e}"
end
```
### Parameters
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **pet** | [**Pet**](Pet.md) | Pet object that needs to be added to the store | |
### Return type
nil (empty response body)
### Authorization
[petstore_auth](../README.md#petstore_auth)
### HTTP request headers
- **Content-Type**: application/json, application/xml
- **Accept**: Not defined
## delete_pet
> delete_pet(pet_id, opts)
Deletes a pet
### Examples
```ruby
require 'time'
require 'petstore'
# setup authorization
Petstore.configure do |config|
# Configure OAuth2 access token for authorization: petstore_auth
config.access_token = 'YOUR ACCESS TOKEN'
end
api_instance = Petstore::PetApi.new
pet_id = 789 # Integer | Pet id to delete
opts = {
api_key: 'api_key_example' # String |
}
begin
# Deletes a pet
api_instance.delete_pet(pet_id, opts)
rescue Petstore::ApiError => e
puts "Error when calling PetApi->delete_pet: #{e}"
end
```
#### Using the delete_pet_with_http_info variant
This returns an Array which contains the response data (`nil` in this case), status code and headers.
> <Array(nil, Integer, Hash)> delete_pet_with_http_info(pet_id, opts)
```ruby
begin
# Deletes a pet
data, status_code, headers = api_instance.delete_pet_with_http_info(pet_id, opts)
p status_code # => 2xx
p headers # => { ... }
p data # => nil
rescue Petstore::ApiError => e
puts "Error when calling PetApi->delete_pet_with_http_info: #{e}"
end
```
### Parameters
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **pet_id** | **Integer** | Pet id to delete | |
| **api_key** | **String** | | [optional] |
### Return type
nil (empty response body)
### Authorization
[petstore_auth](../README.md#petstore_auth)
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: Not defined
## find_pets_by_status
> <Array<Pet>> find_pets_by_status(status)
Finds Pets by status
Multiple status values can be provided with comma separated strings
### Examples
```ruby
require 'time'
require 'petstore'
# setup authorization
Petstore.configure do |config|
# Configure OAuth2 access token for authorization: petstore_auth
config.access_token = 'YOUR ACCESS TOKEN'
end
api_instance = Petstore::PetApi.new
status = ['available'] # Array<String> | Status values that need to be considered for filter
begin
# Finds Pets by status
result = api_instance.find_pets_by_status(status)
p result
rescue Petstore::ApiError => e
puts "Error when calling PetApi->find_pets_by_status: #{e}"
end
```
#### Using the find_pets_by_status_with_http_info variant
This returns an Array which contains the response data, status code and headers.
> <Array(<Array<Pet>>, Integer, Hash)> find_pets_by_status_with_http_info(status)
```ruby
begin
# Finds Pets by status
data, status_code, headers = api_instance.find_pets_by_status_with_http_info(status)
p status_code # => 2xx
p headers # => { ... }
p data # => <Array<Pet>>
rescue Petstore::ApiError => e
puts "Error when calling PetApi->find_pets_by_status_with_http_info: #{e}"
end
```
### Parameters
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **status** | [**Array&lt;String&gt;**](String.md) | Status values that need to be considered for filter | |
### Return type
[**Array&lt;Pet&gt;**](Pet.md)
### Authorization
[petstore_auth](../README.md#petstore_auth)
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/xml, application/json
## find_pets_by_tags
> <Array<Pet>> find_pets_by_tags(tags)
Finds Pets by tags
Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
### Examples
```ruby
require 'time'
require 'petstore'
# setup authorization
Petstore.configure do |config|
# Configure OAuth2 access token for authorization: petstore_auth
config.access_token = 'YOUR ACCESS TOKEN'
end
api_instance = Petstore::PetApi.new
tags = ['inner_example'] # Array<String> | Tags to filter by
begin
# Finds Pets by tags
result = api_instance.find_pets_by_tags(tags)
p result
rescue Petstore::ApiError => e
puts "Error when calling PetApi->find_pets_by_tags: #{e}"
end
```
#### Using the find_pets_by_tags_with_http_info variant
This returns an Array which contains the response data, status code and headers.
> <Array(<Array<Pet>>, Integer, Hash)> find_pets_by_tags_with_http_info(tags)
```ruby
begin
# Finds Pets by tags
data, status_code, headers = api_instance.find_pets_by_tags_with_http_info(tags)
p status_code # => 2xx
p headers # => { ... }
p data # => <Array<Pet>>
rescue Petstore::ApiError => e
puts "Error when calling PetApi->find_pets_by_tags_with_http_info: #{e}"
end
```
### Parameters
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **tags** | [**Array&lt;String&gt;**](String.md) | Tags to filter by | |
### Return type
[**Array&lt;Pet&gt;**](Pet.md)
### Authorization
[petstore_auth](../README.md#petstore_auth)
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/xml, application/json
## get_pet_by_id
> <Pet> get_pet_by_id(pet_id)
Find pet by ID
Returns a single pet
### Examples
```ruby
require 'time'
require 'petstore'
# setup authorization
Petstore.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 = Petstore::PetApi.new
pet_id = 789 # Integer | ID of pet to return
begin
# Find pet by ID
result = api_instance.get_pet_by_id(pet_id)
p result
rescue Petstore::ApiError => e
puts "Error when calling PetApi->get_pet_by_id: #{e}"
end
```
#### Using the get_pet_by_id_with_http_info variant
This returns an Array which contains the response data, status code and headers.
> <Array(<Pet>, Integer, Hash)> get_pet_by_id_with_http_info(pet_id)
```ruby
begin
# Find pet by ID
data, status_code, headers = api_instance.get_pet_by_id_with_http_info(pet_id)
p status_code # => 2xx
p headers # => { ... }
p data # => <Pet>
rescue Petstore::ApiError => e
puts "Error when calling PetApi->get_pet_by_id_with_http_info: #{e}"
end
```
### Parameters
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **pet_id** | **Integer** | ID of pet to return | |
### Return type
[**Pet**](Pet.md)
### Authorization
[api_key](../README.md#api_key)
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/xml, application/json
## update_pet
> update_pet(pet)
Update an existing pet
### Examples
```ruby
require 'time'
require 'petstore'
# setup authorization
Petstore.configure do |config|
# Configure OAuth2 access token for authorization: petstore_auth
config.access_token = 'YOUR ACCESS TOKEN'
end
api_instance = Petstore::PetApi.new
pet = Petstore::Pet.new({name: 'doggie', photo_urls: ['photo_urls_example']}) # Pet | Pet object that needs to be added to the store
begin
# Update an existing pet
api_instance.update_pet(pet)
rescue Petstore::ApiError => e
puts "Error when calling PetApi->update_pet: #{e}"
end
```
#### Using the update_pet_with_http_info variant
This returns an Array which contains the response data (`nil` in this case), status code and headers.
> <Array(nil, Integer, Hash)> update_pet_with_http_info(pet)
```ruby
begin
# Update an existing pet
data, status_code, headers = api_instance.update_pet_with_http_info(pet)
p status_code # => 2xx
p headers # => { ... }
p data # => nil
rescue Petstore::ApiError => e
puts "Error when calling PetApi->update_pet_with_http_info: #{e}"
end
```
### Parameters
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **pet** | [**Pet**](Pet.md) | Pet object that needs to be added to the store | |
### Return type
nil (empty response body)
### Authorization
[petstore_auth](../README.md#petstore_auth)
### HTTP request headers
- **Content-Type**: application/json, application/xml
- **Accept**: Not defined
## update_pet_with_form
> update_pet_with_form(pet_id, opts)
Updates a pet in the store with form data
### Examples
```ruby
require 'time'
require 'petstore'
# setup authorization
Petstore.configure do |config|
# Configure OAuth2 access token for authorization: petstore_auth
config.access_token = 'YOUR ACCESS TOKEN'
end
api_instance = Petstore::PetApi.new
pet_id = 789 # Integer | ID of pet that needs to be updated
opts = {
name: 'name_example', # String | Updated name of the pet
status: 'status_example' # String | Updated status of the pet
}
begin
# Updates a pet in the store with form data
api_instance.update_pet_with_form(pet_id, opts)
rescue Petstore::ApiError => e
puts "Error when calling PetApi->update_pet_with_form: #{e}"
end
```
#### Using the update_pet_with_form_with_http_info variant
This returns an Array which contains the response data (`nil` in this case), status code and headers.
> <Array(nil, Integer, Hash)> update_pet_with_form_with_http_info(pet_id, opts)
```ruby
begin
# Updates a pet in the store with form data
data, status_code, headers = api_instance.update_pet_with_form_with_http_info(pet_id, opts)
p status_code # => 2xx
p headers # => { ... }
p data # => nil
rescue Petstore::ApiError => e
puts "Error when calling PetApi->update_pet_with_form_with_http_info: #{e}"
end
```
### Parameters
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **pet_id** | **Integer** | ID of pet that needs to be updated | |
| **name** | **String** | Updated name of the pet | [optional] |
| **status** | **String** | Updated status of the pet | [optional] |
### Return type
nil (empty response body)
### Authorization
[petstore_auth](../README.md#petstore_auth)
### HTTP request headers
- **Content-Type**: application/x-www-form-urlencoded
- **Accept**: Not defined
## upload_file
> <ApiResponse> upload_file(pet_id, opts)
uploads an image
### Examples
```ruby
require 'time'
require 'petstore'
# setup authorization
Petstore.configure do |config|
# Configure OAuth2 access token for authorization: petstore_auth
config.access_token = 'YOUR ACCESS TOKEN'
end
api_instance = Petstore::PetApi.new
pet_id = 789 # Integer | ID of pet to update
opts = {
additional_metadata: 'additional_metadata_example', # String | Additional data to pass to server
file: File.new('/path/to/some/file') # File | file to upload
}
begin
# uploads an image
result = api_instance.upload_file(pet_id, opts)
p result
rescue Petstore::ApiError => e
puts "Error when calling PetApi->upload_file: #{e}"
end
```
#### Using the upload_file_with_http_info variant
This returns an Array which contains the response data, status code and headers.
> <Array(<ApiResponse>, Integer, Hash)> upload_file_with_http_info(pet_id, opts)
```ruby
begin
# uploads an image
data, status_code, headers = api_instance.upload_file_with_http_info(pet_id, opts)
p status_code # => 2xx
p headers # => { ... }
p data # => <ApiResponse>
rescue Petstore::ApiError => e
puts "Error when calling PetApi->upload_file_with_http_info: #{e}"
end
```
### Parameters
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **pet_id** | **Integer** | ID of pet to update | |
| **additional_metadata** | **String** | Additional data to pass to server | [optional] |
| **file** | **File** | file to upload | [optional] |
### Return type
[**ApiResponse**](ApiResponse.md)
### Authorization
[petstore_auth](../README.md#petstore_auth)
### HTTP request headers
- **Content-Type**: multipart/form-data
- **Accept**: application/json
## upload_file_with_required_file
> <ApiResponse> upload_file_with_required_file(pet_id, required_file, opts)
uploads an image (required)
### Examples
```ruby
require 'time'
require 'petstore'
# setup authorization
Petstore.configure do |config|
# Configure OAuth2 access token for authorization: petstore_auth
config.access_token = 'YOUR ACCESS TOKEN'
end
api_instance = Petstore::PetApi.new
pet_id = 789 # Integer | ID of pet to update
required_file = File.new('/path/to/some/file') # File | file to upload
opts = {
additional_metadata: 'additional_metadata_example' # String | Additional data to pass to server
}
begin
# uploads an image (required)
result = api_instance.upload_file_with_required_file(pet_id, required_file, opts)
p result
rescue Petstore::ApiError => e
puts "Error when calling PetApi->upload_file_with_required_file: #{e}"
end
```
#### Using the upload_file_with_required_file_with_http_info variant
This returns an Array which contains the response data, status code and headers.
> <Array(<ApiResponse>, Integer, Hash)> upload_file_with_required_file_with_http_info(pet_id, required_file, opts)
```ruby
begin
# uploads an image (required)
data, status_code, headers = api_instance.upload_file_with_required_file_with_http_info(pet_id, required_file, opts)
p status_code # => 2xx
p headers # => { ... }
p data # => <ApiResponse>
rescue Petstore::ApiError => e
puts "Error when calling PetApi->upload_file_with_required_file_with_http_info: #{e}"
end
```
### Parameters
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **pet_id** | **Integer** | ID of pet to update | |
| **required_file** | **File** | file to upload | |
| **additional_metadata** | **String** | Additional data to pass to server | [optional] |
### Return type
[**ApiResponse**](ApiResponse.md)
### Authorization
[petstore_auth](../README.md#petstore_auth)
### HTTP request headers
- **Content-Type**: multipart/form-data
- **Accept**: application/json

20
samples/client/petstore/ruby-autoload/docs/ReadOnlyFirst.md Normal file
View File

@ -0,0 +1,20 @@
# Petstore::ReadOnlyFirst
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **bar** | **String** | | [optional][readonly] |
| **baz** | **String** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::ReadOnlyFirst.new(
bar: null,
baz: null
)
```

15
samples/client/petstore/ruby-autoload/docs/SingleRefType.md Normal file
View File

@ -0,0 +1,15 @@
# Petstore::SingleRefType
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
## Example
```ruby
require 'petstore'
instance = Petstore::SingleRefType.new()
```

18
samples/client/petstore/ruby-autoload/docs/SpecialModelName.md Normal file
View File

@ -0,0 +1,18 @@
# Petstore::SpecialModelName
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **special_property_name** | **Integer** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::SpecialModelName.new(
special_property_name: null
)
```

270
samples/client/petstore/ruby-autoload/docs/StoreApi.md Normal file
View File

@ -0,0 +1,270 @@
# Petstore::StoreApi
All URIs are relative to *http://petstore.swagger.io:80/v2*
| Method | HTTP request | Description |
| ------ | ------------ | ----------- |
| [**delete_order**](StoreApi.md#delete_order) | **DELETE** /store/order/{order_id} | Delete purchase order by ID |
| [**get_inventory**](StoreApi.md#get_inventory) | **GET** /store/inventory | Returns pet inventories by status |
| [**get_order_by_id**](StoreApi.md#get_order_by_id) | **GET** /store/order/{order_id} | Find purchase order by ID |
| [**place_order**](StoreApi.md#place_order) | **POST** /store/order | Place an order for a pet |
## delete_order
> delete_order(order_id)
Delete purchase order by ID
For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
### Examples
```ruby
require 'time'
require 'petstore'
api_instance = Petstore::StoreApi.new
order_id = 'order_id_example' # String | ID of the order that needs to be deleted
begin
# Delete purchase order by ID
api_instance.delete_order(order_id)
rescue Petstore::ApiError => e
puts "Error when calling StoreApi->delete_order: #{e}"
end
```
#### Using the delete_order_with_http_info variant
This returns an Array which contains the response data (`nil` in this case), status code and headers.
> <Array(nil, Integer, Hash)> delete_order_with_http_info(order_id)
```ruby
begin
# Delete purchase order by ID
data, status_code, headers = api_instance.delete_order_with_http_info(order_id)
p status_code # => 2xx
p headers # => { ... }
p data # => nil
rescue Petstore::ApiError => e
puts "Error when calling StoreApi->delete_order_with_http_info: #{e}"
end
```
### Parameters
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **order_id** | **String** | ID of the order that needs to be deleted | |
### Return type
nil (empty response body)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: Not defined
## get_inventory
> Hash&lt;String, Integer&gt; get_inventory
Returns pet inventories by status
Returns a map of status codes to quantities
### Examples
```ruby
require 'time'
require 'petstore'
# setup authorization
Petstore.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 = Petstore::StoreApi.new
begin
# Returns pet inventories by status
result = api_instance.get_inventory
p result
rescue Petstore::ApiError => e
puts "Error when calling StoreApi->get_inventory: #{e}"
end
```
#### Using the get_inventory_with_http_info variant
This returns an Array which contains the response data, status code and headers.
> <Array(Hash&lt;String, Integer&gt;, Integer, Hash)> get_inventory_with_http_info
```ruby
begin
# Returns pet inventories by status
data, status_code, headers = api_instance.get_inventory_with_http_info
p status_code # => 2xx
p headers # => { ... }
p data # => Hash&lt;String, Integer&gt;
rescue Petstore::ApiError => e
puts "Error when calling StoreApi->get_inventory_with_http_info: #{e}"
end
```
### Parameters
This endpoint does not need any parameter.
### Return type
**Hash&lt;String, Integer&gt;**
### Authorization
[api_key](../README.md#api_key)
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
## get_order_by_id
> <Order> get_order_by_id(order_id)
Find purchase order by ID
For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions
### Examples
```ruby
require 'time'
require 'petstore'
api_instance = Petstore::StoreApi.new
order_id = 789 # Integer | ID of pet that needs to be fetched
begin
# Find purchase order by ID
result = api_instance.get_order_by_id(order_id)
p result
rescue Petstore::ApiError => e
puts "Error when calling StoreApi->get_order_by_id: #{e}"
end
```
#### Using the get_order_by_id_with_http_info variant
This returns an Array which contains the response data, status code and headers.
> <Array(<Order>, Integer, Hash)> get_order_by_id_with_http_info(order_id)
```ruby
begin
# Find purchase order by ID
data, status_code, headers = api_instance.get_order_by_id_with_http_info(order_id)
p status_code # => 2xx
p headers # => { ... }
p data # => <Order>
rescue Petstore::ApiError => e
puts "Error when calling StoreApi->get_order_by_id_with_http_info: #{e}"
end
```
### Parameters
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **order_id** | **Integer** | ID of pet that needs to be fetched | |
### Return type
[**Order**](Order.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/xml, application/json
## place_order
> <Order> place_order(order)
Place an order for a pet
### Examples
```ruby
require 'time'
require 'petstore'
api_instance = Petstore::StoreApi.new
order = Petstore::Order.new # Order | order placed for purchasing the pet
begin
# Place an order for a pet
result = api_instance.place_order(order)
p result
rescue Petstore::ApiError => e
puts "Error when calling StoreApi->place_order: #{e}"
end
```
#### Using the place_order_with_http_info variant
This returns an Array which contains the response data, status code and headers.
> <Array(<Order>, Integer, Hash)> place_order_with_http_info(order)
```ruby
begin
# Place an order for a pet
data, status_code, headers = api_instance.place_order_with_http_info(order)
p status_code # => 2xx
p headers # => { ... }
p data # => <Order>
rescue Petstore::ApiError => e
puts "Error when calling StoreApi->place_order_with_http_info: #{e}"
end
```
### Parameters
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **order** | [**Order**](Order.md) | order placed for purchasing the pet | |
### Return type
[**Order**](Order.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: application/json
- **Accept**: application/xml, application/json

20
samples/client/petstore/ruby-autoload/docs/Tag.md Normal file
View File

@ -0,0 +1,20 @@
# Petstore::Tag
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **id** | **Integer** | | [optional] |
| **name** | **String** | | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::Tag.new(
id: null,
name: null
)
```

32
samples/client/petstore/ruby-autoload/docs/User.md Normal file
View File

@ -0,0 +1,32 @@
# Petstore::User
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **id** | **Integer** | | [optional] |
| **username** | **String** | | [optional] |
| **first_name** | **String** | | [optional] |
| **last_name** | **String** | | [optional] |
| **email** | **String** | | [optional] |
| **password** | **String** | | [optional] |
| **phone** | **String** | | [optional] |
| **user_status** | **Integer** | User Status | [optional] |
## Example
```ruby
require 'petstore'
instance = Petstore::User.new(
id: null,
username: null,
first_name: null,
last_name: null,
email: null,
password: null,
phone: null,
user_status: null
)
```

522
samples/client/petstore/ruby-autoload/docs/UserApi.md Normal file
View File

@ -0,0 +1,522 @@
# Petstore::UserApi
All URIs are relative to *http://petstore.swagger.io:80/v2*
| Method | HTTP request | Description |
| ------ | ------------ | ----------- |
| [**create_user**](UserApi.md#create_user) | **POST** /user | Create user |
| [**create_users_with_array_input**](UserApi.md#create_users_with_array_input) | **POST** /user/createWithArray | Creates list of users with given input array |
| [**create_users_with_list_input**](UserApi.md#create_users_with_list_input) | **POST** /user/createWithList | Creates list of users with given input array |
| [**delete_user**](UserApi.md#delete_user) | **DELETE** /user/{username} | Delete user |
| [**get_user_by_name**](UserApi.md#get_user_by_name) | **GET** /user/{username} | Get user by user name |
| [**login_user**](UserApi.md#login_user) | **GET** /user/login | Logs user into the system |
| [**logout_user**](UserApi.md#logout_user) | **GET** /user/logout | Logs out current logged in user session |
| [**update_user**](UserApi.md#update_user) | **PUT** /user/{username} | Updated user |
## create_user
> create_user(user)
Create user
This can only be done by the logged in user.
### Examples
```ruby
require 'time'
require 'petstore'
api_instance = Petstore::UserApi.new
user = Petstore::User.new # User | Created user object
begin
# Create user
api_instance.create_user(user)
rescue Petstore::ApiError => e
puts "Error when calling UserApi->create_user: #{e}"
end
```
#### Using the create_user_with_http_info variant
This returns an Array which contains the response data (`nil` in this case), status code and headers.
> <Array(nil, Integer, Hash)> create_user_with_http_info(user)
```ruby
begin
# Create user
data, status_code, headers = api_instance.create_user_with_http_info(user)
p status_code # => 2xx
p headers # => { ... }
p data # => nil
rescue Petstore::ApiError => e
puts "Error when calling UserApi->create_user_with_http_info: #{e}"
end
```
### Parameters
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **user** | [**User**](User.md) | Created user object | |
### Return type
nil (empty response body)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: application/json
- **Accept**: Not defined
## create_users_with_array_input
> create_users_with_array_input(user)
Creates list of users with given input array
### Examples
```ruby
require 'time'
require 'petstore'
api_instance = Petstore::UserApi.new
user = [Petstore::User.new] # Array<User> | List of user object
begin
# Creates list of users with given input array
api_instance.create_users_with_array_input(user)
rescue Petstore::ApiError => e
puts "Error when calling UserApi->create_users_with_array_input: #{e}"
end
```
#### Using the create_users_with_array_input_with_http_info variant
This returns an Array which contains the response data (`nil` in this case), status code and headers.
> <Array(nil, Integer, Hash)> create_users_with_array_input_with_http_info(user)
```ruby
begin
# Creates list of users with given input array
data, status_code, headers = api_instance.create_users_with_array_input_with_http_info(user)
p status_code # => 2xx
p headers # => { ... }
p data # => nil
rescue Petstore::ApiError => e
puts "Error when calling UserApi->create_users_with_array_input_with_http_info: #{e}"
end
```
### Parameters
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **user** | [**Array&lt;User&gt;**](User.md) | List of user object | |
### Return type
nil (empty response body)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: application/json
- **Accept**: Not defined
## create_users_with_list_input
> create_users_with_list_input(user)
Creates list of users with given input array
### Examples
```ruby
require 'time'
require 'petstore'
api_instance = Petstore::UserApi.new
user = [Petstore::User.new] # Array<User> | List of user object
begin
# Creates list of users with given input array
api_instance.create_users_with_list_input(user)
rescue Petstore::ApiError => e
puts "Error when calling UserApi->create_users_with_list_input: #{e}"
end
```
#### Using the create_users_with_list_input_with_http_info variant
This returns an Array which contains the response data (`nil` in this case), status code and headers.
> <Array(nil, Integer, Hash)> create_users_with_list_input_with_http_info(user)
```ruby
begin
# Creates list of users with given input array
data, status_code, headers = api_instance.create_users_with_list_input_with_http_info(user)
p status_code # => 2xx
p headers # => { ... }
p data # => nil
rescue Petstore::ApiError => e
puts "Error when calling UserApi->create_users_with_list_input_with_http_info: #{e}"
end
```
### Parameters
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **user** | [**Array&lt;User&gt;**](User.md) | List of user object | |
### Return type
nil (empty response body)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: application/json
- **Accept**: Not defined
## delete_user
> delete_user(username)
Delete user
This can only be done by the logged in user.
### Examples
```ruby
require 'time'
require 'petstore'
api_instance = Petstore::UserApi.new
username = 'username_example' # String | The name that needs to be deleted
begin
# Delete user
api_instance.delete_user(username)
rescue Petstore::ApiError => e
puts "Error when calling UserApi->delete_user: #{e}"
end
```
#### Using the delete_user_with_http_info variant
This returns an Array which contains the response data (`nil` in this case), status code and headers.
> <Array(nil, Integer, Hash)> delete_user_with_http_info(username)
```ruby
begin
# Delete user
data, status_code, headers = api_instance.delete_user_with_http_info(username)
p status_code # => 2xx
p headers # => { ... }
p data # => nil
rescue Petstore::ApiError => e
puts "Error when calling UserApi->delete_user_with_http_info: #{e}"
end
```
### Parameters
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **username** | **String** | The name that needs to be deleted | |
### Return type
nil (empty response body)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: Not defined
## get_user_by_name
> <User> get_user_by_name(username)
Get user by user name
### Examples
```ruby
require 'time'
require 'petstore'
api_instance = Petstore::UserApi.new
username = 'username_example' # String | The name that needs to be fetched. Use user1 for testing.
begin
# Get user by user name
result = api_instance.get_user_by_name(username)
p result
rescue Petstore::ApiError => e
puts "Error when calling UserApi->get_user_by_name: #{e}"
end
```
#### Using the get_user_by_name_with_http_info variant
This returns an Array which contains the response data, status code and headers.
> <Array(<User>, Integer, Hash)> get_user_by_name_with_http_info(username)
```ruby
begin
# Get user by user name
data, status_code, headers = api_instance.get_user_by_name_with_http_info(username)
p status_code # => 2xx
p headers # => { ... }
p data # => <User>
rescue Petstore::ApiError => e
puts "Error when calling UserApi->get_user_by_name_with_http_info: #{e}"
end
```
### Parameters
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **username** | **String** | The name that needs to be fetched. Use user1 for testing. | |
### Return type
[**User**](User.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/xml, application/json
## login_user
> String login_user(username, password)
Logs user into the system
### Examples
```ruby
require 'time'
require 'petstore'
api_instance = Petstore::UserApi.new
username = 'username_example' # String | The user name for login
password = 'password_example' # String | The password for login in clear text
begin
# Logs user into the system
result = api_instance.login_user(username, password)
p result
rescue Petstore::ApiError => e
puts "Error when calling UserApi->login_user: #{e}"
end
```
#### Using the login_user_with_http_info variant
This returns an Array which contains the response data, status code and headers.
> <Array(String, Integer, Hash)> login_user_with_http_info(username, password)
```ruby
begin
# Logs user into the system
data, status_code, headers = api_instance.login_user_with_http_info(username, password)
p status_code # => 2xx
p headers # => { ... }
p data # => String
rescue Petstore::ApiError => e
puts "Error when calling UserApi->login_user_with_http_info: #{e}"
end
```
### Parameters
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **username** | **String** | The user name for login | |
| **password** | **String** | The password for login in clear text | |
### Return type
**String**
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/xml, application/json
## logout_user
> logout_user
Logs out current logged in user session
### Examples
```ruby
require 'time'
require 'petstore'
api_instance = Petstore::UserApi.new
begin
# Logs out current logged in user session
api_instance.logout_user
rescue Petstore::ApiError => e
puts "Error when calling UserApi->logout_user: #{e}"
end
```
#### Using the logout_user_with_http_info variant
This returns an Array which contains the response data (`nil` in this case), status code and headers.
> <Array(nil, Integer, Hash)> logout_user_with_http_info
```ruby
begin
# Logs out current logged in user session
data, status_code, headers = api_instance.logout_user_with_http_info
p status_code # => 2xx
p headers # => { ... }
p data # => nil
rescue Petstore::ApiError => e
puts "Error when calling UserApi->logout_user_with_http_info: #{e}"
end
```
### Parameters
This endpoint does not need any parameter.
### Return type
nil (empty response body)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: Not defined
## update_user
> update_user(username, user)
Updated user
This can only be done by the logged in user.
### Examples
```ruby
require 'time'
require 'petstore'
api_instance = Petstore::UserApi.new
username = 'username_example' # String | name that need to be deleted
user = Petstore::User.new # User | Updated user object
begin
# Updated user
api_instance.update_user(username, user)
rescue Petstore::ApiError => e
puts "Error when calling UserApi->update_user: #{e}"
end
```
#### Using the update_user_with_http_info variant
This returns an Array which contains the response data (`nil` in this case), status code and headers.
> <Array(nil, Integer, Hash)> update_user_with_http_info(username, user)
```ruby
begin
# Updated user
data, status_code, headers = api_instance.update_user_with_http_info(username, user)
p status_code # => 2xx
p headers # => { ... }
p data # => nil
rescue Petstore::ApiError => e
puts "Error when calling UserApi->update_user_with_http_info: #{e}"
end
```
### Parameters
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **username** | **String** | name that need to be deleted | |
| **user** | [**User**](User.md) | Updated user object | |
### Return type
nil (empty response body)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: application/json
- **Accept**: Not defined

57
samples/client/petstore/ruby-autoload/git_push.sh Normal file
View File

@ -0,0 +1,57 @@
#!/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-petstore-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'

94
samples/client/petstore/ruby-autoload/lib/petstore.rb Normal file
View File

@ -0,0 +1,94 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
# Common files
require 'petstore/api_client'
require 'petstore/api_error'
require 'petstore/version'
require 'petstore/configuration'
# Models
Petstore.autoload :AdditionalPropertiesClass, 'petstore/models/additional_properties_class'
Petstore.autoload :AllOfWithSingleRef, 'petstore/models/all_of_with_single_ref'
Petstore.autoload :Animal, 'petstore/models/animal'
Petstore.autoload :ApiResponse, 'petstore/models/api_response'
Petstore.autoload :ArrayOfArrayOfNumberOnly, 'petstore/models/array_of_array_of_number_only'
Petstore.autoload :ArrayOfNumberOnly, 'petstore/models/array_of_number_only'
Petstore.autoload :ArrayTest, 'petstore/models/array_test'
Petstore.autoload :Capitalization, 'petstore/models/capitalization'
Petstore.autoload :Cat, 'petstore/models/cat'
Petstore.autoload :CatAllOf, 'petstore/models/cat_all_of'
Petstore.autoload :Category, 'petstore/models/category'
Petstore.autoload :ClassModel, 'petstore/models/class_model'
Petstore.autoload :Client, 'petstore/models/client'
Petstore.autoload :DeprecatedObject, 'petstore/models/deprecated_object'
Petstore.autoload :Dog, 'petstore/models/dog'
Petstore.autoload :DogAllOf, 'petstore/models/dog_all_of'
Petstore.autoload :EnumArrays, 'petstore/models/enum_arrays'
Petstore.autoload :EnumClass, 'petstore/models/enum_class'
Petstore.autoload :EnumTest, 'petstore/models/enum_test'
Petstore.autoload :File, 'petstore/models/file'
Petstore.autoload :FileSchemaTestClass, 'petstore/models/file_schema_test_class'
Petstore.autoload :Foo, 'petstore/models/foo'
Petstore.autoload :FooGetDefaultResponse, 'petstore/models/foo_get_default_response'
Petstore.autoload :FormatTest, 'petstore/models/format_test'
Petstore.autoload :HasOnlyReadOnly, 'petstore/models/has_only_read_only'
Petstore.autoload :HealthCheckResult, 'petstore/models/health_check_result'
Petstore.autoload :List, 'petstore/models/list'
Petstore.autoload :MapTest, 'petstore/models/map_test'
Petstore.autoload :MixedPropertiesAndAdditionalPropertiesClass, 'petstore/models/mixed_properties_and_additional_properties_class'
Petstore.autoload :Model200Response, 'petstore/models/model200_response'
Petstore.autoload :ModelReturn, 'petstore/models/model_return'
Petstore.autoload :Name, 'petstore/models/name'
Petstore.autoload :NullableClass, 'petstore/models/nullable_class'
Petstore.autoload :NumberOnly, 'petstore/models/number_only'
Petstore.autoload :ObjectWithDeprecatedFields, 'petstore/models/object_with_deprecated_fields'
Petstore.autoload :Order, 'petstore/models/order'
Petstore.autoload :OuterComposite, 'petstore/models/outer_composite'
Petstore.autoload :OuterEnum, 'petstore/models/outer_enum'
Petstore.autoload :OuterEnumDefaultValue, 'petstore/models/outer_enum_default_value'
Petstore.autoload :OuterEnumInteger, 'petstore/models/outer_enum_integer'
Petstore.autoload :OuterEnumIntegerDefaultValue, 'petstore/models/outer_enum_integer_default_value'
Petstore.autoload :OuterObjectWithEnumProperty, 'petstore/models/outer_object_with_enum_property'
Petstore.autoload :Pet, 'petstore/models/pet'
Petstore.autoload :ReadOnlyFirst, 'petstore/models/read_only_first'
Petstore.autoload :SingleRefType, 'petstore/models/single_ref_type'
Petstore.autoload :SpecialModelName, 'petstore/models/special_model_name'
Petstore.autoload :Tag, 'petstore/models/tag'
Petstore.autoload :User, 'petstore/models/user'
# APIs
Petstore.autoload :AnotherFakeApi, 'petstore/api/another_fake_api'
Petstore.autoload :DefaultApi, 'petstore/api/default_api'
Petstore.autoload :FakeApi, 'petstore/api/fake_api'
Petstore.autoload :FakeClassnameTags123Api, 'petstore/api/fake_classname_tags123_api'
Petstore.autoload :PetApi, 'petstore/api/pet_api'
Petstore.autoload :StoreApi, 'petstore/api/store_api'
Petstore.autoload :UserApi, 'petstore/api/user_api'
module Petstore
class << self
# Customize default settings for the SDK using block.
# Petstore.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

90
samples/client/petstore/ruby-autoload/lib/petstore/api/another_fake_api.rb Normal file
View File

@ -0,0 +1,90 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'cgi'
module Petstore
class AnotherFakeApi
attr_accessor :api_client
def initialize(api_client = ApiClient.default)
@api_client = api_client
end
# To test special tags
# To test special tags and operation ID starting with number
# @param client [Client] client model
# @param [Hash] opts the optional parameters
# @return [Client]
def call_123_test_special_tags(client, opts = {})
data, _status_code, _headers = call_123_test_special_tags_with_http_info(client, opts)
data
end
# To test special tags
# To test special tags and operation ID starting with number
# @param client [Client] client model
# @param [Hash] opts the optional parameters
# @return [Array<(Client, Integer, Hash)>] Client data, response status code and response headers
def call_123_test_special_tags_with_http_info(client, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: AnotherFakeApi.call_123_test_special_tags ...'
end
# verify the required parameter 'client' is set
if @api_client.config.client_side_validation && client.nil?
fail ArgumentError, "Missing the required parameter 'client' when calling AnotherFakeApi.call_123_test_special_tags"
end
# resource path
local_var_path = '/another-fake/dummy'
# 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'])
# HTTP header 'Content-Type'
content_type = @api_client.select_header_content_type(['application/json'])
if !content_type.nil?
header_params['Content-Type'] = content_type
end
# form parameters
form_params = opts[:form_params] || {}
# http body (model)
post_body = opts[:debug_body] || @api_client.object_to_http_body(client)
# return_type
return_type = opts[:debug_return_type] || 'Client'
# auth_names
auth_names = opts[:debug_auth_names] || []
new_options = opts.merge(
:operation => :"AnotherFakeApi.call_123_test_special_tags",
: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(:PATCH, local_var_path, new_options)
if @api_client.config.debugging
@api_client.config.logger.debug "API called: AnotherFakeApi#call_123_test_special_tags\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
end
end

75
samples/client/petstore/ruby-autoload/lib/petstore/api/default_api.rb Normal file
View File

@ -0,0 +1,75 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'cgi'
module Petstore
class DefaultApi
attr_accessor :api_client
def initialize(api_client = ApiClient.default)
@api_client = api_client
end
# @param [Hash] opts the optional parameters
# @return [FooGetDefaultResponse]
def foo_get(opts = {})
data, _status_code, _headers = foo_get_with_http_info(opts)
data
end
# @param [Hash] opts the optional parameters
# @return [Array<(FooGetDefaultResponse, Integer, Hash)>] FooGetDefaultResponse data, response status code and response headers
def foo_get_with_http_info(opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: DefaultApi.foo_get ...'
end
# resource path
local_var_path = '/foo'
# 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] || 'FooGetDefaultResponse'
# auth_names
auth_names = opts[:debug_auth_names] || []
new_options = opts.merge(
:operation => :"DefaultApi.foo_get",
: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: DefaultApi#foo_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
end
end

1340
samples/client/petstore/ruby-autoload/lib/petstore/api/fake_api.rb Normal file
View File

File diff suppressed because it is too large Load Diff

90
samples/client/petstore/ruby-autoload/lib/petstore/api/fake_classname_tags123_api.rb Normal file
View File

@ -0,0 +1,90 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'cgi'
module Petstore
class FakeClassnameTags123Api
attr_accessor :api_client
def initialize(api_client = ApiClient.default)
@api_client = api_client
end
# To test class name in snake case
# To test class name in snake case
# @param client [Client] client model
# @param [Hash] opts the optional parameters
# @return [Client]
def test_classname(client, opts = {})
data, _status_code, _headers = test_classname_with_http_info(client, opts)
data
end
# To test class name in snake case
# To test class name in snake case
# @param client [Client] client model
# @param [Hash] opts the optional parameters
# @return [Array<(Client, Integer, Hash)>] Client data, response status code and response headers
def test_classname_with_http_info(client, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: FakeClassnameTags123Api.test_classname ...'
end
# verify the required parameter 'client' is set
if @api_client.config.client_side_validation && client.nil?
fail ArgumentError, "Missing the required parameter 'client' when calling FakeClassnameTags123Api.test_classname"
end
# resource path
local_var_path = '/fake_classname_test'
# 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'])
# HTTP header 'Content-Type'
content_type = @api_client.select_header_content_type(['application/json'])
if !content_type.nil?
header_params['Content-Type'] = content_type
end
# form parameters
form_params = opts[:form_params] || {}
# http body (model)
post_body = opts[:debug_body] || @api_client.object_to_http_body(client)
# return_type
return_type = opts[:debug_return_type] || 'Client'
# auth_names
auth_names = opts[:debug_auth_names] || ['api_key_query']
new_options = opts.merge(
:operation => :"FakeClassnameTags123Api.test_classname",
: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(:PATCH, local_var_path, new_options)
if @api_client.config.debugging
@api_client.config.logger.debug "API called: FakeClassnameTags123Api#test_classname\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
end
end

633
samples/client/petstore/ruby-autoload/lib/petstore/api/pet_api.rb Normal file
View File

@ -0,0 +1,633 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'cgi'
module Petstore
class PetApi
attr_accessor :api_client
def initialize(api_client = ApiClient.default)
@api_client = api_client
end
# Add a new pet to the store
#
# @param pet [Pet] Pet object that needs to be added to the store
# @param [Hash] opts the optional parameters
# @return [nil]
def add_pet(pet, opts = {})
add_pet_with_http_info(pet, opts)
nil
end
# Add a new pet to the store
#
# @param pet [Pet] Pet object that needs to be added to the store
# @param [Hash] opts the optional parameters
# @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
def add_pet_with_http_info(pet, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: PetApi.add_pet ...'
end
# verify the required parameter 'pet' is set
if @api_client.config.client_side_validation && pet.nil?
fail ArgumentError, "Missing the required parameter 'pet' when calling PetApi.add_pet"
end
# resource path
local_var_path = '/pet'
# query parameters
query_params = opts[:query_params] || {}
# header parameters
header_params = opts[:header_params] || {}
# HTTP header 'Content-Type'
content_type = @api_client.select_header_content_type(['application/json', 'application/xml'])
if !content_type.nil?
header_params['Content-Type'] = content_type
end
# form parameters
form_params = opts[:form_params] || {}
# http body (model)
post_body = opts[:debug_body] || @api_client.object_to_http_body(pet)
# return_type
return_type = opts[:debug_return_type]
# auth_names
auth_names = opts[:debug_auth_names] || ['petstore_auth']
new_options = opts.merge(
:operation => :"PetApi.add_pet",
: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(:POST, local_var_path, new_options)
if @api_client.config.debugging
@api_client.config.logger.debug "API called: PetApi#add_pet\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
# Deletes a pet
#
# @param pet_id [Integer] Pet id to delete
# @param [Hash] opts the optional parameters
# @option opts [String] :api_key
# @return [nil]
def delete_pet(pet_id, opts = {})
delete_pet_with_http_info(pet_id, opts)
nil
end
# Deletes a pet
#
# @param pet_id [Integer] Pet id to delete
# @param [Hash] opts the optional parameters
# @option opts [String] :api_key
# @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
def delete_pet_with_http_info(pet_id, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: PetApi.delete_pet ...'
end
# verify the required parameter 'pet_id' is set
if @api_client.config.client_side_validation && pet_id.nil?
fail ArgumentError, "Missing the required parameter 'pet_id' when calling PetApi.delete_pet"
end
# resource path
local_var_path = '/pet/{petId}'.sub('{' + 'petId' + '}', CGI.escape(pet_id.to_s).gsub('%2F', '/'))
# query parameters
query_params = opts[:query_params] || {}
# header parameters
header_params = opts[:header_params] || {}
header_params[:'api_key'] = opts[:'api_key'] if !opts[:'api_key'].nil?
# form parameters
form_params = opts[:form_params] || {}
# http body (model)
post_body = opts[:debug_body]
# return_type
return_type = opts[:debug_return_type]
# auth_names
auth_names = opts[:debug_auth_names] || ['petstore_auth']
new_options = opts.merge(
:operation => :"PetApi.delete_pet",
: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(:DELETE, local_var_path, new_options)
if @api_client.config.debugging
@api_client.config.logger.debug "API called: PetApi#delete_pet\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
# Finds Pets by status
# Multiple status values can be provided with comma separated strings
# @param status [Array<String>] Status values that need to be considered for filter
# @param [Hash] opts the optional parameters
# @return [Array<Pet>]
def find_pets_by_status(status, opts = {})
data, _status_code, _headers = find_pets_by_status_with_http_info(status, opts)
data
end
# Finds Pets by status
# Multiple status values can be provided with comma separated strings
# @param status [Array<String>] Status values that need to be considered for filter
# @param [Hash] opts the optional parameters
# @return [Array<(Array<Pet>, Integer, Hash)>] Array<Pet> data, response status code and response headers
def find_pets_by_status_with_http_info(status, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: PetApi.find_pets_by_status ...'
end
# verify the required parameter 'status' is set
if @api_client.config.client_side_validation && status.nil?
fail ArgumentError, "Missing the required parameter 'status' when calling PetApi.find_pets_by_status"
end
# resource path
local_var_path = '/pet/findByStatus'
# query parameters
query_params = opts[:query_params] || {}
query_params[:'status'] = @api_client.build_collection_param(status, :csv)
# header parameters
header_params = opts[:header_params] || {}
# HTTP header 'Accept' (if needed)
header_params['Accept'] = @api_client.select_header_accept(['application/xml', '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] || 'Array<Pet>'
# auth_names
auth_names = opts[:debug_auth_names] || ['petstore_auth']
new_options = opts.merge(
:operation => :"PetApi.find_pets_by_status",
: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: PetApi#find_pets_by_status\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
# Finds Pets by tags
# Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
# @param tags [Array<String>] Tags to filter by
# @param [Hash] opts the optional parameters
# @return [Array<Pet>]
def find_pets_by_tags(tags, opts = {})
data, _status_code, _headers = find_pets_by_tags_with_http_info(tags, opts)
data
end
# Finds Pets by tags
# Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
# @param tags [Array<String>] Tags to filter by
# @param [Hash] opts the optional parameters
# @return [Array<(Array<Pet>, Integer, Hash)>] Array<Pet> data, response status code and response headers
def find_pets_by_tags_with_http_info(tags, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: PetApi.find_pets_by_tags ...'
end
# verify the required parameter 'tags' is set
if @api_client.config.client_side_validation && tags.nil?
fail ArgumentError, "Missing the required parameter 'tags' when calling PetApi.find_pets_by_tags"
end
# resource path
local_var_path = '/pet/findByTags'
# query parameters
query_params = opts[:query_params] || {}
query_params[:'tags'] = @api_client.build_collection_param(tags, :csv)
# header parameters
header_params = opts[:header_params] || {}
# HTTP header 'Accept' (if needed)
header_params['Accept'] = @api_client.select_header_accept(['application/xml', '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] || 'Array<Pet>'
# auth_names
auth_names = opts[:debug_auth_names] || ['petstore_auth']
new_options = opts.merge(
:operation => :"PetApi.find_pets_by_tags",
: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: PetApi#find_pets_by_tags\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
# Find pet by ID
# Returns a single pet
# @param pet_id [Integer] ID of pet to return
# @param [Hash] opts the optional parameters
# @return [Pet]
def get_pet_by_id(pet_id, opts = {})
data, _status_code, _headers = get_pet_by_id_with_http_info(pet_id, opts)
data
end
# Find pet by ID
# Returns a single pet
# @param pet_id [Integer] ID of pet to return
# @param [Hash] opts the optional parameters
# @return [Array<(Pet, Integer, Hash)>] Pet data, response status code and response headers
def get_pet_by_id_with_http_info(pet_id, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: PetApi.get_pet_by_id ...'
end
# verify the required parameter 'pet_id' is set
if @api_client.config.client_side_validation && pet_id.nil?
fail ArgumentError, "Missing the required parameter 'pet_id' when calling PetApi.get_pet_by_id"
end
# resource path
local_var_path = '/pet/{petId}'.sub('{' + 'petId' + '}', CGI.escape(pet_id.to_s).gsub('%2F', '/'))
# 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/xml', '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] || 'Pet'
# auth_names
auth_names = opts[:debug_auth_names] || ['api_key']
new_options = opts.merge(
:operation => :"PetApi.get_pet_by_id",
: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: PetApi#get_pet_by_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
# Update an existing pet
#
# @param pet [Pet] Pet object that needs to be added to the store
# @param [Hash] opts the optional parameters
# @return [nil]
def update_pet(pet, opts = {})
update_pet_with_http_info(pet, opts)
nil
end
# Update an existing pet
#
# @param pet [Pet] Pet object that needs to be added to the store
# @param [Hash] opts the optional parameters
# @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
def update_pet_with_http_info(pet, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: PetApi.update_pet ...'
end
# verify the required parameter 'pet' is set
if @api_client.config.client_side_validation && pet.nil?
fail ArgumentError, "Missing the required parameter 'pet' when calling PetApi.update_pet"
end
# resource path
local_var_path = '/pet'
# query parameters
query_params = opts[:query_params] || {}
# header parameters
header_params = opts[:header_params] || {}
# HTTP header 'Content-Type'
content_type = @api_client.select_header_content_type(['application/json', 'application/xml'])
if !content_type.nil?
header_params['Content-Type'] = content_type
end
# form parameters
form_params = opts[:form_params] || {}
# http body (model)
post_body = opts[:debug_body] || @api_client.object_to_http_body(pet)
# return_type
return_type = opts[:debug_return_type]
# auth_names
auth_names = opts[:debug_auth_names] || ['petstore_auth']
new_options = opts.merge(
:operation => :"PetApi.update_pet",
: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(:PUT, local_var_path, new_options)
if @api_client.config.debugging
@api_client.config.logger.debug "API called: PetApi#update_pet\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
# Updates a pet in the store with form data
#
# @param pet_id [Integer] ID of pet that needs to be updated
# @param [Hash] opts the optional parameters
# @option opts [String] :name Updated name of the pet
# @option opts [String] :status Updated status of the pet
# @return [nil]
def update_pet_with_form(pet_id, opts = {})
update_pet_with_form_with_http_info(pet_id, opts)
nil
end
# Updates a pet in the store with form data
#
# @param pet_id [Integer] ID of pet that needs to be updated
# @param [Hash] opts the optional parameters
# @option opts [String] :name Updated name of the pet
# @option opts [String] :status Updated status of the pet
# @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
def update_pet_with_form_with_http_info(pet_id, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: PetApi.update_pet_with_form ...'
end
# verify the required parameter 'pet_id' is set
if @api_client.config.client_side_validation && pet_id.nil?
fail ArgumentError, "Missing the required parameter 'pet_id' when calling PetApi.update_pet_with_form"
end
# resource path
local_var_path = '/pet/{petId}'.sub('{' + 'petId' + '}', CGI.escape(pet_id.to_s).gsub('%2F', '/'))
# query parameters
query_params = opts[:query_params] || {}
# header parameters
header_params = opts[:header_params] || {}
# HTTP header 'Content-Type'
content_type = @api_client.select_header_content_type(['application/x-www-form-urlencoded'])
if !content_type.nil?
header_params['Content-Type'] = content_type
end
# form parameters
form_params = opts[:form_params] || {}
form_params['name'] = opts[:'name'] if !opts[:'name'].nil?
form_params['status'] = opts[:'status'] if !opts[:'status'].nil?
# http body (model)
post_body = opts[:debug_body]
# return_type
return_type = opts[:debug_return_type]
# auth_names
auth_names = opts[:debug_auth_names] || ['petstore_auth']
new_options = opts.merge(
:operation => :"PetApi.update_pet_with_form",
: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(:POST, local_var_path, new_options)
if @api_client.config.debugging
@api_client.config.logger.debug "API called: PetApi#update_pet_with_form\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
# uploads an image
#
# @param pet_id [Integer] ID of pet to update
# @param [Hash] opts the optional parameters
# @option opts [String] :additional_metadata Additional data to pass to server
# @option opts [File] :file file to upload
# @return [ApiResponse]
def upload_file(pet_id, opts = {})
data, _status_code, _headers = upload_file_with_http_info(pet_id, opts)
data
end
# uploads an image
#
# @param pet_id [Integer] ID of pet to update
# @param [Hash] opts the optional parameters
# @option opts [String] :additional_metadata Additional data to pass to server
# @option opts [File] :file file to upload
# @return [Array<(ApiResponse, Integer, Hash)>] ApiResponse data, response status code and response headers
def upload_file_with_http_info(pet_id, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: PetApi.upload_file ...'
end
# verify the required parameter 'pet_id' is set
if @api_client.config.client_side_validation && pet_id.nil?
fail ArgumentError, "Missing the required parameter 'pet_id' when calling PetApi.upload_file"
end
# resource path
local_var_path = '/pet/{petId}/uploadImage'.sub('{' + 'petId' + '}', CGI.escape(pet_id.to_s).gsub('%2F', '/'))
# 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'])
# HTTP header 'Content-Type'
content_type = @api_client.select_header_content_type(['multipart/form-data'])
if !content_type.nil?
header_params['Content-Type'] = content_type
end
# form parameters
form_params = opts[:form_params] || {}
form_params['additionalMetadata'] = opts[:'additional_metadata'] if !opts[:'additional_metadata'].nil?
form_params['file'] = opts[:'file'] if !opts[:'file'].nil?
# http body (model)
post_body = opts[:debug_body]
# return_type
return_type = opts[:debug_return_type] || 'ApiResponse'
# auth_names
auth_names = opts[:debug_auth_names] || ['petstore_auth']
new_options = opts.merge(
:operation => :"PetApi.upload_file",
: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(:POST, local_var_path, new_options)
if @api_client.config.debugging
@api_client.config.logger.debug "API called: PetApi#upload_file\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
# uploads an image (required)
#
# @param pet_id [Integer] ID of pet to update
# @param required_file [File] file to upload
# @param [Hash] opts the optional parameters
# @option opts [String] :additional_metadata Additional data to pass to server
# @return [ApiResponse]
def upload_file_with_required_file(pet_id, required_file, opts = {})
data, _status_code, _headers = upload_file_with_required_file_with_http_info(pet_id, required_file, opts)
data
end
# uploads an image (required)
#
# @param pet_id [Integer] ID of pet to update
# @param required_file [File] file to upload
# @param [Hash] opts the optional parameters
# @option opts [String] :additional_metadata Additional data to pass to server
# @return [Array<(ApiResponse, Integer, Hash)>] ApiResponse data, response status code and response headers
def upload_file_with_required_file_with_http_info(pet_id, required_file, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: PetApi.upload_file_with_required_file ...'
end
# verify the required parameter 'pet_id' is set
if @api_client.config.client_side_validation && pet_id.nil?
fail ArgumentError, "Missing the required parameter 'pet_id' when calling PetApi.upload_file_with_required_file"
end
# verify the required parameter 'required_file' is set
if @api_client.config.client_side_validation && required_file.nil?
fail ArgumentError, "Missing the required parameter 'required_file' when calling PetApi.upload_file_with_required_file"
end
# resource path
local_var_path = '/fake/{petId}/uploadImageWithRequiredFile'.sub('{' + 'petId' + '}', CGI.escape(pet_id.to_s).gsub('%2F', '/'))
# 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'])
# HTTP header 'Content-Type'
content_type = @api_client.select_header_content_type(['multipart/form-data'])
if !content_type.nil?
header_params['Content-Type'] = content_type
end
# form parameters
form_params = opts[:form_params] || {}
form_params['requiredFile'] = required_file
form_params['additionalMetadata'] = opts[:'additional_metadata'] if !opts[:'additional_metadata'].nil?
# http body (model)
post_body = opts[:debug_body]
# return_type
return_type = opts[:debug_return_type] || 'ApiResponse'
# auth_names
auth_names = opts[:debug_auth_names] || ['petstore_auth']
new_options = opts.merge(
:operation => :"PetApi.upload_file_with_required_file",
: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(:POST, local_var_path, new_options)
if @api_client.config.debugging
@api_client.config.logger.debug "API called: PetApi#upload_file_with_required_file\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
end
end

279
samples/client/petstore/ruby-autoload/lib/petstore/api/store_api.rb Normal file
View File

@ -0,0 +1,279 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'cgi'
module Petstore
class StoreApi
attr_accessor :api_client
def initialize(api_client = ApiClient.default)
@api_client = api_client
end
# Delete purchase order by ID
# For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
# @param order_id [String] ID of the order that needs to be deleted
# @param [Hash] opts the optional parameters
# @return [nil]
def delete_order(order_id, opts = {})
delete_order_with_http_info(order_id, opts)
nil
end
# Delete purchase order by ID
# For valid response try integer IDs with value &lt; 1000. Anything above 1000 or nonintegers will generate API errors
# @param order_id [String] ID of the order that needs to be deleted
# @param [Hash] opts the optional parameters
# @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
def delete_order_with_http_info(order_id, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: StoreApi.delete_order ...'
end
# verify the required parameter 'order_id' is set
if @api_client.config.client_side_validation && order_id.nil?
fail ArgumentError, "Missing the required parameter 'order_id' when calling StoreApi.delete_order"
end
# resource path
local_var_path = '/store/order/{order_id}'.sub('{' + 'order_id' + '}', CGI.escape(order_id.to_s).gsub('%2F', '/'))
# query parameters
query_params = opts[:query_params] || {}
# header parameters
header_params = opts[:header_params] || {}
# form parameters
form_params = opts[:form_params] || {}
# http body (model)
post_body = opts[:debug_body]
# return_type
return_type = opts[:debug_return_type]
# auth_names
auth_names = opts[:debug_auth_names] || []
new_options = opts.merge(
:operation => :"StoreApi.delete_order",
: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(:DELETE, local_var_path, new_options)
if @api_client.config.debugging
@api_client.config.logger.debug "API called: StoreApi#delete_order\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
# Returns pet inventories by status
# Returns a map of status codes to quantities
# @param [Hash] opts the optional parameters
# @return [Hash<String, Integer>]
def get_inventory(opts = {})
data, _status_code, _headers = get_inventory_with_http_info(opts)
data
end
# Returns pet inventories by status
# Returns a map of status codes to quantities
# @param [Hash] opts the optional parameters
# @return [Array<(Hash<String, Integer>, Integer, Hash)>] Hash<String, Integer> data, response status code and response headers
def get_inventory_with_http_info(opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: StoreApi.get_inventory ...'
end
# resource path
local_var_path = '/store/inventory'
# 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] || 'Hash<String, Integer>'
# auth_names
auth_names = opts[:debug_auth_names] || ['api_key']
new_options = opts.merge(
:operation => :"StoreApi.get_inventory",
: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: StoreApi#get_inventory\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
# Find purchase order by ID
# For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions
# @param order_id [Integer] ID of pet that needs to be fetched
# @param [Hash] opts the optional parameters
# @return [Order]
def get_order_by_id(order_id, opts = {})
data, _status_code, _headers = get_order_by_id_with_http_info(order_id, opts)
data
end
# Find purchase order by ID
# For valid response try integer IDs with value &lt;&#x3D; 5 or &gt; 10. Other values will generated exceptions
# @param order_id [Integer] ID of pet that needs to be fetched
# @param [Hash] opts the optional parameters
# @return [Array<(Order, Integer, Hash)>] Order data, response status code and response headers
def get_order_by_id_with_http_info(order_id, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: StoreApi.get_order_by_id ...'
end
# verify the required parameter 'order_id' is set
if @api_client.config.client_side_validation && order_id.nil?
fail ArgumentError, "Missing the required parameter 'order_id' when calling StoreApi.get_order_by_id"
end
if @api_client.config.client_side_validation && order_id > 5
fail ArgumentError, 'invalid value for "order_id" when calling StoreApi.get_order_by_id, must be smaller than or equal to 5.'
end
if @api_client.config.client_side_validation && order_id < 1
fail ArgumentError, 'invalid value for "order_id" when calling StoreApi.get_order_by_id, must be greater than or equal to 1.'
end
# resource path
local_var_path = '/store/order/{order_id}'.sub('{' + 'order_id' + '}', CGI.escape(order_id.to_s).gsub('%2F', '/'))
# 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/xml', '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] || 'Order'
# auth_names
auth_names = opts[:debug_auth_names] || []
new_options = opts.merge(
:operation => :"StoreApi.get_order_by_id",
: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: StoreApi#get_order_by_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
# Place an order for a pet
#
# @param order [Order] order placed for purchasing the pet
# @param [Hash] opts the optional parameters
# @return [Order]
def place_order(order, opts = {})
data, _status_code, _headers = place_order_with_http_info(order, opts)
data
end
# Place an order for a pet
#
# @param order [Order] order placed for purchasing the pet
# @param [Hash] opts the optional parameters
# @return [Array<(Order, Integer, Hash)>] Order data, response status code and response headers
def place_order_with_http_info(order, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: StoreApi.place_order ...'
end
# verify the required parameter 'order' is set
if @api_client.config.client_side_validation && order.nil?
fail ArgumentError, "Missing the required parameter 'order' when calling StoreApi.place_order"
end
# resource path
local_var_path = '/store/order'
# 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/xml', 'application/json'])
# HTTP header 'Content-Type'
content_type = @api_client.select_header_content_type(['application/json'])
if !content_type.nil?
header_params['Content-Type'] = content_type
end
# form parameters
form_params = opts[:form_params] || {}
# http body (model)
post_body = opts[:debug_body] || @api_client.object_to_http_body(order)
# return_type
return_type = opts[:debug_return_type] || 'Order'
# auth_names
auth_names = opts[:debug_auth_names] || []
new_options = opts.merge(
:operation => :"StoreApi.place_order",
: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(:POST, local_var_path, new_options)
if @api_client.config.debugging
@api_client.config.logger.debug "API called: StoreApi#place_order\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
end
end

542
samples/client/petstore/ruby-autoload/lib/petstore/api/user_api.rb Normal file
View File

@ -0,0 +1,542 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'cgi'
module Petstore
class UserApi
attr_accessor :api_client
def initialize(api_client = ApiClient.default)
@api_client = api_client
end
# Create user
# This can only be done by the logged in user.
# @param user [User] Created user object
# @param [Hash] opts the optional parameters
# @return [nil]
def create_user(user, opts = {})
create_user_with_http_info(user, opts)
nil
end
# Create user
# This can only be done by the logged in user.
# @param user [User] Created user object
# @param [Hash] opts the optional parameters
# @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
def create_user_with_http_info(user, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: UserApi.create_user ...'
end
# verify the required parameter 'user' is set
if @api_client.config.client_side_validation && user.nil?
fail ArgumentError, "Missing the required parameter 'user' when calling UserApi.create_user"
end
# resource path
local_var_path = '/user'
# query parameters
query_params = opts[:query_params] || {}
# header parameters
header_params = opts[:header_params] || {}
# HTTP header 'Content-Type'
content_type = @api_client.select_header_content_type(['application/json'])
if !content_type.nil?
header_params['Content-Type'] = content_type
end
# form parameters
form_params = opts[:form_params] || {}
# http body (model)
post_body = opts[:debug_body] || @api_client.object_to_http_body(user)
# return_type
return_type = opts[:debug_return_type]
# auth_names
auth_names = opts[:debug_auth_names] || []
new_options = opts.merge(
:operation => :"UserApi.create_user",
: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(:POST, local_var_path, new_options)
if @api_client.config.debugging
@api_client.config.logger.debug "API called: UserApi#create_user\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
# Creates list of users with given input array
#
# @param user [Array<User>] List of user object
# @param [Hash] opts the optional parameters
# @return [nil]
def create_users_with_array_input(user, opts = {})
create_users_with_array_input_with_http_info(user, opts)
nil
end
# Creates list of users with given input array
#
# @param user [Array<User>] List of user object
# @param [Hash] opts the optional parameters
# @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
def create_users_with_array_input_with_http_info(user, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: UserApi.create_users_with_array_input ...'
end
# verify the required parameter 'user' is set
if @api_client.config.client_side_validation && user.nil?
fail ArgumentError, "Missing the required parameter 'user' when calling UserApi.create_users_with_array_input"
end
# resource path
local_var_path = '/user/createWithArray'
# query parameters
query_params = opts[:query_params] || {}
# header parameters
header_params = opts[:header_params] || {}
# HTTP header 'Content-Type'
content_type = @api_client.select_header_content_type(['application/json'])
if !content_type.nil?
header_params['Content-Type'] = content_type
end
# form parameters
form_params = opts[:form_params] || {}
# http body (model)
post_body = opts[:debug_body] || @api_client.object_to_http_body(user)
# return_type
return_type = opts[:debug_return_type]
# auth_names
auth_names = opts[:debug_auth_names] || []
new_options = opts.merge(
:operation => :"UserApi.create_users_with_array_input",
: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(:POST, local_var_path, new_options)
if @api_client.config.debugging
@api_client.config.logger.debug "API called: UserApi#create_users_with_array_input\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
# Creates list of users with given input array
#
# @param user [Array<User>] List of user object
# @param [Hash] opts the optional parameters
# @return [nil]
def create_users_with_list_input(user, opts = {})
create_users_with_list_input_with_http_info(user, opts)
nil
end
# Creates list of users with given input array
#
# @param user [Array<User>] List of user object
# @param [Hash] opts the optional parameters
# @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
def create_users_with_list_input_with_http_info(user, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: UserApi.create_users_with_list_input ...'
end
# verify the required parameter 'user' is set
if @api_client.config.client_side_validation && user.nil?
fail ArgumentError, "Missing the required parameter 'user' when calling UserApi.create_users_with_list_input"
end
# resource path
local_var_path = '/user/createWithList'
# query parameters
query_params = opts[:query_params] || {}
# header parameters
header_params = opts[:header_params] || {}
# HTTP header 'Content-Type'
content_type = @api_client.select_header_content_type(['application/json'])
if !content_type.nil?
header_params['Content-Type'] = content_type
end
# form parameters
form_params = opts[:form_params] || {}
# http body (model)
post_body = opts[:debug_body] || @api_client.object_to_http_body(user)
# return_type
return_type = opts[:debug_return_type]
# auth_names
auth_names = opts[:debug_auth_names] || []
new_options = opts.merge(
:operation => :"UserApi.create_users_with_list_input",
: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(:POST, local_var_path, new_options)
if @api_client.config.debugging
@api_client.config.logger.debug "API called: UserApi#create_users_with_list_input\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
# Delete user
# This can only be done by the logged in user.
# @param username [String] The name that needs to be deleted
# @param [Hash] opts the optional parameters
# @return [nil]
def delete_user(username, opts = {})
delete_user_with_http_info(username, opts)
nil
end
# Delete user
# This can only be done by the logged in user.
# @param username [String] The name that needs to be deleted
# @param [Hash] opts the optional parameters
# @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
def delete_user_with_http_info(username, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: UserApi.delete_user ...'
end
# verify the required parameter 'username' is set
if @api_client.config.client_side_validation && username.nil?
fail ArgumentError, "Missing the required parameter 'username' when calling UserApi.delete_user"
end
# resource path
local_var_path = '/user/{username}'.sub('{' + 'username' + '}', CGI.escape(username.to_s).gsub('%2F', '/'))
# query parameters
query_params = opts[:query_params] || {}
# header parameters
header_params = opts[:header_params] || {}
# form parameters
form_params = opts[:form_params] || {}
# http body (model)
post_body = opts[:debug_body]
# return_type
return_type = opts[:debug_return_type]
# auth_names
auth_names = opts[:debug_auth_names] || []
new_options = opts.merge(
:operation => :"UserApi.delete_user",
: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(:DELETE, local_var_path, new_options)
if @api_client.config.debugging
@api_client.config.logger.debug "API called: UserApi#delete_user\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
# Get user by user name
#
# @param username [String] The name that needs to be fetched. Use user1 for testing.
# @param [Hash] opts the optional parameters
# @return [User]
def get_user_by_name(username, opts = {})
data, _status_code, _headers = get_user_by_name_with_http_info(username, opts)
data
end
# Get user by user name
#
# @param username [String] The name that needs to be fetched. Use user1 for testing.
# @param [Hash] opts the optional parameters
# @return [Array<(User, Integer, Hash)>] User data, response status code and response headers
def get_user_by_name_with_http_info(username, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: UserApi.get_user_by_name ...'
end
# verify the required parameter 'username' is set
if @api_client.config.client_side_validation && username.nil?
fail ArgumentError, "Missing the required parameter 'username' when calling UserApi.get_user_by_name"
end
# resource path
local_var_path = '/user/{username}'.sub('{' + 'username' + '}', CGI.escape(username.to_s).gsub('%2F', '/'))
# 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/xml', '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] || 'User'
# auth_names
auth_names = opts[:debug_auth_names] || []
new_options = opts.merge(
:operation => :"UserApi.get_user_by_name",
: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: UserApi#get_user_by_name\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
# Logs user into the system
#
# @param username [String] The user name for login
# @param password [String] The password for login in clear text
# @param [Hash] opts the optional parameters
# @return [String]
def login_user(username, password, opts = {})
data, _status_code, _headers = login_user_with_http_info(username, password, opts)
data
end
# Logs user into the system
#
# @param username [String] The user name for login
# @param password [String] The password for login in clear text
# @param [Hash] opts the optional parameters
# @return [Array<(String, Integer, Hash)>] String data, response status code and response headers
def login_user_with_http_info(username, password, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: UserApi.login_user ...'
end
# verify the required parameter 'username' is set
if @api_client.config.client_side_validation && username.nil?
fail ArgumentError, "Missing the required parameter 'username' when calling UserApi.login_user"
end
# verify the required parameter 'password' is set
if @api_client.config.client_side_validation && password.nil?
fail ArgumentError, "Missing the required parameter 'password' when calling UserApi.login_user"
end
# resource path
local_var_path = '/user/login'
# query parameters
query_params = opts[:query_params] || {}
query_params[:'username'] = username
query_params[:'password'] = password
# header parameters
header_params = opts[:header_params] || {}
# HTTP header 'Accept' (if needed)
header_params['Accept'] = @api_client.select_header_accept(['application/xml', '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] || 'String'
# auth_names
auth_names = opts[:debug_auth_names] || []
new_options = opts.merge(
:operation => :"UserApi.login_user",
: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: UserApi#login_user\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
# Logs out current logged in user session
#
# @param [Hash] opts the optional parameters
# @return [nil]
def logout_user(opts = {})
logout_user_with_http_info(opts)
nil
end
# Logs out current logged in user session
#
# @param [Hash] opts the optional parameters
# @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
def logout_user_with_http_info(opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: UserApi.logout_user ...'
end
# resource path
local_var_path = '/user/logout'
# query parameters
query_params = opts[:query_params] || {}
# header parameters
header_params = opts[:header_params] || {}
# form parameters
form_params = opts[:form_params] || {}
# http body (model)
post_body = opts[:debug_body]
# return_type
return_type = opts[:debug_return_type]
# auth_names
auth_names = opts[:debug_auth_names] || []
new_options = opts.merge(
:operation => :"UserApi.logout_user",
: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: UserApi#logout_user\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
# Updated user
# This can only be done by the logged in user.
# @param username [String] name that need to be deleted
# @param user [User] Updated user object
# @param [Hash] opts the optional parameters
# @return [nil]
def update_user(username, user, opts = {})
update_user_with_http_info(username, user, opts)
nil
end
# Updated user
# This can only be done by the logged in user.
# @param username [String] name that need to be deleted
# @param user [User] Updated user object
# @param [Hash] opts the optional parameters
# @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
def update_user_with_http_info(username, user, opts = {})
if @api_client.config.debugging
@api_client.config.logger.debug 'Calling API: UserApi.update_user ...'
end
# verify the required parameter 'username' is set
if @api_client.config.client_side_validation && username.nil?
fail ArgumentError, "Missing the required parameter 'username' when calling UserApi.update_user"
end
# verify the required parameter 'user' is set
if @api_client.config.client_side_validation && user.nil?
fail ArgumentError, "Missing the required parameter 'user' when calling UserApi.update_user"
end
# resource path
local_var_path = '/user/{username}'.sub('{' + 'username' + '}', CGI.escape(username.to_s).gsub('%2F', '/'))
# query parameters
query_params = opts[:query_params] || {}
# header parameters
header_params = opts[:header_params] || {}
# HTTP header 'Content-Type'
content_type = @api_client.select_header_content_type(['application/json'])
if !content_type.nil?
header_params['Content-Type'] = content_type
end
# form parameters
form_params = opts[:form_params] || {}
# http body (model)
post_body = opts[:debug_body] || @api_client.object_to_http_body(user)
# return_type
return_type = opts[:debug_return_type]
# auth_names
auth_names = opts[:debug_auth_names] || []
new_options = opts.merge(
:operation => :"UserApi.update_user",
: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(:PUT, local_var_path, new_options)
if @api_client.config.debugging
@api_client.config.logger.debug "API called: UserApi#update_user\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
end
return data, status_code, headers
end
end
end

392
samples/client/petstore/ruby-autoload/lib/petstore/api_client.rb Normal file
View File

@ -0,0 +1,392 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'date'
require 'json'
require 'logger'
require 'tempfile'
require 'time'
require 'typhoeus'
module Petstore
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] || {}
follow_location = opts[:follow_location] || true
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,
:followlocation => follow_location
}
# 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 = Petstore.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 header 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)
# return nil by default
return 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

57
samples/client/petstore/ruby-autoload/lib/petstore/api_error.rb Normal file
View File

@ -0,0 +1,57 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
module Petstore
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

411
samples/client/petstore/ruby-autoload/lib/petstore/configuration.rb Normal file
View File

@ -0,0 +1,411 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
module Petstore
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 = {}
@client_side_validation = true
@verify_ssl = true
@verify_ssl_host = true
@cert_file = nil
@key_file = nil
@timeout = 0
@params_encoding = 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: 'api_key',
value: api_key_with_prefix('api_key')
},
'api_key_query' =>
{
type: 'api_key',
in: 'query',
key: 'api_key_query',
value: api_key_with_prefix('api_key_query')
},
'bearer_test' =>
{
type: 'bearer',
in: 'header',
format: 'JWT',
key: 'Authorization',
value: "Bearer #{access_token}"
},
'http_basic_test' =>
{
type: 'basic',
in: 'header',
key: 'Authorization',
value: basic_auth_token
},
'petstore_auth' =>
{
type: 'oauth2',
in: 'header',
key: 'Authorization',
value: "Bearer #{access_token}"
},
}
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"
]
}
}
},
{
url: "https://127.0.0.1/no_varaible",
description: "The local server without variables",
}
]
end
def operation_server_settings
{
"PetApi.add_pet": [
{
url: "http://petstore.swagger.io/v2",
description: "No description provided",
},
{
url: "http://path-server-test.petstore.local/v2",
description: "No description provided",
},
{
url: "http://{server}.swagger.io:{port}/v2",
description: "test server with variables",
variables: {
server: {
description: "target server",
default_value: "petstore",
enum_values: [
"petstore",
"qa-petstore",
"dev-petstore"
]
},
port: {
description: "No description provided",
default_value: "80",
enum_values: [
"80",
"8080"
]
}
}
}
],
"PetApi.update_pet": [
{
url: "http://petstore.swagger.io/v2",
description: "No description provided",
},
{
url: "http://path-server-test.petstore.local/v2",
description: "No description provided",
},
{
url: "http://{server}.swagger.io:{port}/v2",
description: "test server with variables",
variables: {
server: {
description: "target server",
default_value: "petstore",
enum_values: [
"petstore",
"qa-petstore",
"dev-petstore"
]
},
port: {
description: "No description provided",
default_value: "80",
enum_values: [
"80",
"8080"
]
}
}
}
],
}
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

232
samples/client/petstore/ruby-autoload/lib/petstore/models/additional_properties_class.rb Normal file
View File

@ -0,0 +1,232 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'date'
require 'time'
module Petstore
class AdditionalPropertiesClass
attr_accessor :map_property
attr_accessor :map_of_map_property
# Attribute mapping from ruby-style variable name to JSON key.
def self.attribute_map
{
:'map_property' => :'map_property',
:'map_of_map_property' => :'map_of_map_property'
}
end
# Returns all the JSON keys this model knows about
def self.acceptable_attributes
attribute_map.values
end
# Attribute type mapping.
def self.openapi_types
{
:'map_property' => :'Hash<String, String>',
:'map_of_map_property' => :'Hash<String, Hash<String, String>>'
}
end
# List of attributes with nullable: true
def self.openapi_nullable
Set.new([
])
end
# Initializes the object
# @param [Hash] attributes Model attributes in the form of hash
def initialize(attributes = {})
if (!attributes.is_a?(Hash))
fail ArgumentError, "The input argument (attributes) must be a hash in `Petstore::AdditionalPropertiesClass` initialize method"
end
# check to see if the attribute exists and convert string to symbol for hash key
attributes = attributes.each_with_object({}) { |(k, v), h|
if (!self.class.attribute_map.key?(k.to_sym))
fail ArgumentError, "`#{k}` is not a valid attribute in `Petstore::AdditionalPropertiesClass`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
end
h[k.to_sym] = v
}
if attributes.key?(:'map_property')
if (value = attributes[:'map_property']).is_a?(Hash)
self.map_property = value
end
end
if attributes.key?(:'map_of_map_property')
if (value = attributes[:'map_of_map_property']).is_a?(Hash)
self.map_of_map_property = value
end
end
end
# Show invalid properties with the reasons. Usually used together with valid?
# @return Array for valid properties with the reasons
def list_invalid_properties
invalid_properties = Array.new
invalid_properties
end
# Check to see if the all the properties in the model are valid
# @return true if the model is valid
def valid?
true
end
# Checks equality by comparing each attribute.
# @param [Object] Object to be compared
def ==(o)
return true if self.equal?(o)
self.class == o.class &&
map_property == o.map_property &&
map_of_map_property == o.map_of_map_property
end
# @see the `==` method
# @param [Object] Object to be compared
def eql?(o)
self == o
end
# Calculates hash code according to all attributes.
# @return [Integer] Hash code
def hash
[map_property, map_of_map_property].hash
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def self.build_from_hash(attributes)
new.build_from_hash(attributes)
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def build_from_hash(attributes)
return nil unless attributes.is_a?(Hash)
attributes = attributes.transform_keys(&:to_sym)
self.class.openapi_types.each_pair do |key, type|
if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
self.send("#{key}=", nil)
elsif type =~ /\AArray<(.*)>/i
# check to ensure the input is an array given that the attribute
# is documented as an array but the input is not
if attributes[self.class.attribute_map[key]].is_a?(Array)
self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
end
elsif !attributes[self.class.attribute_map[key]].nil?
self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
end
end
self
end
# Deserializes the data based on type
# @param string type Data type
# @param string value Value to be deserialized
# @return [Object] Deserialized data
def _deserialize(type, value)
case type.to_sym
when :Time
Time.parse(value)
when :Date
Date.parse(value)
when :String
value.to_s
when :Integer
value.to_i
when :Float
value.to_f
when :Boolean
if value.to_s =~ /\A(true|t|yes|y|1)\z/i
true
else
false
end
when :Object
# generic object (usually a Hash), return directly
value
when /\AArray<(?<inner_type>.+)>\z/
inner_type = Regexp.last_match[:inner_type]
value.map { |v| _deserialize(inner_type, v) }
when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
k_type = Regexp.last_match[:k_type]
v_type = Regexp.last_match[:v_type]
{}.tap do |hash|
value.each do |k, v|
hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
end
end
else # model
# models (e.g. Pet) or oneOf
klass = Petstore.const_get(type)
klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
end
end
# Returns the string representation of the object
# @return [String] String presentation of the object
def to_s
to_hash.to_s
end
# to_body is an alias to to_hash (backward compatibility)
# @return [Hash] Returns the object in the form of hash
def to_body
to_hash
end
# Returns the object in the form of hash
# @return [Hash] Returns the object in the form of hash
def to_hash
hash = {}
self.class.attribute_map.each_pair do |attr, param|
value = self.send(attr)
if value.nil?
is_nullable = self.class.openapi_nullable.include?(attr)
next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
end
hash[param] = _to_hash(value)
end
hash
end
# Outputs non-array value in the form of hash
# For object, use to_hash. Otherwise, just return the value
# @param [Object] value Any valid value
# @return [Hash] Returns the value in the form of hash
def _to_hash(value)
if value.is_a?(Array)
value.compact.map { |v| _to_hash(v) }
elsif value.is_a?(Hash)
{}.tap do |hash|
value.each { |k, v| hash[k] = _to_hash(v) }
end
elsif value.respond_to? :to_hash
value.to_hash
else
value
end
end
end
end

229
samples/client/petstore/ruby-autoload/lib/petstore/models/all_of_with_single_ref.rb Normal file
View File

@ -0,0 +1,229 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'date'
require 'time'
module Petstore
class AllOfWithSingleRef
attr_accessor :username
attr_accessor :single_ref_type
# Attribute mapping from ruby-style variable name to JSON key.
def self.attribute_map
{
:'username' => :'username',
:'single_ref_type' => :'SingleRefType'
}
end
# Returns all the JSON keys this model knows about
def self.acceptable_attributes
attribute_map.values
end
# Attribute type mapping.
def self.openapi_types
{
:'username' => :'String',
:'single_ref_type' => :'SingleRefType'
}
end
# List of attributes with nullable: true
def self.openapi_nullable
Set.new([
:'single_ref_type'
])
end
# Initializes the object
# @param [Hash] attributes Model attributes in the form of hash
def initialize(attributes = {})
if (!attributes.is_a?(Hash))
fail ArgumentError, "The input argument (attributes) must be a hash in `Petstore::AllOfWithSingleRef` initialize method"
end
# check to see if the attribute exists and convert string to symbol for hash key
attributes = attributes.each_with_object({}) { |(k, v), h|
if (!self.class.attribute_map.key?(k.to_sym))
fail ArgumentError, "`#{k}` is not a valid attribute in `Petstore::AllOfWithSingleRef`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
end
h[k.to_sym] = v
}
if attributes.key?(:'username')
self.username = attributes[:'username']
end
if attributes.key?(:'single_ref_type')
self.single_ref_type = attributes[:'single_ref_type']
end
end
# Show invalid properties with the reasons. Usually used together with valid?
# @return Array for valid properties with the reasons
def list_invalid_properties
invalid_properties = Array.new
invalid_properties
end
# Check to see if the all the properties in the model are valid
# @return true if the model is valid
def valid?
true
end
# Checks equality by comparing each attribute.
# @param [Object] Object to be compared
def ==(o)
return true if self.equal?(o)
self.class == o.class &&
username == o.username &&
single_ref_type == o.single_ref_type
end
# @see the `==` method
# @param [Object] Object to be compared
def eql?(o)
self == o
end
# Calculates hash code according to all attributes.
# @return [Integer] Hash code
def hash
[username, single_ref_type].hash
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def self.build_from_hash(attributes)
new.build_from_hash(attributes)
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def build_from_hash(attributes)
return nil unless attributes.is_a?(Hash)
attributes = attributes.transform_keys(&:to_sym)
self.class.openapi_types.each_pair do |key, type|
if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
self.send("#{key}=", nil)
elsif type =~ /\AArray<(.*)>/i
# check to ensure the input is an array given that the attribute
# is documented as an array but the input is not
if attributes[self.class.attribute_map[key]].is_a?(Array)
self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
end
elsif !attributes[self.class.attribute_map[key]].nil?
self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
end
end
self
end
# Deserializes the data based on type
# @param string type Data type
# @param string value Value to be deserialized
# @return [Object] Deserialized data
def _deserialize(type, value)
case type.to_sym
when :Time
Time.parse(value)
when :Date
Date.parse(value)
when :String
value.to_s
when :Integer
value.to_i
when :Float
value.to_f
when :Boolean
if value.to_s =~ /\A(true|t|yes|y|1)\z/i
true
else
false
end
when :Object
# generic object (usually a Hash), return directly
value
when /\AArray<(?<inner_type>.+)>\z/
inner_type = Regexp.last_match[:inner_type]
value.map { |v| _deserialize(inner_type, v) }
when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
k_type = Regexp.last_match[:k_type]
v_type = Regexp.last_match[:v_type]
{}.tap do |hash|
value.each do |k, v|
hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
end
end
else # model
# models (e.g. Pet) or oneOf
klass = Petstore.const_get(type)
klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
end
end
# Returns the string representation of the object
# @return [String] String presentation of the object
def to_s
to_hash.to_s
end
# to_body is an alias to to_hash (backward compatibility)
# @return [Hash] Returns the object in the form of hash
def to_body
to_hash
end
# Returns the object in the form of hash
# @return [Hash] Returns the object in the form of hash
def to_hash
hash = {}
self.class.attribute_map.each_pair do |attr, param|
value = self.send(attr)
if value.nil?
is_nullable = self.class.openapi_nullable.include?(attr)
next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
end
hash[param] = _to_hash(value)
end
hash
end
# Outputs non-array value in the form of hash
# For object, use to_hash. Otherwise, just return the value
# @param [Object] value Any valid value
# @return [Hash] Returns the value in the form of hash
def _to_hash(value)
if value.is_a?(Array)
value.compact.map { |v| _to_hash(v) }
elsif value.is_a?(Hash)
{}.tap do |hash|
value.each { |k, v| hash[k] = _to_hash(v) }
end
elsif value.respond_to? :to_hash
value.to_hash
else
value
end
end
end
end

240
samples/client/petstore/ruby-autoload/lib/petstore/models/animal.rb Normal file
View File

@ -0,0 +1,240 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'date'
require 'time'
module Petstore
class Animal
attr_accessor :class_name
attr_accessor :color
# Attribute mapping from ruby-style variable name to JSON key.
def self.attribute_map
{
:'class_name' => :'className',
:'color' => :'color'
}
end
# Returns all the JSON keys this model knows about
def self.acceptable_attributes
attribute_map.values
end
# Attribute type mapping.
def self.openapi_types
{
:'class_name' => :'String',
:'color' => :'String'
}
end
# List of attributes with nullable: true
def self.openapi_nullable
Set.new([
])
end
# discriminator's property name in OpenAPI v3
def self.openapi_discriminator_name
:'class_name'
end
# Initializes the object
# @param [Hash] attributes Model attributes in the form of hash
def initialize(attributes = {})
if (!attributes.is_a?(Hash))
fail ArgumentError, "The input argument (attributes) must be a hash in `Petstore::Animal` initialize method"
end
# check to see if the attribute exists and convert string to symbol for hash key
attributes = attributes.each_with_object({}) { |(k, v), h|
if (!self.class.attribute_map.key?(k.to_sym))
fail ArgumentError, "`#{k}` is not a valid attribute in `Petstore::Animal`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
end
h[k.to_sym] = v
}
if attributes.key?(:'class_name')
self.class_name = attributes[:'class_name']
end
if attributes.key?(:'color')
self.color = attributes[:'color']
else
self.color = 'red'
end
end
# Show invalid properties with the reasons. Usually used together with valid?
# @return Array for valid properties with the reasons
def list_invalid_properties
invalid_properties = Array.new
if @class_name.nil?
invalid_properties.push('invalid value for "class_name", class_name cannot be nil.')
end
invalid_properties
end
# Check to see if the all the properties in the model are valid
# @return true if the model is valid
def valid?
return false if @class_name.nil?
true
end
# Checks equality by comparing each attribute.
# @param [Object] Object to be compared
def ==(o)
return true if self.equal?(o)
self.class == o.class &&
class_name == o.class_name &&
color == o.color
end
# @see the `==` method
# @param [Object] Object to be compared
def eql?(o)
self == o
end
# Calculates hash code according to all attributes.
# @return [Integer] Hash code
def hash
[class_name, color].hash
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def self.build_from_hash(attributes)
new.build_from_hash(attributes)
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def build_from_hash(attributes)
return nil unless attributes.is_a?(Hash)
attributes = attributes.transform_keys(&:to_sym)
self.class.openapi_types.each_pair do |key, type|
if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
self.send("#{key}=", nil)
elsif type =~ /\AArray<(.*)>/i
# check to ensure the input is an array given that the attribute
# is documented as an array but the input is not
if attributes[self.class.attribute_map[key]].is_a?(Array)
self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
end
elsif !attributes[self.class.attribute_map[key]].nil?
self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
end
end
self
end
# Deserializes the data based on type
# @param string type Data type
# @param string value Value to be deserialized
# @return [Object] Deserialized data
def _deserialize(type, value)
case type.to_sym
when :Time
Time.parse(value)
when :Date
Date.parse(value)
when :String
value.to_s
when :Integer
value.to_i
when :Float
value.to_f
when :Boolean
if value.to_s =~ /\A(true|t|yes|y|1)\z/i
true
else
false
end
when :Object
# generic object (usually a Hash), return directly
value
when /\AArray<(?<inner_type>.+)>\z/
inner_type = Regexp.last_match[:inner_type]
value.map { |v| _deserialize(inner_type, v) }
when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
k_type = Regexp.last_match[:k_type]
v_type = Regexp.last_match[:v_type]
{}.tap do |hash|
value.each do |k, v|
hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
end
end
else # model
# models (e.g. Pet) or oneOf
klass = Petstore.const_get(type)
klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
end
end
# Returns the string representation of the object
# @return [String] String presentation of the object
def to_s
to_hash.to_s
end
# to_body is an alias to to_hash (backward compatibility)
# @return [Hash] Returns the object in the form of hash
def to_body
to_hash
end
# Returns the object in the form of hash
# @return [Hash] Returns the object in the form of hash
def to_hash
hash = {}
self.class.attribute_map.each_pair do |attr, param|
value = self.send(attr)
if value.nil?
is_nullable = self.class.openapi_nullable.include?(attr)
next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
end
hash[param] = _to_hash(value)
end
hash
end
# Outputs non-array value in the form of hash
# For object, use to_hash. Otherwise, just return the value
# @param [Object] value Any valid value
# @return [Hash] Returns the value in the form of hash
def _to_hash(value)
if value.is_a?(Array)
value.compact.map { |v| _to_hash(v) }
elsif value.is_a?(Hash)
{}.tap do |hash|
value.each { |k, v| hash[k] = _to_hash(v) }
end
elsif value.respond_to? :to_hash
value.to_hash
else
value
end
end
end
end

237
samples/client/petstore/ruby-autoload/lib/petstore/models/api_response.rb Normal file
View File

@ -0,0 +1,237 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'date'
require 'time'
module Petstore
class ApiResponse
attr_accessor :code
attr_accessor :type
attr_accessor :message
# Attribute mapping from ruby-style variable name to JSON key.
def self.attribute_map
{
:'code' => :'code',
:'type' => :'type',
:'message' => :'message'
}
end
# Returns all the JSON keys this model knows about
def self.acceptable_attributes
attribute_map.values
end
# Attribute type mapping.
def self.openapi_types
{
:'code' => :'Integer',
:'type' => :'String',
:'message' => :'String'
}
end
# List of attributes with nullable: true
def self.openapi_nullable
Set.new([
])
end
# Initializes the object
# @param [Hash] attributes Model attributes in the form of hash
def initialize(attributes = {})
if (!attributes.is_a?(Hash))
fail ArgumentError, "The input argument (attributes) must be a hash in `Petstore::ApiResponse` initialize method"
end
# check to see if the attribute exists and convert string to symbol for hash key
attributes = attributes.each_with_object({}) { |(k, v), h|
if (!self.class.attribute_map.key?(k.to_sym))
fail ArgumentError, "`#{k}` is not a valid attribute in `Petstore::ApiResponse`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
end
h[k.to_sym] = v
}
if attributes.key?(:'code')
self.code = attributes[:'code']
end
if attributes.key?(:'type')
self.type = attributes[:'type']
end
if attributes.key?(:'message')
self.message = attributes[:'message']
end
end
# Show invalid properties with the reasons. Usually used together with valid?
# @return Array for valid properties with the reasons
def list_invalid_properties
invalid_properties = Array.new
invalid_properties
end
# Check to see if the all the properties in the model are valid
# @return true if the model is valid
def valid?
true
end
# Checks equality by comparing each attribute.
# @param [Object] Object to be compared
def ==(o)
return true if self.equal?(o)
self.class == o.class &&
code == o.code &&
type == o.type &&
message == o.message
end
# @see the `==` method
# @param [Object] Object to be compared
def eql?(o)
self == o
end
# Calculates hash code according to all attributes.
# @return [Integer] Hash code
def hash
[code, type, message].hash
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def self.build_from_hash(attributes)
new.build_from_hash(attributes)
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def build_from_hash(attributes)
return nil unless attributes.is_a?(Hash)
attributes = attributes.transform_keys(&:to_sym)
self.class.openapi_types.each_pair do |key, type|
if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
self.send("#{key}=", nil)
elsif type =~ /\AArray<(.*)>/i
# check to ensure the input is an array given that the attribute
# is documented as an array but the input is not
if attributes[self.class.attribute_map[key]].is_a?(Array)
self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
end
elsif !attributes[self.class.attribute_map[key]].nil?
self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
end
end
self
end
# Deserializes the data based on type
# @param string type Data type
# @param string value Value to be deserialized
# @return [Object] Deserialized data
def _deserialize(type, value)
case type.to_sym
when :Time
Time.parse(value)
when :Date
Date.parse(value)
when :String
value.to_s
when :Integer
value.to_i
when :Float
value.to_f
when :Boolean
if value.to_s =~ /\A(true|t|yes|y|1)\z/i
true
else
false
end
when :Object
# generic object (usually a Hash), return directly
value
when /\AArray<(?<inner_type>.+)>\z/
inner_type = Regexp.last_match[:inner_type]
value.map { |v| _deserialize(inner_type, v) }
when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
k_type = Regexp.last_match[:k_type]
v_type = Regexp.last_match[:v_type]
{}.tap do |hash|
value.each do |k, v|
hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
end
end
else # model
# models (e.g. Pet) or oneOf
klass = Petstore.const_get(type)
klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
end
end
# Returns the string representation of the object
# @return [String] String presentation of the object
def to_s
to_hash.to_s
end
# to_body is an alias to to_hash (backward compatibility)
# @return [Hash] Returns the object in the form of hash
def to_body
to_hash
end
# Returns the object in the form of hash
# @return [Hash] Returns the object in the form of hash
def to_hash
hash = {}
self.class.attribute_map.each_pair do |attr, param|
value = self.send(attr)
if value.nil?
is_nullable = self.class.openapi_nullable.include?(attr)
next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
end
hash[param] = _to_hash(value)
end
hash
end
# Outputs non-array value in the form of hash
# For object, use to_hash. Otherwise, just return the value
# @param [Object] value Any valid value
# @return [Hash] Returns the value in the form of hash
def _to_hash(value)
if value.is_a?(Array)
value.compact.map { |v| _to_hash(v) }
elsif value.is_a?(Hash)
{}.tap do |hash|
value.each { |k, v| hash[k] = _to_hash(v) }
end
elsif value.respond_to? :to_hash
value.to_hash
else
value
end
end
end
end

221
samples/client/petstore/ruby-autoload/lib/petstore/models/array_of_array_of_number_only.rb Normal file
View File

@ -0,0 +1,221 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'date'
require 'time'
module Petstore
class ArrayOfArrayOfNumberOnly
attr_accessor :array_array_number
# Attribute mapping from ruby-style variable name to JSON key.
def self.attribute_map
{
:'array_array_number' => :'ArrayArrayNumber'
}
end
# Returns all the JSON keys this model knows about
def self.acceptable_attributes
attribute_map.values
end
# Attribute type mapping.
def self.openapi_types
{
:'array_array_number' => :'Array<Array<Float>>'
}
end
# List of attributes with nullable: true
def self.openapi_nullable
Set.new([
])
end
# Initializes the object
# @param [Hash] attributes Model attributes in the form of hash
def initialize(attributes = {})
if (!attributes.is_a?(Hash))
fail ArgumentError, "The input argument (attributes) must be a hash in `Petstore::ArrayOfArrayOfNumberOnly` initialize method"
end
# check to see if the attribute exists and convert string to symbol for hash key
attributes = attributes.each_with_object({}) { |(k, v), h|
if (!self.class.attribute_map.key?(k.to_sym))
fail ArgumentError, "`#{k}` is not a valid attribute in `Petstore::ArrayOfArrayOfNumberOnly`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
end
h[k.to_sym] = v
}
if attributes.key?(:'array_array_number')
if (value = attributes[:'array_array_number']).is_a?(Array)
self.array_array_number = value
end
end
end
# Show invalid properties with the reasons. Usually used together with valid?
# @return Array for valid properties with the reasons
def list_invalid_properties
invalid_properties = Array.new
invalid_properties
end
# Check to see if the all the properties in the model are valid
# @return true if the model is valid
def valid?
true
end
# Checks equality by comparing each attribute.
# @param [Object] Object to be compared
def ==(o)
return true if self.equal?(o)
self.class == o.class &&
array_array_number == o.array_array_number
end
# @see the `==` method
# @param [Object] Object to be compared
def eql?(o)
self == o
end
# Calculates hash code according to all attributes.
# @return [Integer] Hash code
def hash
[array_array_number].hash
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def self.build_from_hash(attributes)
new.build_from_hash(attributes)
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def build_from_hash(attributes)
return nil unless attributes.is_a?(Hash)
attributes = attributes.transform_keys(&:to_sym)
self.class.openapi_types.each_pair do |key, type|
if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
self.send("#{key}=", nil)
elsif type =~ /\AArray<(.*)>/i
# check to ensure the input is an array given that the attribute
# is documented as an array but the input is not
if attributes[self.class.attribute_map[key]].is_a?(Array)
self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
end
elsif !attributes[self.class.attribute_map[key]].nil?
self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
end
end
self
end
# Deserializes the data based on type
# @param string type Data type
# @param string value Value to be deserialized
# @return [Object] Deserialized data
def _deserialize(type, value)
case type.to_sym
when :Time
Time.parse(value)
when :Date
Date.parse(value)
when :String
value.to_s
when :Integer
value.to_i
when :Float
value.to_f
when :Boolean
if value.to_s =~ /\A(true|t|yes|y|1)\z/i
true
else
false
end
when :Object
# generic object (usually a Hash), return directly
value
when /\AArray<(?<inner_type>.+)>\z/
inner_type = Regexp.last_match[:inner_type]
value.map { |v| _deserialize(inner_type, v) }
when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
k_type = Regexp.last_match[:k_type]
v_type = Regexp.last_match[:v_type]
{}.tap do |hash|
value.each do |k, v|
hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
end
end
else # model
# models (e.g. Pet) or oneOf
klass = Petstore.const_get(type)
klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
end
end
# Returns the string representation of the object
# @return [String] String presentation of the object
def to_s
to_hash.to_s
end
# to_body is an alias to to_hash (backward compatibility)
# @return [Hash] Returns the object in the form of hash
def to_body
to_hash
end
# Returns the object in the form of hash
# @return [Hash] Returns the object in the form of hash
def to_hash
hash = {}
self.class.attribute_map.each_pair do |attr, param|
value = self.send(attr)
if value.nil?
is_nullable = self.class.openapi_nullable.include?(attr)
next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
end
hash[param] = _to_hash(value)
end
hash
end
# Outputs non-array value in the form of hash
# For object, use to_hash. Otherwise, just return the value
# @param [Object] value Any valid value
# @return [Hash] Returns the value in the form of hash
def _to_hash(value)
if value.is_a?(Array)
value.compact.map { |v| _to_hash(v) }
elsif value.is_a?(Hash)
{}.tap do |hash|
value.each { |k, v| hash[k] = _to_hash(v) }
end
elsif value.respond_to? :to_hash
value.to_hash
else
value
end
end
end
end

221
samples/client/petstore/ruby-autoload/lib/petstore/models/array_of_number_only.rb Normal file
View File

@ -0,0 +1,221 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'date'
require 'time'
module Petstore
class ArrayOfNumberOnly
attr_accessor :array_number
# Attribute mapping from ruby-style variable name to JSON key.
def self.attribute_map
{
:'array_number' => :'ArrayNumber'
}
end
# Returns all the JSON keys this model knows about
def self.acceptable_attributes
attribute_map.values
end
# Attribute type mapping.
def self.openapi_types
{
:'array_number' => :'Array<Float>'
}
end
# List of attributes with nullable: true
def self.openapi_nullable
Set.new([
])
end
# Initializes the object
# @param [Hash] attributes Model attributes in the form of hash
def initialize(attributes = {})
if (!attributes.is_a?(Hash))
fail ArgumentError, "The input argument (attributes) must be a hash in `Petstore::ArrayOfNumberOnly` initialize method"
end
# check to see if the attribute exists and convert string to symbol for hash key
attributes = attributes.each_with_object({}) { |(k, v), h|
if (!self.class.attribute_map.key?(k.to_sym))
fail ArgumentError, "`#{k}` is not a valid attribute in `Petstore::ArrayOfNumberOnly`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
end
h[k.to_sym] = v
}
if attributes.key?(:'array_number')
if (value = attributes[:'array_number']).is_a?(Array)
self.array_number = value
end
end
end
# Show invalid properties with the reasons. Usually used together with valid?
# @return Array for valid properties with the reasons
def list_invalid_properties
invalid_properties = Array.new
invalid_properties
end
# Check to see if the all the properties in the model are valid
# @return true if the model is valid
def valid?
true
end
# Checks equality by comparing each attribute.
# @param [Object] Object to be compared
def ==(o)
return true if self.equal?(o)
self.class == o.class &&
array_number == o.array_number
end
# @see the `==` method
# @param [Object] Object to be compared
def eql?(o)
self == o
end
# Calculates hash code according to all attributes.
# @return [Integer] Hash code
def hash
[array_number].hash
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def self.build_from_hash(attributes)
new.build_from_hash(attributes)
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def build_from_hash(attributes)
return nil unless attributes.is_a?(Hash)
attributes = attributes.transform_keys(&:to_sym)
self.class.openapi_types.each_pair do |key, type|
if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
self.send("#{key}=", nil)
elsif type =~ /\AArray<(.*)>/i
# check to ensure the input is an array given that the attribute
# is documented as an array but the input is not
if attributes[self.class.attribute_map[key]].is_a?(Array)
self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
end
elsif !attributes[self.class.attribute_map[key]].nil?
self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
end
end
self
end
# Deserializes the data based on type
# @param string type Data type
# @param string value Value to be deserialized
# @return [Object] Deserialized data
def _deserialize(type, value)
case type.to_sym
when :Time
Time.parse(value)
when :Date
Date.parse(value)
when :String
value.to_s
when :Integer
value.to_i
when :Float
value.to_f
when :Boolean
if value.to_s =~ /\A(true|t|yes|y|1)\z/i
true
else
false
end
when :Object
# generic object (usually a Hash), return directly
value
when /\AArray<(?<inner_type>.+)>\z/
inner_type = Regexp.last_match[:inner_type]
value.map { |v| _deserialize(inner_type, v) }
when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
k_type = Regexp.last_match[:k_type]
v_type = Regexp.last_match[:v_type]
{}.tap do |hash|
value.each do |k, v|
hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
end
end
else # model
# models (e.g. Pet) or oneOf
klass = Petstore.const_get(type)
klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
end
end
# Returns the string representation of the object
# @return [String] String presentation of the object
def to_s
to_hash.to_s
end
# to_body is an alias to to_hash (backward compatibility)
# @return [Hash] Returns the object in the form of hash
def to_body
to_hash
end
# Returns the object in the form of hash
# @return [Hash] Returns the object in the form of hash
def to_hash
hash = {}
self.class.attribute_map.each_pair do |attr, param|
value = self.send(attr)
if value.nil?
is_nullable = self.class.openapi_nullable.include?(attr)
next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
end
hash[param] = _to_hash(value)
end
hash
end
# Outputs non-array value in the form of hash
# For object, use to_hash. Otherwise, just return the value
# @param [Object] value Any valid value
# @return [Hash] Returns the value in the form of hash
def _to_hash(value)
if value.is_a?(Array)
value.compact.map { |v| _to_hash(v) }
elsif value.is_a?(Hash)
{}.tap do |hash|
value.each { |k, v| hash[k] = _to_hash(v) }
end
elsif value.respond_to? :to_hash
value.to_hash
else
value
end
end
end
end

267
samples/client/petstore/ruby-autoload/lib/petstore/models/array_test.rb Normal file
View File

@ -0,0 +1,267 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'date'
require 'time'
module Petstore
class ArrayTest
attr_accessor :array_of_string
attr_accessor :array_array_of_integer
attr_accessor :array_array_of_model
# Attribute mapping from ruby-style variable name to JSON key.
def self.attribute_map
{
:'array_of_string' => :'array_of_string',
:'array_array_of_integer' => :'array_array_of_integer',
:'array_array_of_model' => :'array_array_of_model'
}
end
# Returns all the JSON keys this model knows about
def self.acceptable_attributes
attribute_map.values
end
# Attribute type mapping.
def self.openapi_types
{
:'array_of_string' => :'Array<String>',
:'array_array_of_integer' => :'Array<Array<Integer>>',
:'array_array_of_model' => :'Array<Array<ReadOnlyFirst>>'
}
end
# List of attributes with nullable: true
def self.openapi_nullable
Set.new([
])
end
# Initializes the object
# @param [Hash] attributes Model attributes in the form of hash
def initialize(attributes = {})
if (!attributes.is_a?(Hash))
fail ArgumentError, "The input argument (attributes) must be a hash in `Petstore::ArrayTest` initialize method"
end
# check to see if the attribute exists and convert string to symbol for hash key
attributes = attributes.each_with_object({}) { |(k, v), h|
if (!self.class.attribute_map.key?(k.to_sym))
fail ArgumentError, "`#{k}` is not a valid attribute in `Petstore::ArrayTest`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
end
h[k.to_sym] = v
}
if attributes.key?(:'array_of_string')
if (value = attributes[:'array_of_string']).is_a?(Array)
self.array_of_string = value
end
end
if attributes.key?(:'array_array_of_integer')
if (value = attributes[:'array_array_of_integer']).is_a?(Array)
self.array_array_of_integer = value
end
end
if attributes.key?(:'array_array_of_model')
if (value = attributes[:'array_array_of_model']).is_a?(Array)
self.array_array_of_model = value
end
end
end
# Show invalid properties with the reasons. Usually used together with valid?
# @return Array for valid properties with the reasons
def list_invalid_properties
invalid_properties = Array.new
if !@array_of_string.nil? && @array_of_string.length > 3
invalid_properties.push('invalid value for "array_of_string", number of items must be less than or equal to 3.')
end
if !@array_of_string.nil? && @array_of_string.length < 0
invalid_properties.push('invalid value for "array_of_string", number of items must be greater than or equal to 0.')
end
invalid_properties
end
# Check to see if the all the properties in the model are valid
# @return true if the model is valid
def valid?
return false if !@array_of_string.nil? && @array_of_string.length > 3
return false if !@array_of_string.nil? && @array_of_string.length < 0
true
end
# Custom attribute writer method with validation
# @param [Object] array_of_string Value to be assigned
def array_of_string=(array_of_string)
if !array_of_string.nil? && array_of_string.length > 3
fail ArgumentError, 'invalid value for "array_of_string", number of items must be less than or equal to 3.'
end
if !array_of_string.nil? && array_of_string.length < 0
fail ArgumentError, 'invalid value for "array_of_string", number of items must be greater than or equal to 0.'
end
@array_of_string = array_of_string
end
# Checks equality by comparing each attribute.
# @param [Object] Object to be compared
def ==(o)
return true if self.equal?(o)
self.class == o.class &&
array_of_string == o.array_of_string &&
array_array_of_integer == o.array_array_of_integer &&
array_array_of_model == o.array_array_of_model
end
# @see the `==` method
# @param [Object] Object to be compared
def eql?(o)
self == o
end
# Calculates hash code according to all attributes.
# @return [Integer] Hash code
def hash
[array_of_string, array_array_of_integer, array_array_of_model].hash
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def self.build_from_hash(attributes)
new.build_from_hash(attributes)
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def build_from_hash(attributes)
return nil unless attributes.is_a?(Hash)
attributes = attributes.transform_keys(&:to_sym)
self.class.openapi_types.each_pair do |key, type|
if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
self.send("#{key}=", nil)
elsif type =~ /\AArray<(.*)>/i
# check to ensure the input is an array given that the attribute
# is documented as an array but the input is not
if attributes[self.class.attribute_map[key]].is_a?(Array)
self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
end
elsif !attributes[self.class.attribute_map[key]].nil?
self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
end
end
self
end
# Deserializes the data based on type
# @param string type Data type
# @param string value Value to be deserialized
# @return [Object] Deserialized data
def _deserialize(type, value)
case type.to_sym
when :Time
Time.parse(value)
when :Date
Date.parse(value)
when :String
value.to_s
when :Integer
value.to_i
when :Float
value.to_f
when :Boolean
if value.to_s =~ /\A(true|t|yes|y|1)\z/i
true
else
false
end
when :Object
# generic object (usually a Hash), return directly
value
when /\AArray<(?<inner_type>.+)>\z/
inner_type = Regexp.last_match[:inner_type]
value.map { |v| _deserialize(inner_type, v) }
when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
k_type = Regexp.last_match[:k_type]
v_type = Regexp.last_match[:v_type]
{}.tap do |hash|
value.each do |k, v|
hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
end
end
else # model
# models (e.g. Pet) or oneOf
klass = Petstore.const_get(type)
klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
end
end
# Returns the string representation of the object
# @return [String] String presentation of the object
def to_s
to_hash.to_s
end
# to_body is an alias to to_hash (backward compatibility)
# @return [Hash] Returns the object in the form of hash
def to_body
to_hash
end
# Returns the object in the form of hash
# @return [Hash] Returns the object in the form of hash
def to_hash
hash = {}
self.class.attribute_map.each_pair do |attr, param|
value = self.send(attr)
if value.nil?
is_nullable = self.class.openapi_nullable.include?(attr)
next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
end
hash[param] = _to_hash(value)
end
hash
end
# Outputs non-array value in the form of hash
# For object, use to_hash. Otherwise, just return the value
# @param [Object] value Any valid value
# @return [Hash] Returns the value in the form of hash
def _to_hash(value)
if value.is_a?(Array)
value.compact.map { |v| _to_hash(v) }
elsif value.is_a?(Hash)
{}.tap do |hash|
value.each { |k, v| hash[k] = _to_hash(v) }
end
elsif value.respond_to? :to_hash
value.to_hash
else
value
end
end
end
end

265
samples/client/petstore/ruby-autoload/lib/petstore/models/capitalization.rb Normal file
View File

@ -0,0 +1,265 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'date'
require 'time'
module Petstore
class Capitalization
attr_accessor :small_camel
attr_accessor :capital_camel
attr_accessor :small_snake
attr_accessor :capital_snake
attr_accessor :sca_eth_flow_points
# Name of the pet
attr_accessor :att_name
# Attribute mapping from ruby-style variable name to JSON key.
def self.attribute_map
{
:'small_camel' => :'smallCamel',
:'capital_camel' => :'CapitalCamel',
:'small_snake' => :'small_Snake',
:'capital_snake' => :'Capital_Snake',
:'sca_eth_flow_points' => :'SCA_ETH_Flow_Points',
:'att_name' => :'ATT_NAME'
}
end
# Returns all the JSON keys this model knows about
def self.acceptable_attributes
attribute_map.values
end
# Attribute type mapping.
def self.openapi_types
{
:'small_camel' => :'String',
:'capital_camel' => :'String',
:'small_snake' => :'String',
:'capital_snake' => :'String',
:'sca_eth_flow_points' => :'String',
:'att_name' => :'String'
}
end
# List of attributes with nullable: true
def self.openapi_nullable
Set.new([
])
end
# Initializes the object
# @param [Hash] attributes Model attributes in the form of hash
def initialize(attributes = {})
if (!attributes.is_a?(Hash))
fail ArgumentError, "The input argument (attributes) must be a hash in `Petstore::Capitalization` initialize method"
end
# check to see if the attribute exists and convert string to symbol for hash key
attributes = attributes.each_with_object({}) { |(k, v), h|
if (!self.class.attribute_map.key?(k.to_sym))
fail ArgumentError, "`#{k}` is not a valid attribute in `Petstore::Capitalization`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
end
h[k.to_sym] = v
}
if attributes.key?(:'small_camel')
self.small_camel = attributes[:'small_camel']
end
if attributes.key?(:'capital_camel')
self.capital_camel = attributes[:'capital_camel']
end
if attributes.key?(:'small_snake')
self.small_snake = attributes[:'small_snake']
end
if attributes.key?(:'capital_snake')
self.capital_snake = attributes[:'capital_snake']
end
if attributes.key?(:'sca_eth_flow_points')
self.sca_eth_flow_points = attributes[:'sca_eth_flow_points']
end
if attributes.key?(:'att_name')
self.att_name = attributes[:'att_name']
end
end
# Show invalid properties with the reasons. Usually used together with valid?
# @return Array for valid properties with the reasons
def list_invalid_properties
invalid_properties = Array.new
invalid_properties
end
# Check to see if the all the properties in the model are valid
# @return true if the model is valid
def valid?
true
end
# Checks equality by comparing each attribute.
# @param [Object] Object to be compared
def ==(o)
return true if self.equal?(o)
self.class == o.class &&
small_camel == o.small_camel &&
capital_camel == o.capital_camel &&
small_snake == o.small_snake &&
capital_snake == o.capital_snake &&
sca_eth_flow_points == o.sca_eth_flow_points &&
att_name == o.att_name
end
# @see the `==` method
# @param [Object] Object to be compared
def eql?(o)
self == o
end
# Calculates hash code according to all attributes.
# @return [Integer] Hash code
def hash
[small_camel, capital_camel, small_snake, capital_snake, sca_eth_flow_points, att_name].hash
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def self.build_from_hash(attributes)
new.build_from_hash(attributes)
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def build_from_hash(attributes)
return nil unless attributes.is_a?(Hash)
attributes = attributes.transform_keys(&:to_sym)
self.class.openapi_types.each_pair do |key, type|
if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
self.send("#{key}=", nil)
elsif type =~ /\AArray<(.*)>/i
# check to ensure the input is an array given that the attribute
# is documented as an array but the input is not
if attributes[self.class.attribute_map[key]].is_a?(Array)
self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
end
elsif !attributes[self.class.attribute_map[key]].nil?
self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
end
end
self
end
# Deserializes the data based on type
# @param string type Data type
# @param string value Value to be deserialized
# @return [Object] Deserialized data
def _deserialize(type, value)
case type.to_sym
when :Time
Time.parse(value)
when :Date
Date.parse(value)
when :String
value.to_s
when :Integer
value.to_i
when :Float
value.to_f
when :Boolean
if value.to_s =~ /\A(true|t|yes|y|1)\z/i
true
else
false
end
when :Object
# generic object (usually a Hash), return directly
value
when /\AArray<(?<inner_type>.+)>\z/
inner_type = Regexp.last_match[:inner_type]
value.map { |v| _deserialize(inner_type, v) }
when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
k_type = Regexp.last_match[:k_type]
v_type = Regexp.last_match[:v_type]
{}.tap do |hash|
value.each do |k, v|
hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
end
end
else # model
# models (e.g. Pet) or oneOf
klass = Petstore.const_get(type)
klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
end
end
# Returns the string representation of the object
# @return [String] String presentation of the object
def to_s
to_hash.to_s
end
# to_body is an alias to to_hash (backward compatibility)
# @return [Hash] Returns the object in the form of hash
def to_body
to_hash
end
# Returns the object in the form of hash
# @return [Hash] Returns the object in the form of hash
def to_hash
hash = {}
self.class.attribute_map.each_pair do |attr, param|
value = self.send(attr)
if value.nil?
is_nullable = self.class.openapi_nullable.include?(attr)
next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
end
hash[param] = _to_hash(value)
end
hash
end
# Outputs non-array value in the form of hash
# For object, use to_hash. Otherwise, just return the value
# @param [Object] value Any valid value
# @return [Hash] Returns the value in the form of hash
def _to_hash(value)
if value.is_a?(Array)
value.compact.map { |v| _to_hash(v) }
elsif value.is_a?(Hash)
{}.tap do |hash|
value.each { |k, v| hash[k] = _to_hash(v) }
end
elsif value.respond_to? :to_hash
value.to_hash
else
value
end
end
end
end

231
samples/client/petstore/ruby-autoload/lib/petstore/models/cat.rb Normal file
View File

@ -0,0 +1,231 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'date'
require 'time'
module Petstore
class Cat < Animal
attr_accessor :declawed
# Attribute mapping from ruby-style variable name to JSON key.
def self.attribute_map
{
:'declawed' => :'declawed'
}
end
# Returns all the JSON keys this model knows about, including the ones defined in its parent(s)
def self.acceptable_attributes
attribute_map.values.concat(superclass.acceptable_attributes)
end
# Attribute type mapping.
def self.openapi_types
{
:'declawed' => :'Boolean'
}
end
# List of attributes with nullable: true
def self.openapi_nullable
Set.new([
])
end
# List of class defined in allOf (OpenAPI v3)
def self.openapi_all_of
[
:'Animal',
:'CatAllOf'
]
end
# Initializes the object
# @param [Hash] attributes Model attributes in the form of hash
def initialize(attributes = {})
if (!attributes.is_a?(Hash))
fail ArgumentError, "The input argument (attributes) must be a hash in `Petstore::Cat` initialize method"
end
# check to see if the attribute exists and convert string to symbol for hash key
attributes = attributes.each_with_object({}) { |(k, v), h|
if (!self.class.attribute_map.key?(k.to_sym))
fail ArgumentError, "`#{k}` is not a valid attribute in `Petstore::Cat`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
end
h[k.to_sym] = v
}
# call parent's initialize
super(attributes)
if attributes.key?(:'declawed')
self.declawed = attributes[:'declawed']
end
end
# Show invalid properties with the reasons. Usually used together with valid?
# @return Array for valid properties with the reasons
def list_invalid_properties
invalid_properties = super
invalid_properties
end
# Check to see if the all the properties in the model are valid
# @return true if the model is valid
def valid?
true && super
end
# Checks equality by comparing each attribute.
# @param [Object] Object to be compared
def ==(o)
return true if self.equal?(o)
self.class == o.class &&
declawed == o.declawed && super(o)
end
# @see the `==` method
# @param [Object] Object to be compared
def eql?(o)
self == o
end
# Calculates hash code according to all attributes.
# @return [Integer] Hash code
def hash
[declawed].hash
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def self.build_from_hash(attributes)
new.build_from_hash(attributes)
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def build_from_hash(attributes)
return nil unless attributes.is_a?(Hash)
super(attributes)
attributes = attributes.transform_keys(&:to_sym)
self.class.openapi_types.each_pair do |key, type|
if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
self.send("#{key}=", nil)
elsif type =~ /\AArray<(.*)>/i
# check to ensure the input is an array given that the attribute
# is documented as an array but the input is not
if attributes[self.class.attribute_map[key]].is_a?(Array)
self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
end
elsif !attributes[self.class.attribute_map[key]].nil?
self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
end
end
self
end
# Deserializes the data based on type
# @param string type Data type
# @param string value Value to be deserialized
# @return [Object] Deserialized data
def _deserialize(type, value)
case type.to_sym
when :Time
Time.parse(value)
when :Date
Date.parse(value)
when :String
value.to_s
when :Integer
value.to_i
when :Float
value.to_f
when :Boolean
if value.to_s =~ /\A(true|t|yes|y|1)\z/i
true
else
false
end
when :Object
# generic object (usually a Hash), return directly
value
when /\AArray<(?<inner_type>.+)>\z/
inner_type = Regexp.last_match[:inner_type]
value.map { |v| _deserialize(inner_type, v) }
when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
k_type = Regexp.last_match[:k_type]
v_type = Regexp.last_match[:v_type]
{}.tap do |hash|
value.each do |k, v|
hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
end
end
else # model
# models (e.g. Pet) or oneOf
klass = Petstore.const_get(type)
klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
end
end
# Returns the string representation of the object
# @return [String] String presentation of the object
def to_s
to_hash.to_s
end
# to_body is an alias to to_hash (backward compatibility)
# @return [Hash] Returns the object in the form of hash
def to_body
to_hash
end
# Returns the object in the form of hash
# @return [Hash] Returns the object in the form of hash
def to_hash
hash = super
self.class.attribute_map.each_pair do |attr, param|
value = self.send(attr)
if value.nil?
is_nullable = self.class.openapi_nullable.include?(attr)
next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
end
hash[param] = _to_hash(value)
end
hash
end
# Outputs non-array value in the form of hash
# For object, use to_hash. Otherwise, just return the value
# @param [Object] value Any valid value
# @return [Hash] Returns the value in the form of hash
def _to_hash(value)
if value.is_a?(Array)
value.compact.map { |v| _to_hash(v) }
elsif value.is_a?(Hash)
{}.tap do |hash|
value.each { |k, v| hash[k] = _to_hash(v) }
end
elsif value.respond_to? :to_hash
value.to_hash
else
value
end
end
end
end

219
samples/client/petstore/ruby-autoload/lib/petstore/models/cat_all_of.rb Normal file
View File

@ -0,0 +1,219 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'date'
require 'time'
module Petstore
class CatAllOf
attr_accessor :declawed
# Attribute mapping from ruby-style variable name to JSON key.
def self.attribute_map
{
:'declawed' => :'declawed'
}
end
# Returns all the JSON keys this model knows about
def self.acceptable_attributes
attribute_map.values
end
# Attribute type mapping.
def self.openapi_types
{
:'declawed' => :'Boolean'
}
end
# List of attributes with nullable: true
def self.openapi_nullable
Set.new([
])
end
# Initializes the object
# @param [Hash] attributes Model attributes in the form of hash
def initialize(attributes = {})
if (!attributes.is_a?(Hash))
fail ArgumentError, "The input argument (attributes) must be a hash in `Petstore::CatAllOf` initialize method"
end
# check to see if the attribute exists and convert string to symbol for hash key
attributes = attributes.each_with_object({}) { |(k, v), h|
if (!self.class.attribute_map.key?(k.to_sym))
fail ArgumentError, "`#{k}` is not a valid attribute in `Petstore::CatAllOf`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
end
h[k.to_sym] = v
}
if attributes.key?(:'declawed')
self.declawed = attributes[:'declawed']
end
end
# Show invalid properties with the reasons. Usually used together with valid?
# @return Array for valid properties with the reasons
def list_invalid_properties
invalid_properties = Array.new
invalid_properties
end
# Check to see if the all the properties in the model are valid
# @return true if the model is valid
def valid?
true
end
# Checks equality by comparing each attribute.
# @param [Object] Object to be compared
def ==(o)
return true if self.equal?(o)
self.class == o.class &&
declawed == o.declawed
end
# @see the `==` method
# @param [Object] Object to be compared
def eql?(o)
self == o
end
# Calculates hash code according to all attributes.
# @return [Integer] Hash code
def hash
[declawed].hash
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def self.build_from_hash(attributes)
new.build_from_hash(attributes)
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def build_from_hash(attributes)
return nil unless attributes.is_a?(Hash)
attributes = attributes.transform_keys(&:to_sym)
self.class.openapi_types.each_pair do |key, type|
if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
self.send("#{key}=", nil)
elsif type =~ /\AArray<(.*)>/i
# check to ensure the input is an array given that the attribute
# is documented as an array but the input is not
if attributes[self.class.attribute_map[key]].is_a?(Array)
self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
end
elsif !attributes[self.class.attribute_map[key]].nil?
self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
end
end
self
end
# Deserializes the data based on type
# @param string type Data type
# @param string value Value to be deserialized
# @return [Object] Deserialized data
def _deserialize(type, value)
case type.to_sym
when :Time
Time.parse(value)
when :Date
Date.parse(value)
when :String
value.to_s
when :Integer
value.to_i
when :Float
value.to_f
when :Boolean
if value.to_s =~ /\A(true|t|yes|y|1)\z/i
true
else
false
end
when :Object
# generic object (usually a Hash), return directly
value
when /\AArray<(?<inner_type>.+)>\z/
inner_type = Regexp.last_match[:inner_type]
value.map { |v| _deserialize(inner_type, v) }
when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
k_type = Regexp.last_match[:k_type]
v_type = Regexp.last_match[:v_type]
{}.tap do |hash|
value.each do |k, v|
hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
end
end
else # model
# models (e.g. Pet) or oneOf
klass = Petstore.const_get(type)
klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
end
end
# Returns the string representation of the object
# @return [String] String presentation of the object
def to_s
to_hash.to_s
end
# to_body is an alias to to_hash (backward compatibility)
# @return [Hash] Returns the object in the form of hash
def to_body
to_hash
end
# Returns the object in the form of hash
# @return [Hash] Returns the object in the form of hash
def to_hash
hash = {}
self.class.attribute_map.each_pair do |attr, param|
value = self.send(attr)
if value.nil?
is_nullable = self.class.openapi_nullable.include?(attr)
next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
end
hash[param] = _to_hash(value)
end
hash
end
# Outputs non-array value in the form of hash
# For object, use to_hash. Otherwise, just return the value
# @param [Object] value Any valid value
# @return [Hash] Returns the value in the form of hash
def _to_hash(value)
if value.is_a?(Array)
value.compact.map { |v| _to_hash(v) }
elsif value.is_a?(Hash)
{}.tap do |hash|
value.each { |k, v| hash[k] = _to_hash(v) }
end
elsif value.respond_to? :to_hash
value.to_hash
else
value
end
end
end
end

235
samples/client/petstore/ruby-autoload/lib/petstore/models/category.rb Normal file
View File

@ -0,0 +1,235 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'date'
require 'time'
module Petstore
class Category
attr_accessor :id
attr_accessor :name
# Attribute mapping from ruby-style variable name to JSON key.
def self.attribute_map
{
:'id' => :'id',
:'name' => :'name'
}
end
# Returns all the JSON keys this model knows about
def self.acceptable_attributes
attribute_map.values
end
# Attribute type mapping.
def self.openapi_types
{
:'id' => :'Integer',
:'name' => :'String'
}
end
# List of attributes with nullable: true
def self.openapi_nullable
Set.new([
])
end
# Initializes the object
# @param [Hash] attributes Model attributes in the form of hash
def initialize(attributes = {})
if (!attributes.is_a?(Hash))
fail ArgumentError, "The input argument (attributes) must be a hash in `Petstore::Category` initialize method"
end
# check to see if the attribute exists and convert string to symbol for hash key
attributes = attributes.each_with_object({}) { |(k, v), h|
if (!self.class.attribute_map.key?(k.to_sym))
fail ArgumentError, "`#{k}` is not a valid attribute in `Petstore::Category`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
end
h[k.to_sym] = v
}
if attributes.key?(:'id')
self.id = attributes[:'id']
end
if attributes.key?(:'name')
self.name = attributes[:'name']
else
self.name = 'default-name'
end
end
# Show invalid properties with the reasons. Usually used together with valid?
# @return Array for valid properties with the reasons
def list_invalid_properties
invalid_properties = Array.new
if @name.nil?
invalid_properties.push('invalid value for "name", name cannot be nil.')
end
invalid_properties
end
# Check to see if the all the properties in the model are valid
# @return true if the model is valid
def valid?
return false if @name.nil?
true
end
# Checks equality by comparing each attribute.
# @param [Object] Object to be compared
def ==(o)
return true if self.equal?(o)
self.class == o.class &&
id == o.id &&
name == o.name
end
# @see the `==` method
# @param [Object] Object to be compared
def eql?(o)
self == o
end
# Calculates hash code according to all attributes.
# @return [Integer] Hash code
def hash
[id, name].hash
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def self.build_from_hash(attributes)
new.build_from_hash(attributes)
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def build_from_hash(attributes)
return nil unless attributes.is_a?(Hash)
attributes = attributes.transform_keys(&:to_sym)
self.class.openapi_types.each_pair do |key, type|
if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
self.send("#{key}=", nil)
elsif type =~ /\AArray<(.*)>/i
# check to ensure the input is an array given that the attribute
# is documented as an array but the input is not
if attributes[self.class.attribute_map[key]].is_a?(Array)
self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
end
elsif !attributes[self.class.attribute_map[key]].nil?
self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
end
end
self
end
# Deserializes the data based on type
# @param string type Data type
# @param string value Value to be deserialized
# @return [Object] Deserialized data
def _deserialize(type, value)
case type.to_sym
when :Time
Time.parse(value)
when :Date
Date.parse(value)
when :String
value.to_s
when :Integer
value.to_i
when :Float
value.to_f
when :Boolean
if value.to_s =~ /\A(true|t|yes|y|1)\z/i
true
else
false
end
when :Object
# generic object (usually a Hash), return directly
value
when /\AArray<(?<inner_type>.+)>\z/
inner_type = Regexp.last_match[:inner_type]
value.map { |v| _deserialize(inner_type, v) }
when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
k_type = Regexp.last_match[:k_type]
v_type = Regexp.last_match[:v_type]
{}.tap do |hash|
value.each do |k, v|
hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
end
end
else # model
# models (e.g. Pet) or oneOf
klass = Petstore.const_get(type)
klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
end
end
# Returns the string representation of the object
# @return [String] String presentation of the object
def to_s
to_hash.to_s
end
# to_body is an alias to to_hash (backward compatibility)
# @return [Hash] Returns the object in the form of hash
def to_body
to_hash
end
# Returns the object in the form of hash
# @return [Hash] Returns the object in the form of hash
def to_hash
hash = {}
self.class.attribute_map.each_pair do |attr, param|
value = self.send(attr)
if value.nil?
is_nullable = self.class.openapi_nullable.include?(attr)
next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
end
hash[param] = _to_hash(value)
end
hash
end
# Outputs non-array value in the form of hash
# For object, use to_hash. Otherwise, just return the value
# @param [Object] value Any valid value
# @return [Hash] Returns the value in the form of hash
def _to_hash(value)
if value.is_a?(Array)
value.compact.map { |v| _to_hash(v) }
elsif value.is_a?(Hash)
{}.tap do |hash|
value.each { |k, v| hash[k] = _to_hash(v) }
end
elsif value.respond_to? :to_hash
value.to_hash
else
value
end
end
end
end

220
samples/client/petstore/ruby-autoload/lib/petstore/models/class_model.rb Normal file
View File

@ -0,0 +1,220 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'date'
require 'time'
module Petstore
# Model for testing model with \"_class\" property
class ClassModel
attr_accessor :_class
# Attribute mapping from ruby-style variable name to JSON key.
def self.attribute_map
{
:'_class' => :'_class'
}
end
# Returns all the JSON keys this model knows about
def self.acceptable_attributes
attribute_map.values
end
# Attribute type mapping.
def self.openapi_types
{
:'_class' => :'String'
}
end
# List of attributes with nullable: true
def self.openapi_nullable
Set.new([
])
end
# Initializes the object
# @param [Hash] attributes Model attributes in the form of hash
def initialize(attributes = {})
if (!attributes.is_a?(Hash))
fail ArgumentError, "The input argument (attributes) must be a hash in `Petstore::ClassModel` initialize method"
end
# check to see if the attribute exists and convert string to symbol for hash key
attributes = attributes.each_with_object({}) { |(k, v), h|
if (!self.class.attribute_map.key?(k.to_sym))
fail ArgumentError, "`#{k}` is not a valid attribute in `Petstore::ClassModel`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
end
h[k.to_sym] = v
}
if attributes.key?(:'_class')
self._class = attributes[:'_class']
end
end
# Show invalid properties with the reasons. Usually used together with valid?
# @return Array for valid properties with the reasons
def list_invalid_properties
invalid_properties = Array.new
invalid_properties
end
# Check to see if the all the properties in the model are valid
# @return true if the model is valid
def valid?
true
end
# Checks equality by comparing each attribute.
# @param [Object] Object to be compared
def ==(o)
return true if self.equal?(o)
self.class == o.class &&
_class == o._class
end
# @see the `==` method
# @param [Object] Object to be compared
def eql?(o)
self == o
end
# Calculates hash code according to all attributes.
# @return [Integer] Hash code
def hash
[_class].hash
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def self.build_from_hash(attributes)
new.build_from_hash(attributes)
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def build_from_hash(attributes)
return nil unless attributes.is_a?(Hash)
attributes = attributes.transform_keys(&:to_sym)
self.class.openapi_types.each_pair do |key, type|
if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
self.send("#{key}=", nil)
elsif type =~ /\AArray<(.*)>/i
# check to ensure the input is an array given that the attribute
# is documented as an array but the input is not
if attributes[self.class.attribute_map[key]].is_a?(Array)
self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
end
elsif !attributes[self.class.attribute_map[key]].nil?
self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
end
end
self
end
# Deserializes the data based on type
# @param string type Data type
# @param string value Value to be deserialized
# @return [Object] Deserialized data
def _deserialize(type, value)
case type.to_sym
when :Time
Time.parse(value)
when :Date
Date.parse(value)
when :String
value.to_s
when :Integer
value.to_i
when :Float
value.to_f
when :Boolean
if value.to_s =~ /\A(true|t|yes|y|1)\z/i
true
else
false
end
when :Object
# generic object (usually a Hash), return directly
value
when /\AArray<(?<inner_type>.+)>\z/
inner_type = Regexp.last_match[:inner_type]
value.map { |v| _deserialize(inner_type, v) }
when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
k_type = Regexp.last_match[:k_type]
v_type = Regexp.last_match[:v_type]
{}.tap do |hash|
value.each do |k, v|
hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
end
end
else # model
# models (e.g. Pet) or oneOf
klass = Petstore.const_get(type)
klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
end
end
# Returns the string representation of the object
# @return [String] String presentation of the object
def to_s
to_hash.to_s
end
# to_body is an alias to to_hash (backward compatibility)
# @return [Hash] Returns the object in the form of hash
def to_body
to_hash
end
# Returns the object in the form of hash
# @return [Hash] Returns the object in the form of hash
def to_hash
hash = {}
self.class.attribute_map.each_pair do |attr, param|
value = self.send(attr)
if value.nil?
is_nullable = self.class.openapi_nullable.include?(attr)
next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
end
hash[param] = _to_hash(value)
end
hash
end
# Outputs non-array value in the form of hash
# For object, use to_hash. Otherwise, just return the value
# @param [Object] value Any valid value
# @return [Hash] Returns the value in the form of hash
def _to_hash(value)
if value.is_a?(Array)
value.compact.map { |v| _to_hash(v) }
elsif value.is_a?(Hash)
{}.tap do |hash|
value.each { |k, v| hash[k] = _to_hash(v) }
end
elsif value.respond_to? :to_hash
value.to_hash
else
value
end
end
end
end

219
samples/client/petstore/ruby-autoload/lib/petstore/models/client.rb Normal file
View File

@ -0,0 +1,219 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'date'
require 'time'
module Petstore
class Client
attr_accessor :client
# Attribute mapping from ruby-style variable name to JSON key.
def self.attribute_map
{
:'client' => :'client'
}
end
# Returns all the JSON keys this model knows about
def self.acceptable_attributes
attribute_map.values
end
# Attribute type mapping.
def self.openapi_types
{
:'client' => :'String'
}
end
# List of attributes with nullable: true
def self.openapi_nullable
Set.new([
])
end
# Initializes the object
# @param [Hash] attributes Model attributes in the form of hash
def initialize(attributes = {})
if (!attributes.is_a?(Hash))
fail ArgumentError, "The input argument (attributes) must be a hash in `Petstore::Client` initialize method"
end
# check to see if the attribute exists and convert string to symbol for hash key
attributes = attributes.each_with_object({}) { |(k, v), h|
if (!self.class.attribute_map.key?(k.to_sym))
fail ArgumentError, "`#{k}` is not a valid attribute in `Petstore::Client`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
end
h[k.to_sym] = v
}
if attributes.key?(:'client')
self.client = attributes[:'client']
end
end
# Show invalid properties with the reasons. Usually used together with valid?
# @return Array for valid properties with the reasons
def list_invalid_properties
invalid_properties = Array.new
invalid_properties
end
# Check to see if the all the properties in the model are valid
# @return true if the model is valid
def valid?
true
end
# Checks equality by comparing each attribute.
# @param [Object] Object to be compared
def ==(o)
return true if self.equal?(o)
self.class == o.class &&
client == o.client
end
# @see the `==` method
# @param [Object] Object to be compared
def eql?(o)
self == o
end
# Calculates hash code according to all attributes.
# @return [Integer] Hash code
def hash
[client].hash
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def self.build_from_hash(attributes)
new.build_from_hash(attributes)
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def build_from_hash(attributes)
return nil unless attributes.is_a?(Hash)
attributes = attributes.transform_keys(&:to_sym)
self.class.openapi_types.each_pair do |key, type|
if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
self.send("#{key}=", nil)
elsif type =~ /\AArray<(.*)>/i
# check to ensure the input is an array given that the attribute
# is documented as an array but the input is not
if attributes[self.class.attribute_map[key]].is_a?(Array)
self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
end
elsif !attributes[self.class.attribute_map[key]].nil?
self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
end
end
self
end
# Deserializes the data based on type
# @param string type Data type
# @param string value Value to be deserialized
# @return [Object] Deserialized data
def _deserialize(type, value)
case type.to_sym
when :Time
Time.parse(value)
when :Date
Date.parse(value)
when :String
value.to_s
when :Integer
value.to_i
when :Float
value.to_f
when :Boolean
if value.to_s =~ /\A(true|t|yes|y|1)\z/i
true
else
false
end
when :Object
# generic object (usually a Hash), return directly
value
when /\AArray<(?<inner_type>.+)>\z/
inner_type = Regexp.last_match[:inner_type]
value.map { |v| _deserialize(inner_type, v) }
when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
k_type = Regexp.last_match[:k_type]
v_type = Regexp.last_match[:v_type]
{}.tap do |hash|
value.each do |k, v|
hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
end
end
else # model
# models (e.g. Pet) or oneOf
klass = Petstore.const_get(type)
klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
end
end
# Returns the string representation of the object
# @return [String] String presentation of the object
def to_s
to_hash.to_s
end
# to_body is an alias to to_hash (backward compatibility)
# @return [Hash] Returns the object in the form of hash
def to_body
to_hash
end
# Returns the object in the form of hash
# @return [Hash] Returns the object in the form of hash
def to_hash
hash = {}
self.class.attribute_map.each_pair do |attr, param|
value = self.send(attr)
if value.nil?
is_nullable = self.class.openapi_nullable.include?(attr)
next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
end
hash[param] = _to_hash(value)
end
hash
end
# Outputs non-array value in the form of hash
# For object, use to_hash. Otherwise, just return the value
# @param [Object] value Any valid value
# @return [Hash] Returns the value in the form of hash
def _to_hash(value)
if value.is_a?(Array)
value.compact.map { |v| _to_hash(v) }
elsif value.is_a?(Hash)
{}.tap do |hash|
value.each { |k, v| hash[k] = _to_hash(v) }
end
elsif value.respond_to? :to_hash
value.to_hash
else
value
end
end
end
end

219
samples/client/petstore/ruby-autoload/lib/petstore/models/deprecated_object.rb Normal file
View File

@ -0,0 +1,219 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'date'
require 'time'
module Petstore
class DeprecatedObject
attr_accessor :name
# Attribute mapping from ruby-style variable name to JSON key.
def self.attribute_map
{
:'name' => :'name'
}
end
# Returns all the JSON keys this model knows about
def self.acceptable_attributes
attribute_map.values
end
# Attribute type mapping.
def self.openapi_types
{
:'name' => :'String'
}
end
# List of attributes with nullable: true
def self.openapi_nullable
Set.new([
])
end
# Initializes the object
# @param [Hash] attributes Model attributes in the form of hash
def initialize(attributes = {})
if (!attributes.is_a?(Hash))
fail ArgumentError, "The input argument (attributes) must be a hash in `Petstore::DeprecatedObject` initialize method"
end
# check to see if the attribute exists and convert string to symbol for hash key
attributes = attributes.each_with_object({}) { |(k, v), h|
if (!self.class.attribute_map.key?(k.to_sym))
fail ArgumentError, "`#{k}` is not a valid attribute in `Petstore::DeprecatedObject`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
end
h[k.to_sym] = v
}
if attributes.key?(:'name')
self.name = attributes[:'name']
end
end
# Show invalid properties with the reasons. Usually used together with valid?
# @return Array for valid properties with the reasons
def list_invalid_properties
invalid_properties = Array.new
invalid_properties
end
# Check to see if the all the properties in the model are valid
# @return true if the model is valid
def valid?
true
end
# Checks equality by comparing each attribute.
# @param [Object] Object to be compared
def ==(o)
return true if self.equal?(o)
self.class == o.class &&
name == o.name
end
# @see the `==` method
# @param [Object] Object to be compared
def eql?(o)
self == o
end
# Calculates hash code according to all attributes.
# @return [Integer] Hash code
def hash
[name].hash
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def self.build_from_hash(attributes)
new.build_from_hash(attributes)
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def build_from_hash(attributes)
return nil unless attributes.is_a?(Hash)
attributes = attributes.transform_keys(&:to_sym)
self.class.openapi_types.each_pair do |key, type|
if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
self.send("#{key}=", nil)
elsif type =~ /\AArray<(.*)>/i
# check to ensure the input is an array given that the attribute
# is documented as an array but the input is not
if attributes[self.class.attribute_map[key]].is_a?(Array)
self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
end
elsif !attributes[self.class.attribute_map[key]].nil?
self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
end
end
self
end
# Deserializes the data based on type
# @param string type Data type
# @param string value Value to be deserialized
# @return [Object] Deserialized data
def _deserialize(type, value)
case type.to_sym
when :Time
Time.parse(value)
when :Date
Date.parse(value)
when :String
value.to_s
when :Integer
value.to_i
when :Float
value.to_f
when :Boolean
if value.to_s =~ /\A(true|t|yes|y|1)\z/i
true
else
false
end
when :Object
# generic object (usually a Hash), return directly
value
when /\AArray<(?<inner_type>.+)>\z/
inner_type = Regexp.last_match[:inner_type]
value.map { |v| _deserialize(inner_type, v) }
when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
k_type = Regexp.last_match[:k_type]
v_type = Regexp.last_match[:v_type]
{}.tap do |hash|
value.each do |k, v|
hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
end
end
else # model
# models (e.g. Pet) or oneOf
klass = Petstore.const_get(type)
klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
end
end
# Returns the string representation of the object
# @return [String] String presentation of the object
def to_s
to_hash.to_s
end
# to_body is an alias to to_hash (backward compatibility)
# @return [Hash] Returns the object in the form of hash
def to_body
to_hash
end
# Returns the object in the form of hash
# @return [Hash] Returns the object in the form of hash
def to_hash
hash = {}
self.class.attribute_map.each_pair do |attr, param|
value = self.send(attr)
if value.nil?
is_nullable = self.class.openapi_nullable.include?(attr)
next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
end
hash[param] = _to_hash(value)
end
hash
end
# Outputs non-array value in the form of hash
# For object, use to_hash. Otherwise, just return the value
# @param [Object] value Any valid value
# @return [Hash] Returns the value in the form of hash
def _to_hash(value)
if value.is_a?(Array)
value.compact.map { |v| _to_hash(v) }
elsif value.is_a?(Hash)
{}.tap do |hash|
value.each { |k, v| hash[k] = _to_hash(v) }
end
elsif value.respond_to? :to_hash
value.to_hash
else
value
end
end
end
end

231
samples/client/petstore/ruby-autoload/lib/petstore/models/dog.rb Normal file
View File

@ -0,0 +1,231 @@
=begin
#OpenAPI Petstore
#This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
The version of the OpenAPI document: 1.0.0
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 6.1.0-SNAPSHOT
=end
require 'date'
require 'time'
module Petstore
class Dog < Animal
attr_accessor :breed
# Attribute mapping from ruby-style variable name to JSON key.
def self.attribute_map
{
:'breed' => :'breed'
}
end
# Returns all the JSON keys this model knows about, including the ones defined in its parent(s)
def self.acceptable_attributes
attribute_map.values.concat(superclass.acceptable_attributes)
end
# Attribute type mapping.
def self.openapi_types
{
:'breed' => :'String'
}
end
# List of attributes with nullable: true
def self.openapi_nullable
Set.new([
])
end
# List of class defined in allOf (OpenAPI v3)
def self.openapi_all_of
[
:'Animal',
:'DogAllOf'
]
end
# Initializes the object
# @param [Hash] attributes Model attributes in the form of hash
def initialize(attributes = {})
if (!attributes.is_a?(Hash))
fail ArgumentError, "The input argument (attributes) must be a hash in `Petstore::Dog` initialize method"
end
# check to see if the attribute exists and convert string to symbol for hash key
attributes = attributes.each_with_object({}) { |(k, v), h|
if (!self.class.attribute_map.key?(k.to_sym))
fail ArgumentError, "`#{k}` is not a valid attribute in `Petstore::Dog`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
end
h[k.to_sym] = v
}
# call parent's initialize
super(attributes)
if attributes.key?(:'breed')
self.breed = attributes[:'breed']
end
end
# Show invalid properties with the reasons. Usually used together with valid?
# @return Array for valid properties with the reasons
def list_invalid_properties
invalid_properties = super
invalid_properties
end
# Check to see if the all the properties in the model are valid
# @return true if the model is valid
def valid?
true && super
end
# Checks equality by comparing each attribute.
# @param [Object] Object to be compared
def ==(o)
return true if self.equal?(o)
self.class == o.class &&
breed == o.breed && super(o)
end
# @see the `==` method
# @param [Object] Object to be compared
def eql?(o)
self == o
end
# Calculates hash code according to all attributes.
# @return [Integer] Hash code
def hash
[breed].hash
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def self.build_from_hash(attributes)
new.build_from_hash(attributes)
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def build_from_hash(attributes)
return nil unless attributes.is_a?(Hash)
super(attributes)
attributes = attributes.transform_keys(&:to_sym)
self.class.openapi_types.each_pair do |key, type|
if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
self.send("#{key}=", nil)
elsif type =~ /\AArray<(.*)>/i
# check to ensure the input is an array given that the attribute
# is documented as an array but the input is not
if attributes[self.class.attribute_map[key]].is_a?(Array)
self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
end
elsif !attributes[self.class.attribute_map[key]].nil?
self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
end
end
self
end
# Deserializes the data based on type
# @param string type Data type
# @param string value Value to be deserialized
# @return [Object] Deserialized data
def _deserialize(type, value)
case type.to_sym
when :Time
Time.parse(value)
when :Date
Date.parse(value)
when :String
value.to_s
when :Integer
value.to_i
when :Float
value.to_f
when :Boolean
if value.to_s =~ /\A(true|t|yes|y|1)\z/i
true
else
false
end
when :Object
# generic object (usually a Hash), return directly
value
when /\AArray<(?<inner_type>.+)>\z/
inner_type = Regexp.last_match[:inner_type]
value.map { |v| _deserialize(inner_type, v) }
when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
k_type = Regexp.last_match[:k_type]
v_type = Regexp.last_match[:v_type]
{}.tap do |hash|
value.each do |k, v|
hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
end
end
else # model
# models (e.g. Pet) or oneOf
klass = Petstore.const_get(type)
klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
end
end
# Returns the string representation of the object
# @return [String] String presentation of the object
def to_s
to_hash.to_s
end
# to_body is an alias to to_hash (backward compatibility)
# @return [Hash] Returns the object in the form of hash
def to_body
to_hash
end
# Returns the object in the form of hash
# @return [Hash] Returns the object in the form of hash
def to_hash
hash = super
self.class.attribute_map.each_pair do |attr, param|
value = self.send(attr)
if value.nil?
is_nullable = self.class.openapi_nullable.include?(attr)
next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
end
hash[param] = _to_hash(value)
end
hash
end
# Outputs non-array value in the form of hash
# For object, use to_hash. Otherwise, just return the value
# @param [Object] value Any valid value
# @return [Hash] Returns the value in the form of hash
def _to_hash(value)
if value.is_a?(Array)
value.compact.map { |v| _to_hash(v) }
elsif value.is_a?(Hash)
{}.tap do |hash|
value.each { |k, v| hash[k] = _to_hash(v) }
end
elsif value.respond_to? :to_hash
value.to_hash
else
value
end
end
end
end

Some files were not shown because too many files have changed in this diff Show More