Calculator_Task 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b131a3d366194fc786d9e1cd8e17bff4a80724d0bffc48c5c4eb6b905056a793
+  data.tar.gz: 68a79cd8d607c70fd8318fcef99b9c111446d915a60b668617c072daeaa3ca53
+SHA512:
+  metadata.gz: 1088e7252340a2e3b4985f1b267d0ba0e8cc4ac163282e36d4ba151f82279013b7f1870390cbfb5b7a24d04cf183299e05467b90c6ca62028121c8ad89733ffa
+  data.tar.gz: 667235aaebff70f2dd5fa3fac52e788bcba29c26938c01c4e9f17c4757a40bc9a624bcf68a87ab12056d2a7550324e0cc7e54c2ef8271f13dc275623389903e1

data/LICENSE

@@ -0,0 +1,28 @@
+License: 
+========
+The MIT License (MIT)
+http://opensource.org/licenses/MIT
+
+Copyright (c) 2014 - 2016 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,135 @@
+# Getting started
+
+Simple Calculator API.
+
+## How to Build
+
+This client library is a Ruby gem which can be compiled and used in your Ruby and Ruby on Rails project. This library requires a few gems from the RubyGems repository.
+
+1. Open the command line interface or the terminal and navigate to the folder containing the source code.
+2. Run ``` gem build calculator_task.gemspec ``` to build the gem.
+3. Once built, the gem can be installed on the current work environment using ``` gem install calculator_task-1.0.gem ```
+
+![Building Gem](https://apidocs.io/illustration/ruby?step=buildSDK&workspaceFolder=Calculator%20Task-Ruby&workspaceName=Calculator%20Task-Ruby&projectName=calculator_task&gemName=calculator_task&gemVer=1.0)
+
+## How to Use
+
+The following section explains how to use the CalculatorTask 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](https://apidocs.io/illustration/ruby?step=createNewProject0&workspaceFolder=Calculator%20Task-Ruby&workspaceName=CalculatorTask&projectName=calculator_task&gemName=calculator_task&gemVer=1.0)
+
+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 1](https://apidocs.io/illustration/ruby?step=createNewProject1&workspaceFolder=Calculator%20Task-Ruby&workspaceName=CalculatorTask&projectName=calculator_task&gemName=calculator_task&gemVer=1.0)
+
+In the next dialog make sure that correct *Ruby SDK* is being used (minimum 2.0.0) and click ``` OK ```.
+
+![Create a new Rails Application in RubyMine - step 2](https://apidocs.io/illustration/ruby?step=createNewProject2&workspaceFolder=Calculator%20Task-Ruby&workspaceName=CalculatorTask&projectName=calculator_task&gemName=calculator_task&gemVer=1.0)
+
+This will create a new Rails Application project with an existing set of files and folder.
+
+### 2. Add reference of the gem
+
+In order to use the CalculatorTask 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 'calculator_task', '~> 1.0' ```
+
+![Add references of the Gemfile](https://apidocs.io/illustration/ruby?step=addReference&workspaceFolder=Calculator%20Task-Ruby&workspaceName=CalculatorTask&projectName=calculator_task&gemName=calculator_task&gemVer=1.0)
+
+### 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?step=addCode0&workspaceFolder=Calculator%20Task-Ruby&workspaceName=CalculatorTask&projectName=calculator_task&gemName=calculator_task&gemVer=1.0)
+
+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?step=addCode1&workspaceFolder=Calculator%20Task-Ruby&workspaceName=CalculatorTask&projectName=calculator_task&gemName=calculator_task&gemVer=1.0)
+
+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?step=addCode2&workspaceFolder=Calculator%20Task-Ruby&workspaceName=CalculatorTask&projectName=calculator_task&gemName=calculator_task&gemVer=1.0)
+
+A new controller class anmed ``` 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?step=addCode3&workspaceFolder=Calculator%20Task-Ruby&workspaceName=CalculatorTask&projectName=calculator_task&gemName=calculator_task&gemVer=1.0)
+
+## How to Test
+
+You can test the generated SDK and the server with automatically generated test
+cases as follows:
+
+  1. From terminal/cmd navigate to the root directory of the SDK.
+  2. Invoke: `bundle exec rake`
+
+## Initialization
+
+### 
+
+API client can be initialized as following.
+
+```ruby
+
+client = CalculatorTask::CalculatorTaskClient.new
+```
+
+The added initlization code can be debugged by putting a breakpoint in the ``` Index ``` method and running the project in debug mode by selecting ``` Run -> Debug 'Development: TestApp' ```.
+
+![Debug the TestApp](https://apidocs.io/illustration/ruby?step=addCode4&workspaceFolder=Calculator%20Task-Ruby&workspaceName=CalculatorTask&projectName=calculator_task&gemName=calculator_task&gemVer=1.0&initLine=client%2520%253D%2520CalculatorTaskClient.new)
+
+
+
+# Class Reference
+
+## <a name="list_of_controllers"></a>List of Controllers
+
+* [SimpleCalculatorController](#simple_calculator_controller)
+
+## <a name="simple_calculator_controller"></a>![Class: ](https://apidocs.io/img/class.png ".SimpleCalculatorController") SimpleCalculatorController
+
+### Get singleton instance
+
+The singleton instance of the ``` SimpleCalculatorController ``` class can be accessed from the API Client.
+
+```ruby
+simpleCalculator_controller = client.simple_calculator
+```
+
+### <a name="get_calculate"></a>![Method: ](https://apidocs.io/img/method.png ".SimpleCalculatorController.get_calculate") get_calculate
+
+> Endpoint Calculate
+
+
+```ruby
+def get_calculate(operation,
+                      x,
+                      y); end
+```
+
+#### Parameters
+
+| Parameter | Tags | Description |
+|-----------|------|-------------|
+| operation |  ``` Required ```  | the operation to apply |
+| x |  ``` Required ```  ``` DefaultValue ```  | LHS |
+| y |  ``` Required ```  ``` DefaultValue ```  | RHS |
+
+
+#### Example Usage
+
+```ruby
+operation = CalculatorTask::OperationTypeEnum::ADD
+x = 4
+y = 6
+
+result = simpleCalculator_controller.get_calculate(operation, x, y)
+
+```
+
+
+[Back to List of Controllers](#list_of_controllers)
+
+
+

data/lib/calculator_task.rb

@@ -0,0 +1,35 @@
+# calculator_task
+#
+# This file was automatically generated by APIMATIC v2.0 (
+# https://apimatic.io ).
+
+require 'date'
+require 'json'
+require 'faraday'
+require 'certifi'
+require 'logging'
+
+require_relative 'calculator_task/api_helper.rb'
+require_relative 'calculator_task/calculator_task_client.rb'
+
+# Http
+require_relative 'calculator_task/http/http_call_back.rb'
+require_relative 'calculator_task/http/http_client.rb'
+require_relative 'calculator_task/http/http_method_enum.rb'
+require_relative 'calculator_task/http/http_request.rb'
+require_relative 'calculator_task/http/http_response.rb'
+require_relative 'calculator_task/http/http_context.rb'
+require_relative 'calculator_task/http/faraday_client.rb'
+
+# Models
+require_relative 'calculator_task/models/base_model.rb'
+require_relative 'calculator_task/models/operation_type_enum.rb'
+
+# Exceptions
+require_relative 'calculator_task/exceptions/api_exception.rb'
+
+require_relative 'calculator_task/configuration.rb'
+
+# Controllers
+require_relative 'calculator_task/controllers/base_controller.rb'
+require_relative 'calculator_task/controllers/simple_calculator_controller.rb'

data/lib/calculator_task/api_helper.rb

@@ -0,0 +1,275 @@
+# calculator_task
+#
+# This file was automatically generated by APIMATIC v2.0 (
+# https://apimatic.io ).
+
+module CalculatorTask
+  # 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 = []
+
+      if formatting == 'unindexed'
+        tuples += array.map { |element| ["#{key}[]", element] }
+      elsif formatting == 'indexed'
+        tuples += array.map.with_index do |element, index|
+          ["#{key}[#{index}]", element]
+        end
+      elsif formatting == 'plain'
+        tuples += array.map { |element| [key, element] }
+      else
+        raise ArgumentError, 'Invalid format provided.'
+      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?
+
+      # Iterate and append parameters.
+      parameters.each do |key, value|
+        replace_value = ''
+
+        if value.nil?
+          replace_value = ''
+        elsif value.instance_of? Array
+          value.map! { |element| CGI.escape(element.to_s) }
+          replace_value = value.join('/')
+        else
+          replace_value = CGI.escape(value.to_s)
+        end
+
+        # Find the template parameter and replace it with its value.
+        query_builder = query_builder.gsub('{' + key.to_s + '}', 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.
+    # @param [String] The format of array parameter serialization.
+    def self.append_url_with_query_parameters(query_builder, parameters,
+                                              array_serialization: 'indexed')
+      # 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, value|
+        seperator = query_builder.include?('?') ? '&' : '?'
+        unless value.nil?
+          if value.instance_of? Array
+            value.compact!
+            query_builder += if array_serialization == 'csv'
+                               "#{seperator}#{key}=#{value.map do |element|
+                                 CGI.escape(element.to_s)
+                               end.join(',')}"
+                             elsif array_serialization == 'psv'
+                               "#{seperator}#{key}=#{value.map do |element|
+                                 CGI.escape(element.to_s)
+                               end.join('|')}"
+                             elsif array_serialization == 'tsv'
+                               "#{seperator}#{key}=#{value.map do |element|
+                                 CGI.escape(element.to_s)
+                               end.join("\t")}"
+                             else
+                               "#{seperator}#{APIHelper.serialize_array(
+                                 key, value, formatting: array_serialization
+                               ).map { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }
+                               .join('&')}"
+                             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)
+      return JSON.parse(json)
+    rescue StandardError
+      raise TypeError, 'Server responded with invalid 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)
+      encoded = {}
+      form_parameters.each do |key, value|
+        encoded.merge!(APIHelper.form_encode(value, key, formatting:
+          Configuration.array_serialization))
+      end
+      encoded
+    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 = {}
+
+      serializable_types = [String, Numeric, TrueClass,
+                            FalseClass, Date, DateTime]
+
+      # 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.to_s + ']'))
+          end
+        elsif 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)
+            # print retval
+          end
+        else
+          obj.each_with_index do |value, index|
+            retval.merge!(APIHelper.form_encode(value, instance_name + '[' +
+              index.to_s + ']', 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
+      else
+        retval[instance_name] = obj
+      end
+      retval
+    end
+
+    # Safely converts a string into an rfc3339 DateTime object
+    # @param [String] The datetime string
+    # @return [DateTime] A DateTime object of rfc3339 format
+    def self.rfc3339(date_time)
+      # missing timezone information
+      if date_time.end_with?('Z') || date_time.index('+')
+        DateTime.rfc3339(date_time)
+      else
+        DateTime.rfc3339(date_time + 'Z')
+      end
+    end
+  end
+end
+
+# Extend types to support to_bool.
+module ToBoolean
+  def to_bool
+    return true if self == true || to_s.strip =~ /^(true|yes|y|1)$/i
+    false
+  end
+end
+
+# Extend NilClass type to support to_bool.
+class NilClass; include ToBoolean; end
+# Extend TrueClass type to support to_bool.
+class TrueClass; include ToBoolean; end
+# Extend FalseClass type to support to_bool.
+class FalseClass; include ToBoolean; end
+# Extend Numeric type to support to_bool.
+class Numeric; include ToBoolean; end
+# Extend String type to support to_bool.
+class String; include ToBoolean; end

data/lib/calculator_task/calculator_task_client.rb

@@ -0,0 +1,21 @@
+# calculator_task
+#
+# This file was automatically generated by APIMATIC v2.0 (
+# https://apimatic.io ).
+
+module CalculatorTask
+  #  calculator_task client class.
+  class CalculatorTaskClient
+    # Singleton access to simple_calculator controller.
+    # @return [SimpleCalculatorController] Returns the controller instance.
+    def simple_calculator
+      SimpleCalculatorController.instance
+    end
+
+    # Returns the configuration class for easy access.
+    # @return [Configuration] Returns the actual configuration class.
+    def config
+      Configuration
+    end
+  end
+end

data/lib/calculator_task/configuration.rb

@@ -0,0 +1,20 @@
+# calculator_task
+#
+# This file was automatically generated by APIMATIC v2.0 (
+# https://apimatic.io ).
+
+# CohesityManagementSdk
+module CalculatorTask
+  # All configuration including auth info and base URI for the API access
+  # are configured in this class.
+  class Configuration
+    # The base Uri for API calls
+    @base_uri = 'http://examples.apimatic.io/apps/calculator'
+
+    # The attribute accessors for public properties.
+    class << self
+      attr_accessor :array_serialization
+      attr_accessor :base_uri
+    end
+  end
+end

data/lib/calculator_task/controllers/base_controller.rb

@@ -0,0 +1,51 @@
+# calculator_task
+#
+# This file was automatically generated by APIMATIC v2.0 (
+# https://apimatic.io ).
+
+module CalculatorTask
+  # Base controller.
+  class BaseController
+    attr_accessor :http_client, :http_call_back
+
+    def initialize(http_client: nil, http_call_back: nil)
+      @http_client = http_client || FaradayClient.new
+      @http_call_back = http_call_back
+
+      @global_headers = {
+        'user-agent' => 'APIMATIC 2.0'
+      }
+    end
+
+    def validate_parameters(args)
+      args.each do |_name, value|
+        if value.nil?
+          raise ArgumentError, "Required parameter #{_name} cannot be nil."
+        end
+      end
+    end
+
+    def execute_request(request, binary: false)
+      @http_call_back.on_before_request(request) if @http_call_back
+
+      APIHelper.clean_hash(request.headers)
+      request.headers = @global_headers.clone.merge(request.headers)
+
+      response = if binary
+                   @http_client.execute_as_binary(request)
+                 else
+                   @http_client.execute_as_string(request)
+                 end
+      context = HttpContext.new(request, response)
+
+      @http_call_back.on_after_response(context) if @http_call_back
+
+      context
+    end
+
+    def validate_response(context)
+      raise APIException.new 'HTTP Response Not OK', context unless
+        context.response.status_code.between?(200, 208) # [200,208] = HTTP OK
+    end
+  end
+end

data/lib/calculator_task/controllers/simple_calculator_controller.rb

@@ -0,0 +1,55 @@
+# calculator_task
+#
+# This file was automatically generated by APIMATIC v2.0 (
+# https://apimatic.io ).
+
+module CalculatorTask
+  # SimpleCalculatorController
+  class SimpleCalculatorController < BaseController
+    @instance = SimpleCalculatorController.new
+
+    class << self
+      attr_accessor :instance
+    end
+
+    def instance
+      self.class.instance
+    end
+
+    # Endpoint Calculate
+    # @param [OperationTypeEnum] operation Required parameter: the operation to
+    # apply
+    # @param [Float] x Required parameter: LHS
+    # @param [Float] y Required parameter: RHS
+    # @return Float response from the API call
+    def get_calculate(operation,
+                      x,
+                      y)
+      # Prepare query url.
+      _path_url = '/{operation}'
+      _path_url = APIHelper.append_url_with_template_parameters(
+        _path_url,
+        'operation' => operation
+      )
+      _query_builder = Configuration.base_uri.dup
+      _query_builder << _path_url
+      _query_builder = APIHelper.append_url_with_query_parameters(
+        _query_builder,
+        {
+          'x' => x,
+          'y' => y
+        },
+        array_serialization: Configuration.array_serialization
+      )
+      _query_url = APIHelper.clean_url _query_builder
+      # Prepare and execute HttpRequest.
+      _request = @http_client.get(
+        _query_url
+      )
+      _context = execute_request(_request)
+      validate_response(_context)
+      # Return appropriate response type.
+      _context.response.raw_body.to_f
+    end
+  end
+end

data/lib/calculator_task/exceptions/api_exception.rb

@@ -0,0 +1,20 @@
+# calculator_task
+#
+# This file was automatically generated by APIMATIC v2.0 (
+# https://apimatic.io ).
+
+module CalculatorTask
+  # Class for exceptions when there is a network error, status code error, etc.
+  class APIException < StandardError
+    attr_reader :context, :response_code
+
+    # The constructor.
+    # @param [String] The reason for raising an exception.
+    # @param [HttpContext] The HttpContext of the API call.
+    def initialize(reason, context)
+      super(reason)
+      @context = context
+      @response_code = context.response.status_code
+    end
+  end
+end

data/lib/calculator_task/http/faraday_client.rb

@@ -0,0 +1,64 @@
+# calculator_task
+#
+# This file was automatically generated by APIMATIC v2.0 (
+# https://apimatic.io ).
+
+require 'faraday/http_cache'
+require 'faraday_middleware'
+
+module CalculatorTask
+  # An implementation of HttpClient.
+  class FaradayClient < HttpClient
+    # The constructor.
+    def initialize(timeout: nil, cache: false,
+                   max_retries: nil, retry_interval: nil)
+      @connection = Faraday.new do |faraday|
+        faraday.use Faraday::HttpCache, serializer: Marshal if cache
+        faraday.use FaradayMiddleware::FollowRedirects
+        faraday.request :multipart
+        faraday.request :url_encoded
+        faraday.ssl[:ca_file] = Certifi.where
+        faraday.request :retry, max: max_retries, interval: if max_retries &&
+                                                               retry_interval
+                                                              retry_interval
+                                                            end
+        faraday.adapter Faraday.default_adapter
+        faraday.options[:params_encoder] = Faraday::FlatParamsEncoder
+        faraday.options[:open_timeout] = timeout if timeout
+      end
+    end
+
+    # Method overridden from HttpClient.
+    def execute_as_string(http_request)
+      response = @connection.send(
+        http_request.http_method.downcase,
+        http_request.query_url
+      ) do |request|
+        request.headers = http_request.headers
+        unless http_request.parameters.empty?
+          request.body = http_request.parameters
+        end
+      end
+      convert_response(response)
+    end
+
+    # Method overridden from HttpClient.
+    def execute_as_binary(http_request)
+      response = @connection.send(
+        http_request.http_method.downcase,
+        http_request.query_url
+      ) do |request|
+        request.headers = http_request.headers
+        unless http_request.parameters.empty?
+          request.body = http_request.parameters
+        end
+      end
+      convert_response(response)
+    end
+
+    # Method overridden from HttpClient.
+    def convert_response(response)
+      HttpResponse.new(response.status, response.headers, response.body)
+    end
+  end
+end

data/lib/calculator_task/http/http_call_back.rb

@@ -0,0 +1,24 @@
+# calculator_task
+#
+# This file was automatically generated by APIMATIC v2.0 (
+# https://apimatic.io ).
+
+module CalculatorTask
+  # HttpCallBack allows defining callables for pre and post API calls.
+  class HttpCallBack
+    # A controller will call this method before making an HTTP Request.
+    # @param [HttpRequest] The HttpRequest object which the HttpClient
+    # will execute.
+    def on_before_request(_http_request)
+      raise NotImplementedError, 'This method needs
+        to be implemented in a child class.'
+    end
+
+    # A controller will call this method after making an HTTP Request.
+    # @param [HttpContext] The HttpContext of the API call.
+    def on_after_response(_http_context)
+      raise NotImplementedError, 'This method needs
+        to be implemented in a child class.'
+    end
+  end
+end

data/lib/calculator_task/http/http_client.rb

@@ -0,0 +1,104 @@
+# calculator_task
+#
+# This file was automatically generated by APIMATIC v2.0 (
+# https://apimatic.io ).
+
+module CalculatorTask
+  # An interface for the methods that an HTTP Client must implement.
+  #
+  # This class should not be instantiated but should be used as a base class
+  # for HTTP Client classes.
+  class HttpClient
+    # Execute an HttpRequest when the response is expected to be a string.
+    # @param [HttpRequest] The HttpRequest to be executed.
+    def execute_as_string(_http_request)
+      raise NotImplementedError, 'This method needs
+        to be implemented in a child class.'
+    end
+
+    # Execute an HttpRequest when the response is expected to be binary.
+    # @param [HttpRequest] The HttpRequest to be executed.
+    def execute_as_binary(_http_request)
+      raise NotImplementedError, 'This method needs
+        to be implemented in a child class.'
+    end
+
+    # Converts the HTTP Response from the client to an HttpResponse object.
+    # @param [Dynamic] The response object received from the client.
+    def convert_response(_response)
+      raise NotImplementedError, 'This method needs
+        to be implemented in a child class.'
+    end
+
+    # Get a GET HttpRequest object.
+    # @param [String] The URL to send the request to.
+    # @param [Hash, Optional] The headers for the HTTP Request.
+    def get(query_url,
+            headers: {})
+      HttpRequest.new(HttpMethodEnum::GET,
+                      query_url,
+                      headers: headers)
+    end
+
+    # Get a HEAD HttpRequest object.
+    # @param [String] The URL to send the request to.
+    # @param [Hash, Optional] The headers for the HTTP Request.
+    def head(query_url,
+             headers: {})
+      HttpRequest.new(HttpMethodEnum::HEAD,
+                      query_url,
+                      headers: headers)
+    end
+
+    # Get a POST HttpRequest object.
+    # @param [String] The URL to send the request to.
+    # @param [Hash, Optional] The headers for the HTTP Request.
+    # @param [Hash, Optional] The parameters for the HTTP Request.
+    def post(query_url,
+             headers: {},
+             parameters: {})
+      HttpRequest.new(HttpMethodEnum::POST,
+                      query_url,
+                      headers: headers,
+                      parameters: parameters)
+    end
+
+    # Get a PUT HttpRequest object.
+    # @param [String] The URL to send the request to.
+    # @param [Hash, Optional] The headers for the HTTP Request.
+    # @param [Hash, Optional] The parameters for the HTTP Request.
+    def put(query_url,
+            headers: {},
+            parameters: {})
+      HttpRequest.new(HttpMethodEnum::PUT,
+                      query_url,
+                      headers: headers,
+                      parameters: parameters)
+    end
+
+    # Get a PATCH HttpRequest object.
+    # @param [String] The URL to send the request to.
+    # @param [Hash, Optional] The headers for the HTTP Request.
+    # @param [Hash, Optional] The parameters for the HTTP Request.
+    def patch(query_url,
+              headers: {},
+              parameters: {})
+      HttpRequest.new(HttpMethodEnum::PATCH,
+                      query_url,
+                      headers: headers,
+                      parameters: parameters)
+    end
+
+    # Get a DELETE HttpRequest object.
+    # @param [String] The URL to send the request to.
+    # @param [Hash, Optional] The headers for the HTTP Request.
+    def delete(query_url,
+               headers: {},
+               parameters: {})
+      HttpRequest.new(HttpMethodEnum::DELETE,
+                      query_url,
+                      headers: headers,
+                      parameters: parameters)
+    end
+  end
+end

data/lib/calculator_task/http/http_context.rb

@@ -0,0 +1,20 @@
+# calculator_task
+#
+# This file was automatically generated by APIMATIC v2.0 (
+# https://apimatic.io ).
+
+module CalculatorTask
+  # Represents an Http call in context.
+  class HttpContext
+    attr_accessor :request, :response
+
+    # The constructor.
+    # @param [HttpRequest] An HttpRequest object representing the HTTP request.
+    # @param [HttpResponse] An HttpResponse object representing the HTTP
+    # response.
+    def initialize(request, response)
+      @request = request
+      @response = response
+    end
+  end
+end

data/lib/calculator_task/http/http_method_enum.rb

@@ -0,0 +1,13 @@
+# calculator_task
+#
+# This file was automatically generated by APIMATIC v2.0 (
+# https://apimatic.io ).
+
+module CalculatorTask
+  # HTTP Methods Enumeration.
+  class HttpMethodEnum
+    HTTPMETHODENUM = [GET = 'GET'.freeze, POST = 'POST'.freeze,
+                      PUT = 'PUT'.freeze, PATCH = 'PATCH'.freeze,
+                      DELETE = 'DELETE'.freeze, HEAD = 'HEAD'.freeze].freeze
+  end
+end

data/lib/calculator_task/http/http_request.rb

@@ -0,0 +1,50 @@
+# calculator_task
+#
+# This file was automatically generated by APIMATIC v2.0 (
+# https://apimatic.io ).
+
+module CalculatorTask
+  # Represents a single Http Request.
+  class HttpRequest
+    attr_accessor :http_method, :query_url, :headers,
+                  :parameters, :username, :password
+
+    # The constructor.
+    # @param [HttpMethodEnum] The HTTP method.
+    # @param [String] The URL to send the request to.
+    # @param [Hash, Optional] The headers for the HTTP Request.
+    # @param [Hash, Optional] The parameters for the HTTP Request.
+    def initialize(http_method,
+                   query_url,
+                   headers: {},
+                   parameters: {})
+      @http_method = http_method
+      @query_url = query_url
+      @headers = headers
+      @parameters = parameters
+    end
+
+    # Add a header to the HttpRequest.
+    # @param [String] The name of the header.
+    # @param [String] The value of the header.
+    def add_header(name, value)
+      @headers[name] = value
+    end
+
+    # Add a parameter to the HttpRequest.
+    # @param [String] The name of the parameter.
+    # @param [String] The value of the parameter.
+    def add_parameter(name, value)
+      @parameters[name] = value
+    end
+
+    # Add a query parameter to the HttpRequest.
+    # @param [String] The name of the query parameter.
+    # @param [String] The value of the query parameter.
+    def add_query_parameter(name, value)
+      @query_url = APIHelper.append_url_with_query_parameters(@query_url,
+                                                              name => value)
+      @query_url = APIHelper.clean_url(@query_url)
+    end
+  end
+end

data/lib/calculator_task/http/http_response.rb

@@ -0,0 +1,23 @@
+# calculator_task
+#
+# This file was automatically generated by APIMATIC v2.0 (
+# https://apimatic.io ).
+
+module CalculatorTask
+  # Http response received.
+  class HttpResponse
+    attr_accessor :status_code, :headers, :raw_body
+
+    # The constructor
+    # @param [Integer] The status code returned by the server.
+    # @param [Hash] The headers sent by the server in the response.
+    # @param [String] The raw body of the response.
+    def initialize(status_code,
+                   headers,
+                   raw_body)
+      @status_code = status_code
+      @headers = headers
+      @raw_body = raw_body
+    end
+  end
+end

data/lib/calculator_task/models/base_model.rb

@@ -0,0 +1,36 @@
+# calculator_task
+#
+# This file was automatically generated by APIMATIC v2.0 (
+# https://apimatic.io ).
+
+module CalculatorTask
+  # Base model.
+  class BaseModel
+    # Returns a Hash representation of the current object.
+    def to_hash
+      hash = {}
+      instance_variables.each do |name|
+        value = instance_variable_get(name)
+        name = name[1..-1]
+        key = self.class.names.key?(name) ? self.class.names[name] : name
+        if value.instance_of? Array
+          hash[key] = value.map { |v| v.is_a?(BaseModel) ? v.to_hash : v }
+        elsif value.instance_of? Hash
+          hash[key] = {}
+          value.each do |k, v|
+            hash[key][k] = v.is_a?(BaseModel) ? v.to_hash : v
+          end
+        else
+          hash[key] = value.is_a?(BaseModel) ? value.to_hash : value
+        end
+      end
+      hash
+    end
+
+    # Returns a JSON representation of the curent object.
+    def to_json(options = {})
+      hash = to_hash
+      hash.to_json(options)
+    end
+  end
+end

data/lib/calculator_task/models/operation_type_enum.rb

@@ -0,0 +1,23 @@
+# calculator_task
+#
+# This file was automatically generated by APIMATIC v2.0 (
+# https://apimatic.io ).
+
+module CalculatorTask
+  # Calculator Operation
+  class OperationTypeEnum
+    OPERATION_TYPE_ENUM = [
+      # Addition
+      ADD = 'SUM'.freeze,
+
+      # Subtraction
+      SUBTRACT = 'SUBTRACT'.freeze,
+
+      # Multiplication
+      MULTIPLY = 'MULTIPLY'.freeze,
+
+      # Divide
+      DIVIDE = 'DIVIDE'.freeze
+    ].freeze
+  end
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: Calculator_Task
+version: !ruby/object:Gem::Version
+  version: '1.0'
+platform: ruby
+authors:
+- APIMatic SDK Generator
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-12-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.5
+- !ruby/object:Gem::Dependency
+  name: certifi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2016'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2016'
+- !ruby/object:Gem::Dependency
+  name: faraday-http-cache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.2
+description: Simple Calculator API.
+email: support@apimatic.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/calculator_task.rb
+- lib/calculator_task/api_helper.rb
+- lib/calculator_task/calculator_task_client.rb
+- lib/calculator_task/configuration.rb
+- lib/calculator_task/controllers/base_controller.rb
+- lib/calculator_task/controllers/simple_calculator_controller.rb
+- lib/calculator_task/exceptions/api_exception.rb
+- lib/calculator_task/http/faraday_client.rb
+- lib/calculator_task/http/http_call_back.rb
+- lib/calculator_task/http/http_client.rb
+- lib/calculator_task/http/http_context.rb
+- lib/calculator_task/http/http_method_enum.rb
+- lib/calculator_task/http/http_request.rb
+- lib/calculator_task/http/http_response.rb
+- lib/calculator_task/models/base_model.rb
+- lib/calculator_task/models/operation_type_enum.rb
+homepage: https://apimatic.io
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: calculator_task
+test_files: []