uniqueCalculator 1.1 → 1.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e21e2185d72b885f673e8e2340330872d0ec494cce5ff41ff2027069e1c8884
-  data.tar.gz: a07a74c04b81f2d4162b204435ba4ca575c24624a80a65ddd7ef5a39b1ea6d37
+  metadata.gz: 86aad3f45868b73711243987949b9b43ba27c7bab0036f4c6c4b38f67c1fcb2c
+  data.tar.gz: 857989d73acb6f7dba24d18f8e509b8af53dab01dfc87e40d06acfbd777a8660
 SHA512:
-  metadata.gz: 9fe40e7ccf84ab2890c0ff2f04a137f78a83f5e9a1ace2003b80967f8f063ac4c3b4a767c89961f728edb9db1886fbd3e3f4192cb46d67cd4059fc4e2446b831
-  data.tar.gz: c679b38798da807dbb8dd782707b617e25da82506c56996a4efcc2b2f613483c9a1d6e5825b96b1063a1442eeaf9b37fede7c002025c6da6d498960637a1ab1d
+  metadata.gz: a299700e3332a54d8481c030a413d2f602d25d0331df05e786d3ca78eb7eaf0268e2a661c03cf66fd8faf0468fb8ecca9e3b262b241a493eaf1db59e173745ad
+  data.tar.gz: 878c7c45cf6170115ad5adb36672186ec65277f3c9cb87dae6cf71359ec5572844c75783f78874b26b22e4a9322b7eb2bc951f585dc6043b6ea325654516e820

data/README.md

@@ -10,16 +10,16 @@ Simple calculator API hosted on APIMATIC
 Install the gem from the command line:
 
 ```ruby
-gem install uniqueCalculator -v 1.1
+gem install uniqueCalculator -v 1.2.7
 ```
 
 Or add the gem to your Gemfile and run `bundle`:
 
 ```ruby
-gem 'uniqueCalculator', '1.1'
+gem 'uniqueCalculator', '1.2.7'
 ```
 
-For additional gem details, see the [RubyGems page for the uniqueCalculator gem](https://rubygems.org/gems/uniqueCalculator/versions/1.1).
+For additional gem details, see the [RubyGems page for the uniqueCalculator gem](https://rubygems.org/gems/uniqueCalculator/versions/1.2.7).
 
 ## Test the SDK
 
@@ -46,6 +46,7 @@ The following parameters are configurable for the API Client:
 | `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]** |
+| `http_callback` | `HttpCallBack` | The Http CallBack allows defining callables for pre and post API calls. |
 
 The API client can be initialized as follows:
 

data/lib/apimatic_calculator/api_helper.rb

@@ -5,445 +5,6 @@
 
 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
+  class APIHelper < CoreLibrary::ApiHelper
   end
 end

data/lib/apimatic_calculator/client.rb

@@ -11,13 +11,13 @@ module ApimaticCalculator
     # Access to simple_calculator controller.
     # @return [SimpleCalculatorController] Returns the controller instance.
     def simple_calculator
-      @simple_calculator ||= SimpleCalculatorController.new config
+      @simple_calculator ||= SimpleCalculatorController.new @global_configuration
     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],
+                   retry_methods: %i[get put], http_callback: nil,
                    environment: Environment::PRODUCTION, config: nil)
       @config = if config.nil?
                   Configuration.new(connection: connection, adapter: adapter,
@@ -26,10 +26,17 @@ module ApimaticCalculator
                                     backoff_factor: backoff_factor,
                                     retry_statuses: retry_statuses,
                                     retry_methods: retry_methods,
+                                    http_callback: http_callback,
                                     environment: environment)
                 else
                   config
                 end
+
+      @global_configuration = GlobalConfiguration.new(client_configuration: @config)
+                                                 .base_uri_executor(@config.method(:get_base_uri))
+                                                 .global_errors(BaseController::GLOBAL_ERRORS)
+                                                 .user_agent(BaseController.user_agent)
+                                                 .sdk_module(ApimaticCalculator)
     end
   end
 end

data/lib/apimatic_calculator/configuration.rb

@@ -21,10 +21,9 @@ module ApimaticCalculator
 
   # All configuration including auth info and base URI for the API access
   # are configured in this class.
-  class Configuration
+  class Configuration < CoreLibrary::HttpClientConfiguration
     # The attribute readers for properties.
-    attr_reader :http_client, :connection, :adapter, :timeout, :max_retries, :retry_interval,
-                :backoff_factor, :retry_statuses, :retry_methods, :environment
+    attr_reader :environment
 
     class << self
       attr_reader :environments
@@ -33,43 +32,25 @@ module ApimaticCalculator
     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],
+                   retry_methods: %i[get put], http_callback: nil,
                    environment: Environment::PRODUCTION)
-      # The Faraday connection object passed by the SDK user for making requests
-      @connection = connection
 
-      # The Faraday adapter object passed by the SDK user for performing http requests
-      @adapter = adapter
-
-      # The value to use for connection timeout
-      @timeout = timeout
-
-      # The number of times to retry an endpoint call if it fails
-      @max_retries = max_retries
-
-      # Pause in seconds between retries
-      @retry_interval = retry_interval
-
-      # The amount to multiply each successive retry's interval amount
-      # by in order to provide backoff
-      @backoff_factor = backoff_factor
-
-      # A list of HTTP statuses to retry
-      @retry_statuses = retry_statuses
-
-      # A list of HTTP methods to retry
-      @retry_methods = retry_methods
+      super 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, http_callback: http_callback
 
       # Current API environment
       @environment = String(environment)
 
       # The Http Client to use for making requests.
-      @http_client = create_http_client
+      set_http_client CoreLibrary::FaradayClient.new(self)
     end
 
     def clone_with(connection: nil, adapter: nil, timeout: nil,
                    max_retries: nil, retry_interval: nil, backoff_factor: nil,
-                   retry_statuses: nil, retry_methods: nil, environment: nil)
+                   retry_statuses: nil, retry_methods: nil, http_callback: nil,
+                   environment: nil)
       connection ||= self.connection
       adapter ||= self.adapter
       timeout ||= self.timeout
@@ -78,6 +59,7 @@ module ApimaticCalculator
       backoff_factor ||= self.backoff_factor
       retry_statuses ||= self.retry_statuses
       retry_methods ||= self.retry_methods
+      http_callback ||= self.http_callback
       environment ||= self.environment
 
       Configuration.new(connection: connection, adapter: adapter,
@@ -85,16 +67,8 @@ module ApimaticCalculator
                         retry_interval: retry_interval,
                         backoff_factor: backoff_factor,
                         retry_statuses: retry_statuses,
-                        retry_methods: retry_methods, environment: environment)
-    end
-
-    def create_http_client
-      FaradayClient.new(timeout: timeout, max_retries: max_retries,
-                        retry_interval: retry_interval,
-                        backoff_factor: backoff_factor,
-                        retry_statuses: retry_statuses,
-                        retry_methods: retry_methods, connection: connection,
-                        adapter: adapter)
+                        retry_methods: retry_methods,
+                        http_callback: http_callback, environment: environment)
     end
 
     # All the environments the SDK can run in.
@@ -105,7 +79,7 @@ module ApimaticCalculator
     }.freeze
 
     # Generates the appropriate base URI for the environment and the server.
-    # @param [Configuration::Server] The server enum for which the base URI is
+    # @param [Configuration::Server] server The server enum for which the base URI is
     # required.
     # @return [String] The base URI.
     def get_base_uri(server = Server::CALCULATOR)