-
Notifications
You must be signed in to change notification settings - Fork 20
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
Publish app builder API documentation #2181
Publish app builder API documentation #2181
Conversation
903c24e
to
06db9d8
Compare
9aa6033
to
5f283d2
Compare
unstable_enabled = @api_client.config.unstable_operations["v2.deploy_app".to_sym] | ||
# @option opts [String] :version The version number of the app to retrieve. If not specified, the latest version is returned. Version numbers start at 1 and increment with each update. The special values `latest` and `deployed` can be used to retrieve the latest version or the published version, respectively. | ||
# @return [Array<(GetAppResponse, Integer, Hash)>] GetAppResponse data, response status code and response headers | ||
def get_app_with_http_info(app_id, opts = {}) |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
⚪ Code Quality Violation
Avoid using a hash as an optional parameter (...read more)
The rule "Avoid hash optional parameters" is a guideline that encourages developers to explicitly declare parameters instead of using a hash for optional parameters. This is because using a hash for optional parameters can make the code harder to understand and maintain. It can also lead to unexpected behavior if a developer accidentally includes a key in the hash that the method does not expect.
This rule is important because it promotes code readability and maintainability. It also helps prevent potential bugs that may occur due to unexpected keys in the optional hash. By explicitly declaring each parameter, developers can easily see what parameters a method expects, making the code easier to read and understand.
To adhere to this rule, instead of using a hash for optional parameters, explicitly declare each parameter in the method definition. For example, instead of using options = {}
in the method definition, declare each parameter like name, email, age
. This way, anyone reading the code can easily understand what parameters the method expects and in what order.
def list_apps_with_http_info(opts = {}) | ||
unstable_enabled = @api_client.config.unstable_operations["v2.list_apps".to_sym] | ||
# @return [Array<(UnpublishAppResponse, Integer, Hash)>] UnpublishAppResponse data, response status code and response headers | ||
def unpublish_app_with_http_info(app_id, opts = {}) |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
⚪ Code Quality Violation
Avoid using a hash as an optional parameter (...read more)
The rule "Avoid hash optional parameters" is a guideline that encourages developers to explicitly declare parameters instead of using a hash for optional parameters. This is because using a hash for optional parameters can make the code harder to understand and maintain. It can also lead to unexpected behavior if a developer accidentally includes a key in the hash that the method does not expect.
This rule is important because it promotes code readability and maintainability. It also helps prevent potential bugs that may occur due to unexpected keys in the optional hash. By explicitly declaring each parameter, developers can easily see what parameters a method expects, making the code easier to read and understand.
To adhere to this rule, instead of using a hash for optional parameters, explicitly declare each parameter in the method definition. For example, instead of using options = {}
in the method definition, declare each parameter like name, email, age
. This way, anyone reading the code can easily understand what parameters the method expects and in what order.
# @option opts [Boolean] :filter_self_service Filter apps by whether they are enabled for self-service. | ||
# @option opts [Array<AppsSortField>] :sort The fields and direction to sort apps by. | ||
# @return [Array<(ListAppsResponse, Integer, Hash)>] ListAppsResponse data, response status code and response headers | ||
def list_apps_with_http_info(opts = {}) |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
⚪ Code Quality Violation
Avoid using a hash as an optional parameter (...read more)
The rule "Avoid hash optional parameters" is a guideline that encourages developers to explicitly declare parameters instead of using a hash for optional parameters. This is because using a hash for optional parameters can make the code harder to understand and maintain. It can also lead to unexpected behavior if a developer accidentally includes a key in the hash that the method does not expect.
This rule is important because it promotes code readability and maintainability. It also helps prevent potential bugs that may occur due to unexpected keys in the optional hash. By explicitly declaring each parameter, developers can easily see what parameters a method expects, making the code easier to read and understand.
To adhere to this rule, instead of using a hash for optional parameters, explicitly declare each parameter in the method definition. For example, instead of using options = {}
in the method definition, declare each parameter like name, email, age
. This way, anyone reading the code can easily understand what parameters the method expects and in what order.
def get_app(app_id, opts = {}) | ||
data, _status_code, _headers = get_app_with_http_info(app_id, opts) | ||
# @see #publish_app_with_http_info | ||
def publish_app(app_id, opts = {}) |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
⚪ Code Quality Violation
Avoid using a hash as an optional parameter (...read more)
The rule "Avoid hash optional parameters" is a guideline that encourages developers to explicitly declare parameters instead of using a hash for optional parameters. This is because using a hash for optional parameters can make the code harder to understand and maintain. It can also lead to unexpected behavior if a developer accidentally includes a key in the hash that the method does not expect.
This rule is important because it promotes code readability and maintainability. It also helps prevent potential bugs that may occur due to unexpected keys in the optional hash. By explicitly declaring each parameter, developers can easily see what parameters a method expects, making the code easier to read and understand.
To adhere to this rule, instead of using a hash for optional parameters, explicitly declare each parameter in the method definition. For example, instead of using options = {}
in the method definition, declare each parameter like name, email, age
. This way, anyone reading the code can easily understand what parameters the method expects and in what order.
def disable_app(app_id, opts = {}) | ||
data, _status_code, _headers = disable_app_with_http_info(app_id, opts) | ||
# @see #list_apps_with_http_info | ||
def list_apps(opts = {}) |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
⚪ Code Quality Violation
Avoid using a hash as an optional parameter (...read more)
The rule "Avoid hash optional parameters" is a guideline that encourages developers to explicitly declare parameters instead of using a hash for optional parameters. This is because using a hash for optional parameters can make the code harder to understand and maintain. It can also lead to unexpected behavior if a developer accidentally includes a key in the hash that the method does not expect.
This rule is important because it promotes code readability and maintainability. It also helps prevent potential bugs that may occur due to unexpected keys in the optional hash. By explicitly declaring each parameter, developers can easily see what parameters a method expects, making the code easier to read and understand.
To adhere to this rule, instead of using a hash for optional parameters, explicitly declare each parameter in the method definition. For example, instead of using options = {}
in the method definition, declare each parameter like name, email, age
. This way, anyone reading the code can easily understand what parameters the method expects and in what order.
def get_app_with_http_info(app_id, opts = {}) | ||
unstable_enabled = @api_client.config.unstable_operations["v2.get_app".to_sym] | ||
# @return [Array<(PublishAppResponse, Integer, Hash)>] PublishAppResponse data, response status code and response headers | ||
def publish_app_with_http_info(app_id, opts = {}) |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
⚪ Code Quality Violation
Avoid using a hash as an optional parameter (...read more)
The rule "Avoid hash optional parameters" is a guideline that encourages developers to explicitly declare parameters instead of using a hash for optional parameters. This is because using a hash for optional parameters can make the code harder to understand and maintain. It can also lead to unexpected behavior if a developer accidentally includes a key in the hash that the method does not expect.
This rule is important because it promotes code readability and maintainability. It also helps prevent potential bugs that may occur due to unexpected keys in the optional hash. By explicitly declaring each parameter, developers can easily see what parameters a method expects, making the code easier to read and understand.
To adhere to this rule, instead of using a hash for optional parameters, explicitly declare each parameter in the method definition. For example, instead of using options = {}
in the method definition, declare each parameter like name, email, age
. This way, anyone reading the code can easily understand what parameters the method expects and in what order.
def deploy_app(app_id, opts = {}) | ||
data, _status_code, _headers = deploy_app_with_http_info(app_id, opts) | ||
# @see #get_app_with_http_info | ||
def get_app(app_id, opts = {}) |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
⚪ Code Quality Violation
Avoid using a hash as an optional parameter (...read more)
The rule "Avoid hash optional parameters" is a guideline that encourages developers to explicitly declare parameters instead of using a hash for optional parameters. This is because using a hash for optional parameters can make the code harder to understand and maintain. It can also lead to unexpected behavior if a developer accidentally includes a key in the hash that the method does not expect.
This rule is important because it promotes code readability and maintainability. It also helps prevent potential bugs that may occur due to unexpected keys in the optional hash. By explicitly declaring each parameter, developers can easily see what parameters a method expects, making the code easier to read and understand.
To adhere to this rule, instead of using a hash for optional parameters, explicitly declare each parameter in the method definition. For example, instead of using options = {}
in the method definition, declare each parameter like name, email, age
. This way, anyone reading the code can easily understand what parameters the method expects and in what order.
def list_apps(opts = {}) | ||
data, _status_code, _headers = list_apps_with_http_info(opts) | ||
# @see #unpublish_app_with_http_info | ||
def unpublish_app(app_id, opts = {}) |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
⚪ Code Quality Violation
Avoid using a hash as an optional parameter (...read more)
The rule "Avoid hash optional parameters" is a guideline that encourages developers to explicitly declare parameters instead of using a hash for optional parameters. This is because using a hash for optional parameters can make the code harder to understand and maintain. It can also lead to unexpected behavior if a developer accidentally includes a key in the hash that the method does not expect.
This rule is important because it promotes code readability and maintainability. It also helps prevent potential bugs that may occur due to unexpected keys in the optional hash. By explicitly declaring each parameter, developers can easily see what parameters a method expects, making the code easier to read and understand.
To adhere to this rule, instead of using a hash for optional parameters, explicitly declare each parameter in the method definition. For example, instead of using options = {}
in the method definition, declare each parameter like name, email, age
. This way, anyone reading the code can easily understand what parameters the method expects and in what order.
…-api-documentation
0bfe4fe
to
9260d92
Compare
…-api-documentation
9262045
to
07a0be8
Compare
…-api-documentation
07a0be8
to
03c76d8
Compare
Datadog ReportBranch report: ✅ 0 Failed, 2844 Passed, 81 Skipped, 2m 47.99s Total Time |
03c76d8
to
5a41cc0
Compare
* remove apps.feature * Regenerate client from commit c6ec55eb of spec repo --------- Co-authored-by: Oliver Li <[email protected]> Co-authored-by: api-clients-generation-pipeline[bot] <54105614+api-clients-generation-pipeline[bot]@users.noreply.github.com> Co-authored-by: ci.datadog-api-spec <[email protected]> 59a0cc6
See DataDog/datadog-api-spec#3465
Test branch datadog-api-spec/test/oliver/-apps-2099-app-builder-api-documentation