apimatic_calculator_test_ruby2 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '08c356f35b0fd535093d0908939a8d36ac194e1f36095527f89a39f0f4cc9e2f'
+  data.tar.gz: 4f73d467f4d0250d11d8a932d68ad880825c6bd23e871957524a16a0577e25c7
+SHA512:
+  metadata.gz: 38d3457e6a6fc6092c8ecab370d7b66a133008d0c17bbf1aeadadb7fca7a4428ce789fb4c66e04c43096501ed81759b462cbce112b89806404d18ff671df375e
+  data.tar.gz: 6766d6a8c3e458c1ff214ed49d12673bc29cfaef10fcbb87a7824a014bd46b48cded5d4ac5daeda6867779d1c24ba5748fc1e63a87024985d91159218a8fa2d9

data/LICENSE

@@ -0,0 +1,28 @@
+License: 
+========
+The MIT License (MIT)
+http://opensource.org/licenses/MIT
+
+Copyright (c) 2014 - 2023 APIMATIC Limited
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+Trade Mark:
+==========
+APIMATIC is a trade mark for APIMATIC Limited

data/README.md

@@ -0,0 +1,110 @@
+
+# Getting Started with APIMATIC Calculator
+
+## Introduction
+
+Simple calculator API hosted on APIMATIC
+
+## Building
+
+The generated code depends on a few Ruby gems. The references to these gems are added in the gemspec file. The easiest way to resolve the dependencies, build the gem and install it is through Rake:
+
+1. Install Rake if not already installed: `gem install rake`
+2. Install Bundler if not already installed: `gem install bundler`
+3. From terminal/cmd navigate to the root directory of the SDK.
+4. Invoke: `rake install`
+
+Alternatively, you can build and install the gem manually:
+
+1. From terminal/cmd navigate to the root directory of the SDK.
+2. Run the build command: `gem build apimatic_calculator.gemspec`
+3. Run the install command: `gem install apimatic_calculator-1.0.0.gem`
+
+![Installing Gem](https://apidocs.io/illustration/ruby?workspaceFolder=ApimaticCalculator&gemVer=1.0.0&gemName=apimatic_calculator&step=buildSDK)
+
+## Installation
+
+The following section explains how to use the apimatic_calculator ruby gem in a new Rails project using RubyMine™. The basic workflow presented here is also applicable if you prefer using a different editor or IDE.
+
+### 1. Starting a new project
+
+Close any existing projects in RubyMine™ by selecting `File -> Close Project`. Next, click on `Create New Project` to create a new project from scratch.
+
+![Create a new project in RubyMine - Step 1](https://apidocs.io/illustration/ruby?workspaceFolder=ApimaticCalculator&step=createNewProject0)
+
+Next, provide `TestApp` as the project name, choose `Rails Application` as the project type, and click `OK`.
+
+![Create a new Rails Application in RubyMine - Step 2](https://apidocs.io/illustration/ruby?workspaceFolder=ApimaticCalculator&step=createNewProject1)
+
+In the next dialog make sure that the correct Ruby SDK is being used (>= 2.6 and < 3.1) and click `OK`.
+
+![Create a new Rails Application in RubyMine - Step 3](https://apidocs.io/illustration/ruby?workspaceFolder=ApimaticCalculator&step=createNewProject2)
+
+### 2. Add reference of the gem
+
+In order to use the Tester gem in the new project we must add a gem reference. Locate the `Gemfile` in the Project Explorer window under the `TestApp` project node. The file contains references to all gems being used in the project. Here, add the reference to the library gem by adding the following line: `gem 'apimatic_calculator', '1.0.0'`
+
+![Add new reference to the Gemfile](https://apidocs.io/illustration/ruby?workspaceFolder=ApimaticCalculator&gemVer=1.0.0&gemName=apimatic_calculator&step=addReference)
+
+### 3. Adding a new Rails Controller
+
+Once the `TestApp` project is created, a folder named `controllers` will be visible in the *Project Explorer* under the following path: `TestApp > app > controllers`. Right click on this folder and select `New -> Run Rails Generator...`.
+
+![Run Rails Generator on Controllers Folder](https://apidocs.io/illustration/ruby?workspaceFolder=ApimaticCalculator&gemVer=1.0.0&gemName=apimatic_calculator&step=addCode0)
+
+Selecting the said option will popup a small window where the generator names are displayed. Here, select the `controller` template.
+
+![Create a new Controller](https://apidocs.io/illustration/ruby?workspaceFolder=ApimaticCalculator&step=addCode1)
+
+Next, a popup window will ask you for a Controller name and included Actions. For controller name provide `Hello` and include an action named `Index` and click `OK`.
+
+![Add a new Controller](https://apidocs.io/illustration/ruby?workspaceFolder=ApimaticCalculator&gemVer=1.0.0&gemName=apimatic_calculator&step=addCode2)
+
+A new controller class named `HelloController` will be created in a file named `hello_controller.rb` containing a method named `Index`. In this method, add code for initialization and a sample for its usage.
+
+![Initialize the library](https://apidocs.io/illustration/ruby?workspaceFolder=ApimaticCalculator&gemName=apimatic_calculator&step=addCode3)
+
+## Test the SDK
+
+To run the tests, navigate to the root directory of the SDK in your terminal and execute the following command:
+
+```
+rake
+```
+
+## Initialize the API Client
+
+**_Note:_** Documentation for the client can be found [here.](doc/client.md)
+
+The following parameters are configurable for the API Client:
+
+| Parameter | Type | Description |
+|  --- | --- | --- |
+| `environment` | Environment | The API environment. <br> **Default: `Environment.PRODUCTION`** |
+| `connection` | `Faraday::Connection` | The Faraday connection object passed by the SDK user for making requests |
+| `adapter` | `Faraday::Adapter` | The Faraday adapter object passed by the SDK user for performing http requests |
+| `timeout` | `Float` | The value to use for connection timeout. <br> **Default: 60** |
+| `max_retries` | `Integer` | The number of times to retry an endpoint call if it fails. <br> **Default: 0** |
+| `retry_interval` | `Float` | Pause in seconds between retries. <br> **Default: 1** |
+| `backoff_factor` | `Float` | The amount to multiply each successive retry's interval amount by in order to provide backoff. <br> **Default: 2** |
+| `retry_statuses` | `Array` | A list of HTTP statuses to retry. <br> **Default: [408, 413, 429, 500, 502, 503, 504, 521, 522, 524]** |
+| `retry_methods` | `Array` | A list of HTTP methods to retry. <br> **Default: %i[get put]** |
+
+The API client can be initialized as follows:
+
+```ruby
+client = ApimaticCalculator::Client.new(
+  environment: Environment::PRODUCTION,
+)
+```
+
+## List of APIs
+
+* [Simple Calculator](doc/controllers/simple-calculator.md)
+
+## Classes Documentation
+
+* [Utility Classes](doc/utility-classes.md)
+* [HttpResponse](doc/http-response.md)
+* [HttpRequest](doc/http-request.md)
+

data/lib/apimatic_calculator/api_helper.rb

@@ -0,0 +1,449 @@
+# apimatic_calculator
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module ApimaticCalculator
+  # API utility class
+  class APIHelper
+    # Serializes an array parameter (creates key value pairs).
+    # @param [String] The name of the parameter.
+    # @param [Array] The value of the parameter.
+    # @param [String] The format of the serialization.
+    def self.serialize_array(key, array, formatting: 'indexed')
+      tuples = []
+
+      tuples += case formatting
+                when 'csv'
+                  [[key, array.map { |element| CGI.escape(element.to_s) }.join(',')]]
+                when 'psv'
+                  [[key, array.map { |element| CGI.escape(element.to_s) }.join('|')]]
+                when 'tsv'
+                  [[key, array.map { |element| CGI.escape(element.to_s) }.join("\t")]]
+                else
+                  array.map { |element| [key, element] }
+                end
+      tuples
+    end
+
+    # Replaces template parameters in the given url.
+    # @param [String] The query string builder to replace the template
+    # parameters.
+    # @param [Hash] The parameters to replace in the url.
+    def self.append_url_with_template_parameters(query_builder, parameters)
+      # perform parameter validation
+      unless query_builder.instance_of? String
+        raise ArgumentError, 'Given value for parameter \"query_builder\" is
+          invalid.'
+      end
+
+      # Return if there are no parameters to replace.
+      return query_builder if parameters.nil?
+
+      parameters.each do |key, val|
+        if val.nil?
+          replace_value = ''
+        elsif val['value'].instance_of? Array
+          if val['encode'] == true
+            val['value'].map! { |element| CGI.escape(element.to_s) }
+          else
+            val['value'].map!(&:to_s)
+          end
+          replace_value = val['value'].join('/')
+        else
+          replace_value = if val['encode'] == true
+                            CGI.escape(val['value'].to_s)
+                          else
+                            val['value'].to_s
+                          end
+        end
+
+        # Find the template parameter and replace it with its value.
+        query_builder = query_builder.gsub("{#{key}}", replace_value)
+      end
+      query_builder
+    end
+
+    # Appends the given set of parameters to the given query string.
+    # @param [String] The query string builder to add the query parameters to.
+    # @param [Hash] The parameters to append.
+    def self.append_url_with_query_parameters(query_builder, parameters)
+      # Perform parameter validation.
+      unless query_builder.instance_of? String
+        raise ArgumentError, 'Given value for parameter \"query_builder\"
+          is invalid.'
+      end
+
+      # Return if there are no parameters to replace.
+      return query_builder if parameters.nil?
+
+      array_serialization = 'indexed'
+      parameters = process_complex_types_parameters(parameters, array_serialization)
+
+      parameters.each do |key, value|
+        seperator = query_builder.include?('?') ? '&' : '?'
+        unless value.nil?
+          if value.instance_of? Array
+            value.compact!
+            APIHelper.serialize_array(
+              key, value, formatting: array_serialization
+            ).each do |element|
+              seperator = query_builder.include?('?') ? '&' : '?'
+              query_builder += "#{seperator}#{element[0]}=#{element[1]}"
+            end
+          else
+            query_builder += "#{seperator}#{key}=#{CGI.escape(value.to_s)}"
+          end
+        end
+      end
+      query_builder
+    end
+
+    # Validates and processes the given Url.
+    # @param [String] The given Url to process.
+    # @return [String] Pre-processed Url as string.
+    def self.clean_url(url)
+      # Perform parameter validation.
+      raise ArgumentError, 'Invalid Url.' unless url.instance_of? String
+
+      # Ensure that the urls are absolute.
+      matches = url.match(%r{^(https?://[^/]+)})
+      raise ArgumentError, 'Invalid Url format.' if matches.nil?
+
+      # Get the http protocol match.
+      protocol = matches[1]
+
+      # Check if parameters exist.
+      index = url.index('?')
+
+      # Remove redundant forward slashes.
+      query = url[protocol.length...(!index.nil? ? index : url.length)]
+      query.gsub!(%r{//+}, '/')
+
+      # Get the parameters.
+      parameters = !index.nil? ? url[url.index('?')...url.length] : ''
+
+      # Return processed url.
+      protocol + query + parameters
+    end
+
+    # Parses JSON string.
+    # @param [String] A JSON string.
+    def self.json_deserialize(json)
+      JSON.parse(json)
+    rescue StandardError
+      raise TypeError, 'Server responded with invalid JSON.'
+    end
+
+    # Parses JSON string.
+    # @param [object] The object to serialize.
+    def self.json_serialize(obj)
+      serializable_types.map { |x| obj.is_a? x }.any? ? obj.to_s : obj.to_json
+    end
+
+    # Removes elements with empty values from a hash.
+    # @param [Hash] The hash to clean.
+    def self.clean_hash(hash)
+      hash.delete_if { |_key, value| value.to_s.strip.empty? }
+    end
+
+    # Form encodes a hash of parameters.
+    # @param [Hash] The hash of parameters to encode.
+    # @return [Hash] A hash with the same parameters form encoded.
+    def self.form_encode_parameters(form_parameters)
+      array_serialization = 'indexed'
+      encoded = {}
+      form_parameters.each do |key, value|
+        encoded.merge!(APIHelper.form_encode(value, key, formatting:
+          array_serialization))
+      end
+      encoded
+    end
+
+    # Process complex types in query_params.
+    # @param [Hash] The hash of query parameters.
+    # @return [Hash] A hash with the processed query parameters.
+    def self.process_complex_types_parameters(query_parameters, array_serialization)
+      processed_params = {}
+      query_parameters.each do |key, value|
+        processed_params.merge!(APIHelper.form_encode(value, key, formatting:
+          array_serialization))
+      end
+      processed_params
+    end
+
+    def self.custom_merge(a, b)
+      x = {}
+      a.each do |key, value_a|
+        b.each do |k, value_b|
+          next unless key == k
+
+          x[k] = []
+          if value_a.instance_of? Array
+            value_a.each do |v|
+              x[k].push(v)
+            end
+          else
+            x[k].push(value_a)
+          end
+          if value_b.instance_of? Array
+            value_b.each do |v|
+              x[k].push(v)
+            end
+          else
+            x[k].push(value_b)
+          end
+          a.delete(k)
+          b.delete(k)
+        end
+      end
+      x.merge!(a)
+      x.merge!(b)
+      x
+    end
+
+    # Form encodes an object.
+    # @param [Dynamic] An object to form encode.
+    # @param [String] The name of the object.
+    # @return [Hash] A form encoded representation of the object in the form
+    # of a hash.
+    def self.form_encode(obj, instance_name, formatting: 'indexed')
+      retval = {}
+
+      # If this is a structure, resolve it's field names.
+      obj = obj.to_hash if obj.is_a? BaseModel
+
+      # Create a form encoded hash for this object.
+      if obj.nil?
+        nil
+      elsif obj.instance_of? Array
+        if formatting == 'indexed'
+          obj.each_with_index do |value, index|
+            retval.merge!(APIHelper.form_encode(value, "#{instance_name}[#{index}]"))
+          end
+        elsif APIHelper.serializable_types.map { |x| obj[0].is_a? x }.any?
+          obj.each do |value|
+            abc = if formatting == 'unindexed'
+                    APIHelper.form_encode(value, "#{instance_name}[]",
+                                          formatting: formatting)
+                  else
+                    APIHelper.form_encode(value, instance_name,
+                                          formatting: formatting)
+                  end
+            retval = APIHelper.custom_merge(retval, abc)
+          end
+        else
+          obj.each_with_index do |value, index|
+            retval.merge!(APIHelper.form_encode(value, "#{instance_name}[#{index}]",
+                                                formatting: formatting))
+          end
+        end
+      elsif obj.instance_of? Hash
+        obj.each do |key, value|
+          retval.merge!(APIHelper.form_encode(value, "#{instance_name}[#{key}]",
+                                              formatting: formatting))
+        end
+      elsif obj.instance_of? File
+        retval[instance_name] = UploadIO.new(
+          obj, 'application/octet-stream', File.basename(obj.path)
+        )
+      else
+        retval[instance_name] = obj
+      end
+      retval
+    end
+
+    # Retrieves a field from a Hash/Array based on an Array of keys/indexes
+    # @param [Hash, Array] The hash to extract data from
+    # @param [Array<String, Integer>] The keys/indexes to use
+    # @return [Object] The extracted value
+    def self.map_response(obj, keys)
+      val = obj
+      begin
+        keys.each do |key|
+          val = if val.is_a? Array
+                  if key.to_i.to_s == key
+                    val[key.to_i]
+                  else
+                    val = nil
+                  end
+                else
+                  val.fetch(key.to_sym)
+                end
+        end
+      rescue NoMethodError, TypeError, IndexError
+        val = nil
+      end
+      val
+    end
+
+    # Deserialize the value against the template (group of types).
+    # @param [String] The value to be deserialized.
+    # @param [String] The parameter indicates the type-combination
+    # against which the value will be mapped (oneOf(Integer, String)).
+    def self.deserialize(template, value)
+      decoded = APIHelper.json_deserialize(value)
+      map_types(decoded, template)
+    end
+
+    # Validates and processes the value against the template(group of types).
+    # @param [String] The value to be mapped against the template.
+    # @param [String] The parameter indicates the group of types (oneOf(Integer, String)).
+    # @param [String] The parameter indicates the group (oneOf|anyOf).
+    def self.map_types(value, template, group_name: nil)
+      result_value = nil
+      matches = 0
+      types = []
+      group_name = template.partition('(').first if group_name.nil? && template.match?(/anyOf|oneOf/)
+
+      return if value.nil?
+
+      if template.end_with?('{}') || template.end_with?('[]')
+        types = template.split(group_name, 2).last.gsub(/\s+/, '').split
+      else
+        template = template.split(group_name, 2).last.delete_prefix('(').delete_suffix(')')
+        types = template.scan(/(anyOf|oneOf)[(]([^[)]]*)[)]/).flatten.combination(2).map { |a, b| "#{a}(#{b})" }
+        types.each { |t| template = template.gsub(", #{t}", '') }
+        types = template.gsub(/\s+/, '').split(',').push(*types)
+      end
+      types.each do |element|
+        if element.match?(/^(oneOf|anyOf)[(].*$/)
+          begin
+            result_value = map_types(value, element, matches)
+            matches += 1
+          rescue ValidationException
+            next
+          end
+        elsif element.end_with?('{}')
+          result_value, matches = map_hash_type(value, element, group_name, matches)
+        elsif element.end_with?('[]')
+          result_value, matches = map_array_type(value, element, group_name, matches)
+        else
+          begin
+            result_value, matches = map_type(value, element, group_name, matches)
+          rescue StandardError
+            next
+          end
+        end
+        break if group_name == 'anyOf' && matches == 1
+      end
+      raise ValidationException.new(value, template) unless matches == 1
+
+      value = result_value unless result_value.nil?
+      value
+    end
+
+    # Validates and processes the value against the [Hash] type.
+    # @param [String] The value to be mapped against the type.
+    # @param [String] The possible type of the value.
+    # @param [String] The parameter indicates the group (oneOf|anyOf).
+    # @param [Integer] The parameter indicates the number of matches of value against types.
+    def self.map_hash_type(value, type, group_name, matches)
+      if value.instance_of? Hash
+        decoded = {}
+        value.each do |key, val|
+          type = type.chomp('{}').to_s
+          val = map_types(val, type, group_name: group_name)
+          decoded[key] = val unless type.empty?
+        rescue ValidationException
+          next
+        end
+        matches += 1 if decoded.length == value.length
+        value = decoded unless decoded.empty?
+      end
+      [value, matches]
+    end
+
+    # Validates and processes the value against the [Array] type.
+    # @param [String] The value to be mapped against the type.
+    # @param [String] The possible type of the value.
+    # @param [String] The parameter indicates the group (oneOf|anyOf).
+    # @param [Integer] The parameter indicates the number of matches of value against types.
+    def self.map_array_type(value, type, group_name, matches)
+      if value.instance_of? Array
+        decoded = []
+        value.each do |val|
+          type = type.chomp('[]').to_s
+          val = map_types(val, type, group_name: group_name)
+          decoded.append(val) unless type.empty?
+        rescue ValidationException
+          next
+        end
+        matches += 1 if decoded.length == value.length
+        value = decoded unless decoded.empty?
+      end
+      [value, matches]
+    end
+
+    # Validates and processes the value against the type.
+    # @param [String] The value to be mapped against the type.
+    # @param [String] The possible type of the value.
+    # @param [String] The parameter indicates the group (oneOf|anyOf).
+    # @param [Integer] The parameter indicates the number of matches of value against types.
+    def self.map_type(value, type, _group_name, matches)
+      if ApimaticCalculator.constants.select do |c|
+        ApimaticCalculator.const_get(c).to_s == "ApimaticCalculator::#{type}"
+      end.empty?
+        value, matches = map_data_type(value, type, matches)
+      else
+        value, matches = map_complex_type(value, type, matches)
+      end
+      [value, matches]
+    end
+
+    # Validates and processes the value against the complex types.
+    # @param [String] The value to be mapped against the type.
+    # @param [String] The possible type of the value.
+    # @param [Integer] The parameter indicates the number of matches of value against types.
+    def self.map_complex_type(value, type, matches)
+      obj = ApimaticCalculator.const_get(type)
+      value = if obj.respond_to? 'from_hash'
+                obj.send('from_hash', value)
+              else
+                obj.constants.find { |k| obj.const_get(k) == value }
+              end
+      matches += 1 unless value.nil?
+      [value, matches]
+    end
+
+    # Validates and processes the value against the data types.
+    # @param [String] The value to be mapped against the type.
+    # @param [String] The possible type of the value.
+    # @param [Integer] The parameter indicates the number of matches of value against types.
+    def self.map_data_type(value, element, matches)
+      element = element.split('|').map { |x| Object.const_get x }
+      matches += 1 if element.all? { |x| APIHelper.data_types.include?(x) } &&
+                      element.any? { |x| (value.instance_of? x) || (value.class.ancestors.include? x) }
+      [value, matches]
+    end
+
+    # Validates the value against the template(group of types).
+    # @param [String] The value to be mapped against the type.
+    # @param [String] The parameter indicates the group of types (oneOf(Integer, String)).
+    def self.validate_types(value, template)
+      map_types(APIHelper.json_deserialize(value.to_json), template)
+    end
+
+    # Get content-type depending on the value
+    def self.get_content_type(value)
+      if serializable_types.map { |x| value.is_a? x }.any?
+        'text/plain; charset=utf-8'
+      else
+        'application/json; charset=utf-8'
+      end
+    end
+
+    # Array of serializable types
+    def self.serializable_types
+      [String, Numeric, TrueClass,
+       FalseClass, Date, DateTime]
+    end
+
+    # Array of supported data types
+    def self.data_types
+      [String, Float, Integer,
+       TrueClass, FalseClass, Date,
+       DateTime, Array, Hash, Object]
+    end
+  end
+end

data/lib/apimatic_calculator/client.rb

@@ -0,0 +1,35 @@
+# apimatic_calculator
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module ApimaticCalculator
+  #  apimatic_calculator client class.
+  class Client
+    attr_reader :config
+
+    # Access to simple_calculator controller.
+    # @return [SimpleCalculatorController] Returns the controller instance.
+    def simple_calculator
+      @simple_calculator ||= SimpleCalculatorController.new config
+    end
+
+    def initialize(connection: nil, adapter: :net_http_persistent, timeout: 60,
+                   max_retries: 0, retry_interval: 1, backoff_factor: 2,
+                   retry_statuses: [408, 413, 429, 500, 502, 503, 504, 521, 522, 524],
+                   retry_methods: %i[get put],
+                   environment: Environment::PRODUCTION, config: nil)
+      @config = if config.nil?
+                  Configuration.new(connection: connection, adapter: adapter,
+                                    timeout: timeout, max_retries: max_retries,
+                                    retry_interval: retry_interval,
+                                    backoff_factor: backoff_factor,
+                                    retry_statuses: retry_statuses,
+                                    retry_methods: retry_methods,
+                                    environment: environment)
+                else
+                  config
+                end
+    end
+  end
+end