From f7654d5823047ecd4f1c95495740998ce676d700 Mon Sep 17 00:00:00 2001 From: slavkor <30171206+slavkor@users.noreply.github.com> Date: Thu, 11 Jul 2024 08:48:32 +0000 Subject: [PATCH] chore: release data-link SDK --- README.md | 133 +++--- src/.gitignore | 39 ++ src/.gitlab-ci.yml | 26 ++ src/.openapi-generator-ignore | 23 + src/.openapi-generator/FILES | 32 ++ src/.openapi-generator/VERSION | 1 + src/.rspec | 2 + src/.rubocop.yml | 148 +++++++ src/.travis.yml | 11 + src/Gemfile | 9 + src/README.md | 106 +++++ src/Rakefile | 10 + src/databox.gemspec | 39 ++ src/docs/ApiResponse.md | 20 + src/docs/DefaultApi.md | 410 ++++++++++++++++++ src/docs/PushData.md | 30 ++ src/docs/PushDataAttribute.md | 20 + src/docs/State.md | 15 + src/git_push.sh | 57 +++ src/lib/databox.rb | 44 ++ src/lib/databox/api/default_api.rb | 348 +++++++++++++++ src/lib/databox/api_client.rb | 394 +++++++++++++++++ src/lib/databox/api_error.rb | 58 +++ src/lib/databox/configuration.rb | 298 +++++++++++++ src/lib/databox/models/api_response.rb | 223 ++++++++++ src/lib/databox/models/push_data.rb | 270 ++++++++++++ src/lib/databox/models/push_data_attribute.rb | 223 ++++++++++ src/lib/databox/models/state.rb | 40 ++ src/lib/databox/version.rb | 15 + src/spec/api/default_api_spec.rb | 92 ++++ src/spec/models/api_response_spec.rb | 42 ++ src/spec/models/push_data_attribute_spec.rb | 42 ++ src/spec/models/push_data_spec.rb | 72 +++ src/spec/models/state_spec.rb | 30 ++ src/spec/spec_helper.rb | 111 +++++ 35 files changed, 3376 insertions(+), 57 deletions(-) create mode 100644 src/.gitignore create mode 100644 src/.gitlab-ci.yml create mode 100644 src/.openapi-generator-ignore create mode 100644 src/.openapi-generator/FILES create mode 100644 src/.openapi-generator/VERSION create mode 100644 src/.rspec create mode 100644 src/.rubocop.yml create mode 100644 src/.travis.yml create mode 100644 src/Gemfile create mode 100644 src/README.md create mode 100644 src/Rakefile create mode 100644 src/databox.gemspec create mode 100644 src/docs/ApiResponse.md create mode 100644 src/docs/DefaultApi.md create mode 100644 src/docs/PushData.md create mode 100644 src/docs/PushDataAttribute.md create mode 100644 src/docs/State.md create mode 100644 src/git_push.sh create mode 100644 src/lib/databox.rb create mode 100644 src/lib/databox/api/default_api.rb create mode 100644 src/lib/databox/api_client.rb create mode 100644 src/lib/databox/api_error.rb create mode 100644 src/lib/databox/configuration.rb create mode 100644 src/lib/databox/models/api_response.rb create mode 100644 src/lib/databox/models/push_data.rb create mode 100644 src/lib/databox/models/push_data_attribute.rb create mode 100644 src/lib/databox/models/state.rb create mode 100644 src/lib/databox/version.rb create mode 100644 src/spec/api/default_api_spec.rb create mode 100644 src/spec/models/api_response_spec.rb create mode 100644 src/spec/models/push_data_attribute_spec.rb create mode 100644 src/spec/models/push_data_spec.rb create mode 100644 src/spec/models/state_spec.rb create mode 100644 src/spec/spec_helper.rb diff --git a/README.md b/README.md index 3cbca2a..6a9478e 100644 --- a/README.md +++ b/README.md @@ -1,87 +1,106 @@ -# Databox bindings for Ruby +# databox -[![Build Status][travis-badge]][travis] -[![Gem Version](https://badge.fury.io/rb/databox.svg)](https://badge.fury.io/rb/databox) +Databox - the Ruby gem for the Static OpenAPI document of Push API resource -Ruby Gem for [Databox](http://databox.com/) - Mobile Executive Dashboard. +Push API resources Open API documentation + +This SDK is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: + +- API version: 0.4.0 +- Package version: 2.1.1 +- Generator version: 7.6.0 +- Build package: org.openapitools.codegen.languages.RubyClientCodegen ## Installation -Add this line to your application's Gemfile: +### Build a gem - gem 'databox' +To build the Ruby code into a gem: -And then execute: +```shell +gem build databox.gemspec +``` - $ bundle +Then either install the gem locally: -Or install it yourself as: +```shell +gem install ./databox-2.1.1.gem +``` - $ gem install databox +(for development, run `gem install --dev ./databox-2.1.1.gem` to install the development dependencies) -## Initialisation +or publish the gem to a gem hosting service, e.g. [RubyGems](https://rubygems.org/). -Before pushing data to Databox you have to initialize it with token. +Finally add this to the Gemfile: -```ruby -Databox.configure do |c| - c.push_token = "YOUR_TOKEN" -end -``` + gem 'databox', '~> 2.1.1' -## Usage +### Install from Git -Pushing data directly to Databox with help of `push` method: +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: -```ruby -client = Databox::Client.new + gem 'databox', :git => 'https://github.com/GIT_USER_ID/GIT_REPO_ID.git' + +### Include the Ruby code directly -client.push(key: 'sales.total', value: 3000) -client.push(key: 'temp.boston', value: 52.0) -client.push(key: 'temp.boston', value: 52.0, date: '2015-01-01 17:00:00') -client.push(key: 'temp.boston', value: 52.0, attributes: { - location: 'boston-south' -}) +Include the Ruby code directly using `-I` as follows: +```shell +ruby -Ilib script.rb ``` -Inserting multiple matrices with one `insert_all`: +## Getting Started + +Please follow the [installation](#installation) procedure and then run the following code: ```ruby -client = Databox::Client.new +# Load the gem +require 'databox' + +# Setup authorization +Databox.configure do |config| + # Configure HTTP basic authorization: basicAuth + config.username = 'YOUR_USERNAME' + config.password = 'YOUR_PASSWORD' +end -client.insert_all [ - {key: 'temp.boston', value: 52}, - {key: 'temp.boston', value: 50, date: '2015-01-01 17:00:00'}, - {key: 'temp.ny', value: 49} -] -``` +api_instance = Databox::DefaultApi.new -Retrieving information from last push with `last_push`: +begin + api_instance.data_delete +rescue Databox::ApiError => e + puts "Exception when calling DefaultApi->data_delete: #{e}" +end -```ruby -client.last_push - -# => -#[{ -# "push"=>"{\"data\":[{\"$sales.total\":2000}]}", -# "err"=>"[]", -# "no_err"=>0, -# "datetime"=>"2015-06-05T10:21:23.861Z", -# "keys"=>"[\"132|sales.total\"]" -#}] ``` -## Resources -- [Databox Web App](https://app.databox.com/) -- [Databox Developers Portal](https://developers.databox.com/) +## Documentation for API Endpoints + +All URIs are relative to *https://push.databox.com* + +Class | Method | HTTP request | Description +------------ | ------------- | ------------- | ------------- +*Databox::DefaultApi* | [**data_delete**](docs/DefaultApi.md#data_delete) | **DELETE** /data | +*Databox::DefaultApi* | [**data_metric_key_delete**](docs/DefaultApi.md#data_metric_key_delete) | **DELETE** /data/{metricKey} | +*Databox::DefaultApi* | [**data_post**](docs/DefaultApi.md#data_post) | **POST** /data | +*Databox::DefaultApi* | [**metrickeys_get**](docs/DefaultApi.md#metrickeys_get) | **GET** /metrickeys | +*Databox::DefaultApi* | [**metrickeys_post**](docs/DefaultApi.md#metrickeys_post) | **POST** /metrickeys | +*Databox::DefaultApi* | [**ping_get**](docs/DefaultApi.md#ping_get) | **GET** /ping | + + +## Documentation for Models + + - [Databox::ApiResponse](docs/ApiResponse.md) + - [Databox::PushData](docs/PushData.md) + - [Databox::PushDataAttribute](docs/PushDataAttribute.md) + - [Databox::State](docs/State.md) + + +## Documentation for Authorization + -## Author & License -- [Oto Brglez](https://github.com/otobrglez) -- [Vlada Petrović](https://github.com/VladaPetrovic) +Authentication schemes defined for the API: +### basicAuth -## License -- Comes with `MIT` license and terms. +- **Type**: HTTP basic authentication -[travis-badge]: https://secure.travis-ci.org/databox/databox-ruby.png?branch=v2 -[travis]: http://travis-ci.org/databox/databox-ruby diff --git a/src/.gitignore b/src/.gitignore new file mode 100644 index 0000000..05a17cb --- /dev/null +++ b/src/.gitignore @@ -0,0 +1,39 @@ +# Generated by: https://openapi-generator.tech +# + +*.gem +*.rbc +/.config +/coverage/ +/InstalledFiles +/pkg/ +/spec/reports/ +/spec/examples.txt +/test/tmp/ +/test/version_tmp/ +/tmp/ + +## Specific to RubyMotion: +.dat* +.repl_history +build/ + +## Documentation cache and generated files: +/.yardoc/ +/_yardoc/ +/doc/ +/rdoc/ + +## Environment normalization: +/.bundle/ +/vendor/bundle +/lib/bundler/man/ + +# for a library or gem, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# Gemfile.lock +# .ruby-version +# .ruby-gemset + +# unless supporting rvm < 1.11.0 or doing something fancy, ignore this: +.rvmrc diff --git a/src/.gitlab-ci.yml b/src/.gitlab-ci.yml new file mode 100644 index 0000000..3a253c4 --- /dev/null +++ b/src/.gitlab-ci.yml @@ -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.7', '3.0', '3.1'] + 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 + diff --git a/src/.openapi-generator-ignore b/src/.openapi-generator-ignore new file mode 100644 index 0000000..7484ee5 --- /dev/null +++ b/src/.openapi-generator-ignore @@ -0,0 +1,23 @@ +# OpenAPI Generator Ignore +# Generated by openapi-generator https://github.com/openapitools/openapi-generator + +# Use this file to prevent files from being overwritten by the generator. +# The patterns follow closely to .gitignore or .dockerignore. + +# As an example, the C# client generator defines ApiClient.cs. +# You can make changes and tell OpenAPI Generator to ignore just this file by uncommenting the following line: +#ApiClient.cs + +# You can match any string of characters against a directory, file or extension with a single asterisk (*): +#foo/*/qux +# The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux + +# You can recursively match patterns against a directory, file or extension with a double asterisk (**): +#foo/**/qux +# This matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux + +# You can also negate patterns with an exclamation (!). +# For example, you can ignore all files in a docs folder with the file extension .md: +#docs/*.md +# Then explicitly reverse the ignore rule for a single file: +#!docs/README.md diff --git a/src/.openapi-generator/FILES b/src/.openapi-generator/FILES new file mode 100644 index 0000000..2198256 --- /dev/null +++ b/src/.openapi-generator/FILES @@ -0,0 +1,32 @@ +.gitignore +.gitlab-ci.yml +.openapi-generator-ignore +.rspec +.rubocop.yml +.travis.yml +Gemfile +README.md +Rakefile +databox.gemspec +docs/ApiResponse.md +docs/DefaultApi.md +docs/PushData.md +docs/PushDataAttribute.md +docs/State.md +git_push.sh +lib/databox.rb +lib/databox/api/default_api.rb +lib/databox/api_client.rb +lib/databox/api_error.rb +lib/databox/configuration.rb +lib/databox/models/api_response.rb +lib/databox/models/push_data.rb +lib/databox/models/push_data_attribute.rb +lib/databox/models/state.rb +lib/databox/version.rb +spec/api/default_api_spec.rb +spec/models/api_response_spec.rb +spec/models/push_data_attribute_spec.rb +spec/models/push_data_spec.rb +spec/models/state_spec.rb +spec/spec_helper.rb diff --git a/src/.openapi-generator/VERSION b/src/.openapi-generator/VERSION new file mode 100644 index 0000000..93c8dda --- /dev/null +++ b/src/.openapi-generator/VERSION @@ -0,0 +1 @@ +7.6.0 diff --git a/src/.rspec b/src/.rspec new file mode 100644 index 0000000..83e16f8 --- /dev/null +++ b/src/.rspec @@ -0,0 +1,2 @@ +--color +--require spec_helper diff --git a/src/.rubocop.yml b/src/.rubocop.yml new file mode 100644 index 0000000..d32b2b1 --- /dev/null +++ b/src/.rubocop.yml @@ -0,0 +1,148 @@ +# This file is based on https://github.com/rails/rails/blob/master/.rubocop.yml (MIT license) +# Automatically generated by OpenAPI Generator (https://openapi-generator.tech) +AllCops: + TargetRubyVersion: 2.4 + # RuboCop has a bunch of cops enabled by default. This setting tells RuboCop + # to ignore them, so only the ones explicitly set in this file are enabled. + DisabledByDefault: true + Exclude: + - '**/templates/**/*' + - '**/vendor/**/*' + - 'actionpack/lib/action_dispatch/journey/parser.rb' + +# Prefer &&/|| over and/or. +Style/AndOr: + Enabled: true + +# Align `when` with `case`. +Layout/CaseIndentation: + Enabled: true + +# Align comments with method definitions. +Layout/CommentIndentation: + Enabled: true + +Layout/ElseAlignment: + Enabled: true + +Layout/EmptyLineAfterMagicComment: + Enabled: true + +# In a regular class definition, no empty lines around the body. +Layout/EmptyLinesAroundClassBody: + Enabled: true + +# In a regular method definition, no empty lines around the body. +Layout/EmptyLinesAroundMethodBody: + Enabled: true + +# In a regular module definition, no empty lines around the body. +Layout/EmptyLinesAroundModuleBody: + Enabled: true + +Layout/FirstArgumentIndentation: + Enabled: true + +# Use Ruby >= 1.9 syntax for hashes. Prefer { a: :b } over { :a => :b }. +Style/HashSyntax: + Enabled: false + +# Method definitions after `private` or `protected` isolated calls need one +# extra level of indentation. +Layout/IndentationConsistency: + Enabled: true + EnforcedStyle: indented_internal_methods + +# Two spaces, no tabs (for indentation). +Layout/IndentationWidth: + Enabled: true + +Layout/LeadingCommentSpace: + Enabled: true + +Layout/SpaceAfterColon: + Enabled: true + +Layout/SpaceAfterComma: + Enabled: true + +Layout/SpaceAroundEqualsInParameterDefault: + Enabled: true + +Layout/SpaceAroundKeyword: + Enabled: true + +Layout/SpaceAroundOperators: + Enabled: true + +Layout/SpaceBeforeComma: + Enabled: true + +Layout/SpaceBeforeFirstArg: + Enabled: true + +Style/DefWithParentheses: + Enabled: true + +# Defining a method with parameters needs parentheses. +Style/MethodDefParentheses: + Enabled: true + +Style/FrozenStringLiteralComment: + Enabled: false + EnforcedStyle: always + +# Use `foo {}` not `foo{}`. +Layout/SpaceBeforeBlockBraces: + Enabled: true + +# Use `foo { bar }` not `foo {bar}`. +Layout/SpaceInsideBlockBraces: + Enabled: true + +# Use `{ a: 1 }` not `{a:1}`. +Layout/SpaceInsideHashLiteralBraces: + Enabled: true + +Layout/SpaceInsideParens: + Enabled: true + +# Check quotes usage according to lint rule below. +#Style/StringLiterals: +# Enabled: true +# EnforcedStyle: single_quotes + +# Detect hard tabs, no hard tabs. +Layout/IndentationStyle: + Enabled: true + +# Blank lines should not have any spaces. +Layout/TrailingEmptyLines: + Enabled: true + +# No trailing whitespace. +Layout/TrailingWhitespace: + Enabled: false + +# Use quotes for string literals when they are enough. +Style/RedundantPercentQ: + Enabled: true + +# Align `end` with the matching keyword or starting expression except for +# assignments, where it should be aligned with the LHS. +Layout/EndAlignment: + Enabled: true + EnforcedStyleAlignWith: variable + AutoCorrect: true + +# Use my_method(my_arg) not my_method( my_arg ) or my_method my_arg. +Lint/RequireParentheses: + Enabled: true + +Style/RedundantReturn: + Enabled: true + AllowMultipleReturnValues: true + +Style/Semicolon: + Enabled: true + AllowAsExpressionSeparator: true diff --git a/src/.travis.yml b/src/.travis.yml new file mode 100644 index 0000000..385ae74 --- /dev/null +++ b/src/.travis.yml @@ -0,0 +1,11 @@ +language: ruby +cache: bundler +rvm: + - 2.7 + - 3.0 + - 3.1 +script: + - bundle install --path vendor/bundle + - bundle exec rspec + - gem build databox.gemspec + - gem install ./databox-2.1.1.gem diff --git a/src/Gemfile b/src/Gemfile new file mode 100644 index 0000000..c2e3127 --- /dev/null +++ b/src/Gemfile @@ -0,0 +1,9 @@ +source 'https://rubygems.org' + +gemspec + +group :development, :test do + gem 'rake', '~> 13.0.1' + gem 'pry-byebug' + gem 'rubocop', '~> 0.66.0' +end diff --git a/src/README.md b/src/README.md new file mode 100644 index 0000000..6a9478e --- /dev/null +++ b/src/README.md @@ -0,0 +1,106 @@ +# databox + +Databox - the Ruby gem for the Static OpenAPI document of Push API resource + +Push API resources Open API documentation + +This SDK is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: + +- API version: 0.4.0 +- Package version: 2.1.1 +- Generator version: 7.6.0 +- Build package: org.openapitools.codegen.languages.RubyClientCodegen + +## Installation + +### Build a gem + +To build the Ruby code into a gem: + +```shell +gem build databox.gemspec +``` + +Then either install the gem locally: + +```shell +gem install ./databox-2.1.1.gem +``` + +(for development, run `gem install --dev ./databox-2.1.1.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 'databox', '~> 2.1.1' + +### 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 'databox', :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 'databox' + +# Setup authorization +Databox.configure do |config| + # Configure HTTP basic authorization: basicAuth + config.username = 'YOUR_USERNAME' + config.password = 'YOUR_PASSWORD' +end + +api_instance = Databox::DefaultApi.new + +begin + api_instance.data_delete +rescue Databox::ApiError => e + puts "Exception when calling DefaultApi->data_delete: #{e}" +end + +``` + +## Documentation for API Endpoints + +All URIs are relative to *https://push.databox.com* + +Class | Method | HTTP request | Description +------------ | ------------- | ------------- | ------------- +*Databox::DefaultApi* | [**data_delete**](docs/DefaultApi.md#data_delete) | **DELETE** /data | +*Databox::DefaultApi* | [**data_metric_key_delete**](docs/DefaultApi.md#data_metric_key_delete) | **DELETE** /data/{metricKey} | +*Databox::DefaultApi* | [**data_post**](docs/DefaultApi.md#data_post) | **POST** /data | +*Databox::DefaultApi* | [**metrickeys_get**](docs/DefaultApi.md#metrickeys_get) | **GET** /metrickeys | +*Databox::DefaultApi* | [**metrickeys_post**](docs/DefaultApi.md#metrickeys_post) | **POST** /metrickeys | +*Databox::DefaultApi* | [**ping_get**](docs/DefaultApi.md#ping_get) | **GET** /ping | + + +## Documentation for Models + + - [Databox::ApiResponse](docs/ApiResponse.md) + - [Databox::PushData](docs/PushData.md) + - [Databox::PushDataAttribute](docs/PushDataAttribute.md) + - [Databox::State](docs/State.md) + + +## Documentation for Authorization + + +Authentication schemes defined for the API: +### basicAuth + +- **Type**: HTTP basic authentication + diff --git a/src/Rakefile b/src/Rakefile new file mode 100644 index 0000000..c72ca30 --- /dev/null +++ b/src/Rakefile @@ -0,0 +1,10 @@ +require "bundler/gem_tasks" + +begin + require 'rspec/core/rake_task' + + RSpec::Core::RakeTask.new(:spec) + task default: :spec +rescue LoadError + # no rspec available +end diff --git a/src/databox.gemspec b/src/databox.gemspec new file mode 100644 index 0000000..edac75e --- /dev/null +++ b/src/databox.gemspec @@ -0,0 +1,39 @@ +# -*- encoding: utf-8 -*- + +=begin +#Static OpenAPI document of Push API resource + +#Push API resources Open API documentation + +The version of the OpenAPI document: 0.4.0 + +Generated by: https://openapi-generator.tech +Generator version: 7.6.0 + +=end + +$:.push File.expand_path("../lib", __FILE__) +require "databox/version" + +Gem::Specification.new do |s| + s.name = "databox" + s.version = Databox::VERSION + s.platform = Gem::Platform::RUBY + s.authors = ["Databox"] + s.email = [""] + s.homepage = "https://databox.com/" + s.summary = "Static OpenAPI document of Push API resource Ruby Gem" + s.description = "SDK Client for using Databox Push API feature" + s.license = "Unlicense" + s.required_ruby_version = ">= 2.7" + s.metadata = {} + + s.add_runtime_dependency 'typhoeus', '~> 1.0', '>= 1.0.1' + + s.add_development_dependency 'rspec', '~> 3.6', '>= 3.6.0' + + s.files = `find *`.split("\n").uniq.sort.select { |f| !f.empty? } + s.test_files = `find spec/*`.split("\n") + s.executables = [] + s.require_paths = ["lib"] +end diff --git a/src/docs/ApiResponse.md b/src/docs/ApiResponse.md new file mode 100644 index 0000000..5318886 --- /dev/null +++ b/src/docs/ApiResponse.md @@ -0,0 +1,20 @@ +# Databox::ApiResponse + +## Properties + +| Name | Type | Description | Notes | +| ---- | ---- | ----------- | ----- | +| **status** | **String** | | [optional] | +| **message** | **String** | | [optional] | + +## Example + +```ruby +require 'databox' + +instance = Databox::ApiResponse.new( + status: null, + message: null +) +``` + diff --git a/src/docs/DefaultApi.md b/src/docs/DefaultApi.md new file mode 100644 index 0000000..a4631cc --- /dev/null +++ b/src/docs/DefaultApi.md @@ -0,0 +1,410 @@ +# Databox::DefaultApi + +All URIs are relative to *https://push.databox.com* + +| Method | HTTP request | Description | +| ------ | ------------ | ----------- | +| [**data_delete**](DefaultApi.md#data_delete) | **DELETE** /data | | +| [**data_metric_key_delete**](DefaultApi.md#data_metric_key_delete) | **DELETE** /data/{metricKey} | | +| [**data_post**](DefaultApi.md#data_post) | **POST** /data | | +| [**metrickeys_get**](DefaultApi.md#metrickeys_get) | **GET** /metrickeys | | +| [**metrickeys_post**](DefaultApi.md#metrickeys_post) | **POST** /metrickeys | | +| [**ping_get**](DefaultApi.md#ping_get) | **GET** /ping | | + + +## data_delete + +> data_delete + + + +### Examples + +```ruby +require 'time' +require 'databox' +# setup authorization +Databox.configure do |config| + # Configure HTTP basic authorization: basicAuth + config.username = 'YOUR USERNAME' + config.password = 'YOUR PASSWORD' +end + +api_instance = Databox::DefaultApi.new + +begin + + api_instance.data_delete +rescue Databox::ApiError => e + puts "Error when calling DefaultApi->data_delete: #{e}" +end +``` + +#### Using the data_delete_with_http_info variant + +This returns an Array which contains the response data (`nil` in this case), status code and headers. + +> data_delete_with_http_info + +```ruby +begin + + data, status_code, headers = api_instance.data_delete_with_http_info + p status_code # => 2xx + p headers # => { ... } + p data # => nil +rescue Databox::ApiError => e + puts "Error when calling DefaultApi->data_delete_with_http_info: #{e}" +end +``` + +### Parameters + +This endpoint does not need any parameter. + +### Return type + +nil (empty response body) + +### Authorization + +[basicAuth](../README.md#basicAuth) + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: Not defined + + +## data_metric_key_delete + +> data_metric_key_delete(metric_key) + + + +### Examples + +```ruby +require 'time' +require 'databox' +# setup authorization +Databox.configure do |config| + # Configure HTTP basic authorization: basicAuth + config.username = 'YOUR USERNAME' + config.password = 'YOUR PASSWORD' +end + +api_instance = Databox::DefaultApi.new +metric_key = 'metric_key_example' # String | + +begin + + api_instance.data_metric_key_delete(metric_key) +rescue Databox::ApiError => e + puts "Error when calling DefaultApi->data_metric_key_delete: #{e}" +end +``` + +#### Using the data_metric_key_delete_with_http_info variant + +This returns an Array which contains the response data (`nil` in this case), status code and headers. + +> data_metric_key_delete_with_http_info(metric_key) + +```ruby +begin + + data, status_code, headers = api_instance.data_metric_key_delete_with_http_info(metric_key) + p status_code # => 2xx + p headers # => { ... } + p data # => nil +rescue Databox::ApiError => e + puts "Error when calling DefaultApi->data_metric_key_delete_with_http_info: #{e}" +end +``` + +### Parameters + +| Name | Type | Description | Notes | +| ---- | ---- | ----------- | ----- | +| **metric_key** | **String** | | | + +### Return type + +nil (empty response body) + +### Authorization + +[basicAuth](../README.md#basicAuth) + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: Not defined + + +## data_post + +> data_post(opts) + + + +### Examples + +```ruby +require 'time' +require 'databox' +# setup authorization +Databox.configure do |config| + # Configure HTTP basic authorization: basicAuth + config.username = 'YOUR USERNAME' + config.password = 'YOUR PASSWORD' +end + +api_instance = Databox::DefaultApi.new +opts = { + push_data: [Databox::PushData.new] # Array | +} + +begin + + api_instance.data_post(opts) +rescue Databox::ApiError => e + puts "Error when calling DefaultApi->data_post: #{e}" +end +``` + +#### Using the data_post_with_http_info variant + +This returns an Array which contains the response data (`nil` in this case), status code and headers. + +> data_post_with_http_info(opts) + +```ruby +begin + + data, status_code, headers = api_instance.data_post_with_http_info(opts) + p status_code # => 2xx + p headers # => { ... } + p data # => nil +rescue Databox::ApiError => e + puts "Error when calling DefaultApi->data_post_with_http_info: #{e}" +end +``` + +### Parameters + +| Name | Type | Description | Notes | +| ---- | ---- | ----------- | ----- | +| **push_data** | [**Array<PushData>**](PushData.md) | | [optional] | + +### Return type + +nil (empty response body) + +### Authorization + +[basicAuth](../README.md#basicAuth) + +### HTTP request headers + +- **Content-Type**: application/json, application/vnd.databox.v2+json +- **Accept**: Not defined + + +## metrickeys_get + +> metrickeys_get + + + +### Examples + +```ruby +require 'time' +require 'databox' +# setup authorization +Databox.configure do |config| + # Configure HTTP basic authorization: basicAuth + config.username = 'YOUR USERNAME' + config.password = 'YOUR PASSWORD' +end + +api_instance = Databox::DefaultApi.new + +begin + + api_instance.metrickeys_get +rescue Databox::ApiError => e + puts "Error when calling DefaultApi->metrickeys_get: #{e}" +end +``` + +#### Using the metrickeys_get_with_http_info variant + +This returns an Array which contains the response data (`nil` in this case), status code and headers. + +> metrickeys_get_with_http_info + +```ruby +begin + + data, status_code, headers = api_instance.metrickeys_get_with_http_info + p status_code # => 2xx + p headers # => { ... } + p data # => nil +rescue Databox::ApiError => e + puts "Error when calling DefaultApi->metrickeys_get_with_http_info: #{e}" +end +``` + +### Parameters + +This endpoint does not need any parameter. + +### Return type + +nil (empty response body) + +### Authorization + +[basicAuth](../README.md#basicAuth) + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: Not defined + + +## metrickeys_post + +> metrickeys_post(opts) + + + +### Examples + +```ruby +require 'time' +require 'databox' +# setup authorization +Databox.configure do |config| + # Configure HTTP basic authorization: basicAuth + config.username = 'YOUR USERNAME' + config.password = 'YOUR PASSWORD' +end + +api_instance = Databox::DefaultApi.new +opts = { + body: { ... } # Object | +} + +begin + + api_instance.metrickeys_post(opts) +rescue Databox::ApiError => e + puts "Error when calling DefaultApi->metrickeys_post: #{e}" +end +``` + +#### Using the metrickeys_post_with_http_info variant + +This returns an Array which contains the response data (`nil` in this case), status code and headers. + +> metrickeys_post_with_http_info(opts) + +```ruby +begin + + data, status_code, headers = api_instance.metrickeys_post_with_http_info(opts) + p status_code # => 2xx + p headers # => { ... } + p data # => nil +rescue Databox::ApiError => e + puts "Error when calling DefaultApi->metrickeys_post_with_http_info: #{e}" +end +``` + +### Parameters + +| Name | Type | Description | Notes | +| ---- | ---- | ----------- | ----- | +| **body** | **Object** | | [optional] | + +### Return type + +nil (empty response body) + +### Authorization + +[basicAuth](../README.md#basicAuth) + +### HTTP request headers + +- **Content-Type**: application/json, application/vnd.databox.v2+json +- **Accept**: Not defined + + +## ping_get + +> ping_get + + + +### Examples + +```ruby +require 'time' +require 'databox' +# setup authorization +Databox.configure do |config| + # Configure HTTP basic authorization: basicAuth + config.username = 'YOUR USERNAME' + config.password = 'YOUR PASSWORD' +end + +api_instance = Databox::DefaultApi.new + +begin + + api_instance.ping_get +rescue Databox::ApiError => e + puts "Error when calling DefaultApi->ping_get: #{e}" +end +``` + +#### Using the ping_get_with_http_info variant + +This returns an Array which contains the response data (`nil` in this case), status code and headers. + +> ping_get_with_http_info + +```ruby +begin + + data, status_code, headers = api_instance.ping_get_with_http_info + p status_code # => 2xx + p headers # => { ... } + p data # => nil +rescue Databox::ApiError => e + puts "Error when calling DefaultApi->ping_get_with_http_info: #{e}" +end +``` + +### Parameters + +This endpoint does not need any parameter. + +### Return type + +nil (empty response body) + +### Authorization + +[basicAuth](../README.md#basicAuth) + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: Not defined + diff --git a/src/docs/PushData.md b/src/docs/PushData.md new file mode 100644 index 0000000..87f09a5 --- /dev/null +++ b/src/docs/PushData.md @@ -0,0 +1,30 @@ +# Databox::PushData + +## Properties + +| Name | Type | Description | Notes | +| ---- | ---- | ----------- | ----- | +| **attributes** | [**Array<PushDataAttribute>**](PushDataAttribute.md) | | [optional] | +| **date** | **String** | | [optional] | +| **key** | **String** | | [optional] | +| **period_from** | **String** | | [optional] | +| **period_to** | **String** | | [optional] | +| **unit** | **String** | | [optional] | +| **value** | **Float** | | [optional] | + +## Example + +```ruby +require 'databox' + +instance = Databox::PushData.new( + attributes: null, + date: null, + key: null, + period_from: null, + period_to: null, + unit: null, + value: null +) +``` + diff --git a/src/docs/PushDataAttribute.md b/src/docs/PushDataAttribute.md new file mode 100644 index 0000000..2cd4b66 --- /dev/null +++ b/src/docs/PushDataAttribute.md @@ -0,0 +1,20 @@ +# Databox::PushDataAttribute + +## Properties + +| Name | Type | Description | Notes | +| ---- | ---- | ----------- | ----- | +| **key** | **String** | | [optional] | +| **value** | **String** | | [optional] | + +## Example + +```ruby +require 'databox' + +instance = Databox::PushDataAttribute.new( + key: null, + value: null +) +``` + diff --git a/src/docs/State.md b/src/docs/State.md new file mode 100644 index 0000000..cb4f8e2 --- /dev/null +++ b/src/docs/State.md @@ -0,0 +1,15 @@ +# Databox::State + +## Properties + +| Name | Type | Description | Notes | +| ---- | ---- | ----------- | ----- | + +## Example + +```ruby +require 'databox' + +instance = Databox::State.new() +``` + diff --git a/src/git_push.sh b/src/git_push.sh new file mode 100644 index 0000000..f53a75d --- /dev/null +++ b/src/git_push.sh @@ -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' diff --git a/src/lib/databox.rb b/src/lib/databox.rb new file mode 100644 index 0000000..e43f114 --- /dev/null +++ b/src/lib/databox.rb @@ -0,0 +1,44 @@ +=begin +#Static OpenAPI document of Push API resource + +#Push API resources Open API documentation + +The version of the OpenAPI document: 0.4.0 + +Generated by: https://openapi-generator.tech +Generator version: 7.6.0 + +=end + +# Common files +require 'databox/api_client' +require 'databox/api_error' +require 'databox/version' +require 'databox/configuration' + +# Models +require 'databox/models/api_response' +require 'databox/models/push_data' +require 'databox/models/push_data_attribute' +require 'databox/models/state' + +# APIs +require 'databox/api/default_api' + +module Databox + class << self + # Customize default settings for the SDK using block. + # Databox.configure do |config| + # config.username = "xxx" + # config.password = "xxx" + # end + # If no block given, return the default Configuration object. + def configure + if block_given? + yield(Configuration.default) + else + Configuration.default + end + end + end +end diff --git a/src/lib/databox/api/default_api.rb b/src/lib/databox/api/default_api.rb new file mode 100644 index 0000000..be13d7e --- /dev/null +++ b/src/lib/databox/api/default_api.rb @@ -0,0 +1,348 @@ +=begin +#Static OpenAPI document of Push API resource + +#Push API resources Open API documentation + +The version of the OpenAPI document: 0.4.0 + +Generated by: https://openapi-generator.tech +Generator version: 7.6.0 + +=end + +require 'cgi' + +module Databox + class DefaultApi + attr_accessor :api_client + + def initialize(api_client = ApiClient.default) + @api_client = api_client + end + # @param [Hash] opts the optional parameters + # @return [nil] + def data_delete(opts = {}) + data_delete_with_http_info(opts) + nil + end + + # @param [Hash] opts the optional parameters + # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers + def data_delete_with_http_info(opts = {}) + if @api_client.config.debugging + @api_client.config.logger.debug 'Calling API: DefaultApi.data_delete ...' + end + # resource path + local_var_path = '/data' + + # 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] || ['basicAuth'] + + new_options = opts.merge( + :operation => :"DefaultApi.data_delete", + :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: DefaultApi#data_delete\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}" + end + return data, status_code, headers + end + + # @param metric_key [String] + # @param [Hash] opts the optional parameters + # @return [nil] + def data_metric_key_delete(metric_key, opts = {}) + data_metric_key_delete_with_http_info(metric_key, opts) + nil + end + + # @param metric_key [String] + # @param [Hash] opts the optional parameters + # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers + def data_metric_key_delete_with_http_info(metric_key, opts = {}) + if @api_client.config.debugging + @api_client.config.logger.debug 'Calling API: DefaultApi.data_metric_key_delete ...' + end + # verify the required parameter 'metric_key' is set + if @api_client.config.client_side_validation && metric_key.nil? + fail ArgumentError, "Missing the required parameter 'metric_key' when calling DefaultApi.data_metric_key_delete" + end + # resource path + local_var_path = '/data/{metricKey}'.sub('{' + 'metricKey' + '}', CGI.escape(metric_key.to_s)) + + # 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] || ['basicAuth'] + + new_options = opts.merge( + :operation => :"DefaultApi.data_metric_key_delete", + :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: DefaultApi#data_metric_key_delete\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}" + end + return data, status_code, headers + end + + # @param [Hash] opts the optional parameters + # @option opts [Array] :push_data + # @return [nil] + def data_post(opts = {}) + data_post_with_http_info(opts) + nil + end + + # @param [Hash] opts the optional parameters + # @option opts [Array] :push_data + # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers + def data_post_with_http_info(opts = {}) + if @api_client.config.debugging + @api_client.config.logger.debug 'Calling API: DefaultApi.data_post ...' + end + # resource path + local_var_path = '/data' + + # 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/vnd.databox.v2+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(opts[:'push_data']) + + # return_type + return_type = opts[:debug_return_type] + + # auth_names + auth_names = opts[:debug_auth_names] || ['basicAuth'] + + new_options = opts.merge( + :operation => :"DefaultApi.data_post", + :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: DefaultApi#data_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}" + end + return data, status_code, headers + end + + # @param [Hash] opts the optional parameters + # @return [nil] + def metrickeys_get(opts = {}) + metrickeys_get_with_http_info(opts) + nil + end + + # @param [Hash] opts the optional parameters + # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers + def metrickeys_get_with_http_info(opts = {}) + if @api_client.config.debugging + @api_client.config.logger.debug 'Calling API: DefaultApi.metrickeys_get ...' + end + # resource path + local_var_path = '/metrickeys' + + # 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] || ['basicAuth'] + + new_options = opts.merge( + :operation => :"DefaultApi.metrickeys_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#metrickeys_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}" + end + return data, status_code, headers + end + + # @param [Hash] opts the optional parameters + # @option opts [Object] :body + # @return [nil] + def metrickeys_post(opts = {}) + metrickeys_post_with_http_info(opts) + nil + end + + # @param [Hash] opts the optional parameters + # @option opts [Object] :body + # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers + def metrickeys_post_with_http_info(opts = {}) + if @api_client.config.debugging + @api_client.config.logger.debug 'Calling API: DefaultApi.metrickeys_post ...' + end + # resource path + local_var_path = '/metrickeys' + + # 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/vnd.databox.v2+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(opts[:'body']) + + # return_type + return_type = opts[:debug_return_type] + + # auth_names + auth_names = opts[:debug_auth_names] || ['basicAuth'] + + new_options = opts.merge( + :operation => :"DefaultApi.metrickeys_post", + :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: DefaultApi#metrickeys_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}" + end + return data, status_code, headers + end + + # @param [Hash] opts the optional parameters + # @return [nil] + def ping_get(opts = {}) + ping_get_with_http_info(opts) + nil + end + + # @param [Hash] opts the optional parameters + # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers + def ping_get_with_http_info(opts = {}) + if @api_client.config.debugging + @api_client.config.logger.debug 'Calling API: DefaultApi.ping_get ...' + end + # resource path + local_var_path = '/ping' + + # 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] || ['basicAuth'] + + new_options = opts.merge( + :operation => :"DefaultApi.ping_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#ping_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}" + end + return data, status_code, headers + end + end +end diff --git a/src/lib/databox/api_client.rb b/src/lib/databox/api_client.rb new file mode 100644 index 0000000..5dee214 --- /dev/null +++ b/src/lib/databox/api_client.rb @@ -0,0 +1,394 @@ +=begin +#Static OpenAPI document of Push API resource + +#Push API resources Open API documentation + +The version of the OpenAPI document: 0.4.0 + +Generated by: https://openapi-generator.tech +Generator version: 7.6.0 + +=end + +require 'date' +require 'json' +require 'logger' +require 'tempfile' +require 'time' +require 'typhoeus' + + +module Databox + 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 (may be a Tempfile or nil), response status code and response headers. + def call_api(http_method, path, opts = {}) + request = build_request(http_method, path, opts) + tempfile = download_file(request) if opts[:return_type] == 'File' + 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] == 'File' + data = tempfile + elsif 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 + + Typhoeus::Request.new(url, req_opts) + 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 + # + # @return [Tempfile] the tempfile generated + 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) + end + request.on_body do |chunk| + chunk.force_encoding(encoding) + tempfile.write(chunk) + end + # run the request to ensure the tempfile is created successfully before returning it + request.run + 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`" + else + fail ApiError.new("Failed to create the tempfile based on the HTTP response from the server: #{request.inspect}") + end + + tempfile + 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", "Hash" + def deserialize(response, return_type) + body = response.body + return nil if body.nil? || body.empty? + + # return response body directly for String return type + return body.to_s 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 + sub_type = $1 + data.map { |item| convert_to_type(item, sub_type) } + when /\AHash\\z/ + # e.g. Hash + 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 = Databox.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.split(/[\/\\]/).last + 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 diff --git a/src/lib/databox/api_error.rb b/src/lib/databox/api_error.rb new file mode 100644 index 0000000..578d1c9 --- /dev/null +++ b/src/lib/databox/api_error.rb @@ -0,0 +1,58 @@ +=begin +#Static OpenAPI document of Push API resource + +#Push API resources Open API documentation + +The version of the OpenAPI document: 0.4.0 + +Generated by: https://openapi-generator.tech +Generator version: 7.6.0 + +=end + +module Databox + 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 + @message = arg + end + end + + # Override to_s to display a friendly error message + def to_s + message + end + + def message + if @message.nil? + msg = "Error message: the server returns an error" + else + msg = @message + end + + msg += "\nHTTP status code: #{code}" if code + msg += "\nResponse headers: #{response_headers}" if response_headers + msg += "\nResponse body: #{response_body}" if response_body + + msg + end + end +end diff --git a/src/lib/databox/configuration.rb b/src/lib/databox/configuration.rb new file mode 100644 index 0000000..3bd501e --- /dev/null +++ b/src/lib/databox/configuration.rb @@ -0,0 +1,298 @@ +=begin +#Static OpenAPI document of Push API resource + +#Push API resources Open API documentation + +The version of the OpenAPI document: 0.4.0 + +Generated by: https://openapi-generator.tech +Generator version: 7.6.0 + +=end + +module Databox + 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 + + # Defines a Proc used to fetch or refresh access tokens (Bearer) used with OAuth2. + # Overrides the access_token if set + # @return [Proc] + attr_accessor :access_token_getter + + # Set this to return data as binary instead of downloading a temp file. When enabled (set to true) + # HTTP responses with return type `File` will be returned as a stream of binary data. + # Default to false. + attr_accessor :return_binary_data + + # 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 = 'https' + @host = 'push.databox.com' + @base_path = '' + @server_index = nil + @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) + if operation_server_settings.key?(operation) then + index = server_operation_index.fetch(operation, server_index) + server_url(index.nil? ? 0 : index, server_operation_variables.fetch(operation, server_variables), operation_server_settings[operation]) + else + server_index.nil? ? "#{scheme}://#{[host, base_path].join('/').gsub(/\/+/, '/')}".sub(/\/+\z/, '') : server_url(server_index, server_variables, nil) + end + 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 access_token using access_token_getter or uses the static access_token + def access_token_with_refresh + return access_token if access_token_getter.nil? + access_token_getter.call + 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 + { + 'basicAuth' => + { + type: 'basic', + in: 'header', + key: 'Authorization', + value: basic_auth_token + }, + } + end + + # Returns an array of Server setting + def server_settings + [ + { + url: "https://push.databox.com", + description: "Dev mode server description", + } + ] + end + + def operation_server_settings + { + } + end + + # Returns URL based on server settings + # + # @param index array index of the server settings + # @param variables hash of variable and the corresponding value + def server_url(index, variables = {}, servers = nil) + servers = server_settings if servers == nil + + # check array index out of bound + if (index.nil? || index < 0 || index >= servers.size) + fail ArgumentError, "Invalid index #{index} when selecting the server. Must not be nil and must be less than #{servers.size}" + end + + server = servers[index] + url = server[:url] + + return url unless server.key? :variables + + # go through variable and assign a value + server[:variables].each do |name, variable| + if variables.key?(name) + if (!server[:variables][name].key?(:enum_values) || server[:variables][name][:enum_values].include?(variables[name])) + url.gsub! "{" + name.to_s + "}", variables[name] + else + fail ArgumentError, "The variable `#{name}` in the server URL has invalid value #{variables[name]}. Must be #{server[:variables][name][:enum_values]}." + end + else + # use default value + url.gsub! "{" + name.to_s + "}", server[:variables][name][:default_value] + end + end + + url + end + + + end +end diff --git a/src/lib/databox/models/api_response.rb b/src/lib/databox/models/api_response.rb new file mode 100644 index 0000000..4ea865c --- /dev/null +++ b/src/lib/databox/models/api_response.rb @@ -0,0 +1,223 @@ +=begin +#Static OpenAPI document of Push API resource + +#Push API resources Open API documentation + +The version of the OpenAPI document: 0.4.0 + +Generated by: https://openapi-generator.tech +Generator version: 7.6.0 + +=end + +require 'date' +require 'time' + +module Databox + class ApiResponse + attr_accessor :status + + attr_accessor :message + + # Attribute mapping from ruby-style variable name to JSON key. + def self.attribute_map + { + :'status' => :'status', + :'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 + { + :'status' => :'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 `Databox::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 `Databox::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?(:'status') + self.status = attributes[:'status'] + 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 + warn '[DEPRECATED] the `list_invalid_properties` method is obsolete' + 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? + warn '[DEPRECATED] the `valid?` method is obsolete' + 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 && + status == o.status && + 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 + [status, 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) + return nil unless attributes.is_a?(Hash) + attributes = attributes.transform_keys(&:to_sym) + transformed_hash = {} + openapi_types.each_pair do |key, type| + if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil? + transformed_hash["#{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[attribute_map[key]].is_a?(Array) + transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) } + end + elsif !attributes[attribute_map[key]].nil? + transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]]) + end + end + new(transformed_hash) + end + + # Deserializes the data based on type + # @param string type Data type + # @param string value Value to be deserialized + # @return [Object] Deserialized data + def self._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<(?.+)>\z/ + inner_type = Regexp.last_match[:inner_type] + value.map { |v| _deserialize(inner_type, v) } + when /\AHash<(?.+?), (?.+)>\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 = Databox.const_get(type) + klass.respond_to?(:openapi_any_of) || 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 diff --git a/src/lib/databox/models/push_data.rb b/src/lib/databox/models/push_data.rb new file mode 100644 index 0000000..020a7a4 --- /dev/null +++ b/src/lib/databox/models/push_data.rb @@ -0,0 +1,270 @@ +=begin +#Static OpenAPI document of Push API resource + +#Push API resources Open API documentation + +The version of the OpenAPI document: 0.4.0 + +Generated by: https://openapi-generator.tech +Generator version: 7.6.0 + +=end + +require 'date' +require 'time' + +module Databox + class PushData + attr_accessor :attributes + + attr_accessor :date + + attr_accessor :key + + attr_accessor :period_from + + attr_accessor :period_to + + attr_accessor :unit + + attr_accessor :value + + # Attribute mapping from ruby-style variable name to JSON key. + def self.attribute_map + { + :'attributes' => :'attributes', + :'date' => :'date', + :'key' => :'key', + :'period_from' => :'periodFrom', + :'period_to' => :'periodTo', + :'unit' => :'unit', + :'value' => :'value' + } + 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 + { + :'attributes' => :'Array', + :'date' => :'String', + :'key' => :'String', + :'period_from' => :'String', + :'period_to' => :'String', + :'unit' => :'String', + :'value' => :'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 `Databox::PushData` 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 `Databox::PushData`. 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?(:'attributes') + if (value = attributes[:'attributes']).is_a?(Array) + self.attributes = value + end + end + + if attributes.key?(:'date') + self.date = attributes[:'date'] + end + + if attributes.key?(:'key') + self.key = attributes[:'key'] + end + + if attributes.key?(:'period_from') + self.period_from = attributes[:'period_from'] + end + + if attributes.key?(:'period_to') + self.period_to = attributes[:'period_to'] + end + + if attributes.key?(:'unit') + self.unit = attributes[:'unit'] + end + + if attributes.key?(:'value') + self.value = attributes[:'value'] + 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 + warn '[DEPRECATED] the `list_invalid_properties` method is obsolete' + 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? + warn '[DEPRECATED] the `valid?` method is obsolete' + 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 && + attributes == o.attributes && + date == o.date && + key == o.key && + period_from == o.period_from && + period_to == o.period_to && + unit == o.unit && + value == o.value + 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 + [attributes, date, key, period_from, period_to, unit, value].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) + return nil unless attributes.is_a?(Hash) + attributes = attributes.transform_keys(&:to_sym) + transformed_hash = {} + openapi_types.each_pair do |key, type| + if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil? + transformed_hash["#{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[attribute_map[key]].is_a?(Array) + transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) } + end + elsif !attributes[attribute_map[key]].nil? + transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]]) + end + end + new(transformed_hash) + end + + # Deserializes the data based on type + # @param string type Data type + # @param string value Value to be deserialized + # @return [Object] Deserialized data + def self._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<(?.+)>\z/ + inner_type = Regexp.last_match[:inner_type] + value.map { |v| _deserialize(inner_type, v) } + when /\AHash<(?.+?), (?.+)>\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 = Databox.const_get(type) + klass.respond_to?(:openapi_any_of) || 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 diff --git a/src/lib/databox/models/push_data_attribute.rb b/src/lib/databox/models/push_data_attribute.rb new file mode 100644 index 0000000..d7cea34 --- /dev/null +++ b/src/lib/databox/models/push_data_attribute.rb @@ -0,0 +1,223 @@ +=begin +#Static OpenAPI document of Push API resource + +#Push API resources Open API documentation + +The version of the OpenAPI document: 0.4.0 + +Generated by: https://openapi-generator.tech +Generator version: 7.6.0 + +=end + +require 'date' +require 'time' + +module Databox + class PushDataAttribute + attr_accessor :key + + attr_accessor :value + + # Attribute mapping from ruby-style variable name to JSON key. + def self.attribute_map + { + :'key' => :'key', + :'value' => :'value' + } + 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 + { + :'key' => :'String', + :'value' => :'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 `Databox::PushDataAttribute` 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 `Databox::PushDataAttribute`. 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?(:'key') + self.key = attributes[:'key'] + end + + if attributes.key?(:'value') + self.value = attributes[:'value'] + 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 + warn '[DEPRECATED] the `list_invalid_properties` method is obsolete' + 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? + warn '[DEPRECATED] the `valid?` method is obsolete' + 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 && + key == o.key && + value == o.value + 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 + [key, value].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) + return nil unless attributes.is_a?(Hash) + attributes = attributes.transform_keys(&:to_sym) + transformed_hash = {} + openapi_types.each_pair do |key, type| + if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil? + transformed_hash["#{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[attribute_map[key]].is_a?(Array) + transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) } + end + elsif !attributes[attribute_map[key]].nil? + transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]]) + end + end + new(transformed_hash) + end + + # Deserializes the data based on type + # @param string type Data type + # @param string value Value to be deserialized + # @return [Object] Deserialized data + def self._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<(?.+)>\z/ + inner_type = Regexp.last_match[:inner_type] + value.map { |v| _deserialize(inner_type, v) } + when /\AHash<(?.+?), (?.+)>\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 = Databox.const_get(type) + klass.respond_to?(:openapi_any_of) || 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 diff --git a/src/lib/databox/models/state.rb b/src/lib/databox/models/state.rb new file mode 100644 index 0000000..2627af2 --- /dev/null +++ b/src/lib/databox/models/state.rb @@ -0,0 +1,40 @@ +=begin +#Static OpenAPI document of Push API resource + +#Push API resources Open API documentation + +The version of the OpenAPI document: 0.4.0 + +Generated by: https://openapi-generator.tech +Generator version: 7.6.0 + +=end + +require 'date' +require 'time' + +module Databox + class State + DOWN = "DOWN".freeze + UP = "UP".freeze + + def self.all_vars + @all_vars ||= [DOWN, UP].freeze + end + + # Builds the enum from string + # @param [String] The enum value in the form of the string + # @return [String] The enum value + def self.build_from_hash(value) + new.build_from_hash(value) + end + + # Builds the enum from string + # @param [String] The enum value in the form of the string + # @return [String] The enum value + def build_from_hash(value) + return value if State.all_vars.include?(value) + raise "Invalid ENUM value #{value} for class #State" + end + end +end diff --git a/src/lib/databox/version.rb b/src/lib/databox/version.rb new file mode 100644 index 0000000..8bb3664 --- /dev/null +++ b/src/lib/databox/version.rb @@ -0,0 +1,15 @@ +=begin +#Static OpenAPI document of Push API resource + +#Push API resources Open API documentation + +The version of the OpenAPI document: 0.4.0 + +Generated by: https://openapi-generator.tech +Generator version: 7.6.0 + +=end + +module Databox + VERSION = '2.1.1' +end diff --git a/src/spec/api/default_api_spec.rb b/src/spec/api/default_api_spec.rb new file mode 100644 index 0000000..09ffe74 --- /dev/null +++ b/src/spec/api/default_api_spec.rb @@ -0,0 +1,92 @@ +=begin +#Static OpenAPI document of Push API resource + +#Push API resources Open API documentation + +The version of the OpenAPI document: 0.4.0 + +Generated by: https://openapi-generator.tech +Generator version: 7.6.0 + +=end + +require 'spec_helper' +require 'json' + +# Unit tests for Databox::DefaultApi +# Automatically generated by openapi-generator (https://openapi-generator.tech) +# Please update as you see appropriate +describe 'DefaultApi' do + before do + # run before each test + @api_instance = Databox::DefaultApi.new + end + + after do + # run after each test + end + + describe 'test an instance of DefaultApi' do + it 'should create an instance of DefaultApi' do + expect(@api_instance).to be_instance_of(Databox::DefaultApi) + end + end + + # unit tests for data_delete + # @param [Hash] opts the optional parameters + # @return [nil] + describe 'data_delete test' do + it 'should work' do + # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/ + end + end + + # unit tests for data_metric_key_delete + # @param metric_key + # @param [Hash] opts the optional parameters + # @return [nil] + describe 'data_metric_key_delete test' do + it 'should work' do + # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/ + end + end + + # unit tests for data_post + # @param [Hash] opts the optional parameters + # @option opts [Array] :push_data + # @return [nil] + describe 'data_post test' do + it 'should work' do + # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/ + end + end + + # unit tests for metrickeys_get + # @param [Hash] opts the optional parameters + # @return [nil] + describe 'metrickeys_get test' do + it 'should work' do + # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/ + end + end + + # unit tests for metrickeys_post + # @param [Hash] opts the optional parameters + # @option opts [Object] :body + # @return [nil] + describe 'metrickeys_post test' do + it 'should work' do + # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/ + end + end + + # unit tests for ping_get + # @param [Hash] opts the optional parameters + # @return [nil] + describe 'ping_get test' do + it 'should work' do + # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/ + end + end + +end diff --git a/src/spec/models/api_response_spec.rb b/src/spec/models/api_response_spec.rb new file mode 100644 index 0000000..17864d6 --- /dev/null +++ b/src/spec/models/api_response_spec.rb @@ -0,0 +1,42 @@ +=begin +#Static OpenAPI document of Push API resource + +#Push API resources Open API documentation + +The version of the OpenAPI document: 0.4.0 + +Generated by: https://openapi-generator.tech +Generator version: 7.6.0 + +=end + +require 'spec_helper' +require 'json' +require 'date' + +# Unit tests for Databox::ApiResponse +# Automatically generated by openapi-generator (https://openapi-generator.tech) +# Please update as you see appropriate +describe Databox::ApiResponse do + let(:instance) { Databox::ApiResponse.new } + + describe 'test an instance of ApiResponse' do + it 'should create an instance of ApiResponse' do + # uncomment below to test the instance creation + #expect(instance).to be_instance_of(Databox::ApiResponse) + end + end + + describe 'test attribute "status"' do + it 'should work' do + # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/ + end + end + + describe 'test attribute "message"' do + it 'should work' do + # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/ + end + end + +end diff --git a/src/spec/models/push_data_attribute_spec.rb b/src/spec/models/push_data_attribute_spec.rb new file mode 100644 index 0000000..fc06cee --- /dev/null +++ b/src/spec/models/push_data_attribute_spec.rb @@ -0,0 +1,42 @@ +=begin +#Static OpenAPI document of Push API resource + +#Push API resources Open API documentation + +The version of the OpenAPI document: 0.4.0 + +Generated by: https://openapi-generator.tech +Generator version: 7.6.0 + +=end + +require 'spec_helper' +require 'json' +require 'date' + +# Unit tests for Databox::PushDataAttribute +# Automatically generated by openapi-generator (https://openapi-generator.tech) +# Please update as you see appropriate +describe Databox::PushDataAttribute do + let(:instance) { Databox::PushDataAttribute.new } + + describe 'test an instance of PushDataAttribute' do + it 'should create an instance of PushDataAttribute' do + # uncomment below to test the instance creation + #expect(instance).to be_instance_of(Databox::PushDataAttribute) + end + end + + describe 'test attribute "key"' do + it 'should work' do + # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/ + end + end + + describe 'test attribute "value"' do + it 'should work' do + # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/ + end + end + +end diff --git a/src/spec/models/push_data_spec.rb b/src/spec/models/push_data_spec.rb new file mode 100644 index 0000000..4322f1b --- /dev/null +++ b/src/spec/models/push_data_spec.rb @@ -0,0 +1,72 @@ +=begin +#Static OpenAPI document of Push API resource + +#Push API resources Open API documentation + +The version of the OpenAPI document: 0.4.0 + +Generated by: https://openapi-generator.tech +Generator version: 7.6.0 + +=end + +require 'spec_helper' +require 'json' +require 'date' + +# Unit tests for Databox::PushData +# Automatically generated by openapi-generator (https://openapi-generator.tech) +# Please update as you see appropriate +describe Databox::PushData do + let(:instance) { Databox::PushData.new } + + describe 'test an instance of PushData' do + it 'should create an instance of PushData' do + # uncomment below to test the instance creation + #expect(instance).to be_instance_of(Databox::PushData) + end + end + + describe 'test attribute "attributes"' do + it 'should work' do + # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/ + end + end + + describe 'test attribute "date"' do + it 'should work' do + # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/ + end + end + + describe 'test attribute "key"' do + it 'should work' do + # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/ + end + end + + describe 'test attribute "period_from"' do + it 'should work' do + # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/ + end + end + + describe 'test attribute "period_to"' do + it 'should work' do + # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/ + end + end + + describe 'test attribute "unit"' do + it 'should work' do + # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/ + end + end + + describe 'test attribute "value"' do + it 'should work' do + # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/ + end + end + +end diff --git a/src/spec/models/state_spec.rb b/src/spec/models/state_spec.rb new file mode 100644 index 0000000..120d6bf --- /dev/null +++ b/src/spec/models/state_spec.rb @@ -0,0 +1,30 @@ +=begin +#Static OpenAPI document of Push API resource + +#Push API resources Open API documentation + +The version of the OpenAPI document: 0.4.0 + +Generated by: https://openapi-generator.tech +Generator version: 7.6.0 + +=end + +require 'spec_helper' +require 'json' +require 'date' + +# Unit tests for Databox::State +# Automatically generated by openapi-generator (https://openapi-generator.tech) +# Please update as you see appropriate +describe Databox::State do + let(:instance) { Databox::State.new } + + describe 'test an instance of State' do + it 'should create an instance of State' do + # uncomment below to test the instance creation + #expect(instance).to be_instance_of(Databox::State) + end + end + +end diff --git a/src/spec/spec_helper.rb b/src/spec/spec_helper.rb new file mode 100644 index 0000000..0609261 --- /dev/null +++ b/src/spec/spec_helper.rb @@ -0,0 +1,111 @@ +=begin +#Static OpenAPI document of Push API resource + +#Push API resources Open API documentation + +The version of the OpenAPI document: 0.4.0 + +Generated by: https://openapi-generator.tech +Generator version: 7.6.0 + +=end + +# load the gem +require 'databox' + +# The following was generated by the `rspec --init` command. Conventionally, all +# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`. +# The generated `.rspec` file contains `--require spec_helper` which will cause +# this file to always be loaded, without a need to explicitly require it in any +# files. +# +# Given that it is always loaded, you are encouraged to keep this file as +# light-weight as possible. Requiring heavyweight dependencies from this file +# will add to the boot time of your test suite on EVERY test run, even for an +# individual file that may not need all of that loaded. Instead, consider making +# a separate helper file that requires the additional dependencies and performs +# the additional setup, and require it from the spec files that actually need +# it. +# +# The `.rspec` file also contains a few flags that are not defaults but that +# users commonly want. +# +# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration +RSpec.configure do |config| + # rspec-expectations config goes here. You can use an alternate + # assertion/expectation library such as wrong or the stdlib/minitest + # assertions if you prefer. + config.expect_with :rspec do |expectations| + # This option will default to `true` in RSpec 4. It makes the `description` + # and `failure_message` of custom matchers include text for helper methods + # defined using `chain`, e.g.: + # be_bigger_than(2).and_smaller_than(4).description + # # => "be bigger than 2 and smaller than 4" + # ...rather than: + # # => "be bigger than 2" + expectations.include_chain_clauses_in_custom_matcher_descriptions = true + end + + # rspec-mocks config goes here. You can use an alternate test double + # library (such as bogus or mocha) by changing the `mock_with` option here. + config.mock_with :rspec do |mocks| + # Prevents you from mocking or stubbing a method that does not exist on + # a real object. This is generally recommended, and will default to + # `true` in RSpec 4. + mocks.verify_partial_doubles = true + end + +# The settings below are suggested to provide a good initial experience +# with RSpec, but feel free to customize to your heart's content. +=begin + # These two settings work together to allow you to limit a spec run + # to individual examples or groups you care about by tagging them with + # `:focus` metadata. When nothing is tagged with `:focus`, all examples + # get run. + config.filter_run :focus + config.run_all_when_everything_filtered = true + + # Allows RSpec to persist some state between runs in order to support + # the `--only-failures` and `--next-failure` CLI options. We recommend + # you configure your source control system to ignore this file. + config.example_status_persistence_file_path = "spec/examples.txt" + + # Limits the available syntax to the non-monkey patched syntax that is + # recommended. For more details, see: + # - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/ + # - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/ + # - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode + config.disable_monkey_patching! + + # This setting enables warnings. It's recommended, but in some cases may + # be too noisy due to issues in dependencies. + config.warnings = true + + # Many RSpec users commonly either run the entire suite or an individual + # file, and it's useful to allow more verbose output when running an + # individual spec file. + if config.files_to_run.one? + # Use the documentation formatter for detailed output, + # unless a formatter has already been configured + # (e.g. via a command-line flag). + config.default_formatter = 'doc' + end + + # Print the 10 slowest examples and example groups at the + # end of the spec run, to help surface which specs are running + # particularly slow. + config.profile_examples = 10 + + # Run specs in random order to surface order dependencies. If you find an + # order dependency and want to debug it, you can fix the order by providing + # the seed, which is printed after each run. + # --seed 1234 + config.order = :random + + # Seed global randomization in this process using the `--seed` CLI option. + # Setting this allows you to use `--seed` to deterministically reproduce + # test failures related to randomization by passing the same `--seed` value + # as the one that triggered the failure. + Kernel.srand config.seed +=end +end