smartystreets_ruby_sdk 2.0.2 → 3.0.0

data/lib/smartystreets_ruby_sdk/exceptions.rb

@@ -4,25 +4,32 @@ end
 class BadCredentialsError < SmartyException
 end
 
-class PaymentRequiredError < SmartyException
+class ForbiddenError < SmartyException
 end
 
+class PaymentRequiredError < SmartyException
+end
 
 class RequestEntityTooLargeError < SmartyException
 end
 
-
 class BadRequestError < SmartyException
 end
 
+class UnprocessableEntityError < SmartyException
+end
 
 class TooManyRequestsError < SmartyException
 end
 
-
 class InternalServerError < SmartyException
 end
 
-
 class ServiceUnavailableError < SmartyException
-end
+end
+
+class GatewayTimeoutError < SmartyException
+end
+
+class BatchFullError < SmartyException
+end

data/lib/smartystreets_ruby_sdk/international_street.rb

@@ -0,0 +1,10 @@
+require_relative './international_street/lookup'
+require_relative './international_street/metadata'
+require_relative './international_street/analysis'
+require_relative './international_street/components'
+require_relative './international_street/candidate'
+require_relative './international_street/client'
+require_relative './international_street/language_mode'
+
+module InternationalStreet
+end

data/lib/smartystreets_ruby_sdk/international_street/analysis.rb

@@ -0,0 +1,13 @@
+module InternationalStreet
+  # See "https://smartystreets.com/docs/cloud/international-street-api#analysis"
+  class Analysis
+
+    attr_reader :max_address_precision, :verification_status, :address_precision
+
+    def initialize(obj)
+      @verification_status = obj.fetch('verification_status', nil)
+      @address_precision = obj.fetch('address_precision', nil)
+      @max_address_precision = obj.fetch('max_address_precision', nil)
+    end
+  end
+end

data/lib/smartystreets_ruby_sdk/international_street/candidate.rb

@@ -0,0 +1,33 @@
+require_relative 'components'
+require_relative 'metadata'
+require_relative 'analysis'
+
+module InternationalStreet
+  # A candidate is a possible match for an address that was submitted. A lookup can have multiple
+  # candidates if the address was ambiguous.
+  #
+  # See "https://smartystreets.com/docs/cloud/international-street-api#root"
+  class Candidate
+    attr_reader :metadata, :address3, :address11, :address2, :address12, :address1, :address10,
+                :address9, :address8, :address7, :organization, :address6, :address5, :address4, :components, :analysis
+
+    def initialize(obj)
+      @organization = obj.fetch('organization', nil)
+      @address1 = obj.fetch('address1', nil)
+      @address2 = obj.fetch('address2', nil)
+      @address3 = obj.fetch('address3', nil)
+      @address4 = obj.fetch('address4', nil)
+      @address5 = obj.fetch('address5', nil)
+      @address6 = obj.fetch('address6', nil)
+      @address7 = obj.fetch('address7', nil)
+      @address8 = obj.fetch('address8', nil)
+      @address9 = obj.fetch('address9', nil)
+      @address10 = obj.fetch('address10', nil)
+      @address11 = obj.fetch('address11', nil)
+      @address12 = obj.fetch('address12', nil)
+      @components = Components.new(obj.fetch('components', {}))
+      @metadata = Metadata.new(obj.fetch('metadata', {}))
+      @analysis = Analysis.new(obj.fetch('analysis', {}))
+    end
+  end
+end

data/lib/smartystreets_ruby_sdk/international_street/client.rb

@@ -0,0 +1,56 @@
+require_relative '../request'
+require_relative 'candidate'
+
+module InternationalStreet
+  # It is recommended to instantiate this class using ClientBuilder.build_international_street_api_client()
+  class Client
+    def initialize(sender, serializer)
+      @sender = sender
+      @serializer = serializer
+    end
+
+    # Sends a Lookup object to the International Street API and stores the result in the Lookup's result field.
+    def send(lookup)
+      lookup.ensure_enough_info
+      request = build_request(lookup)
+
+      response = @sender.send(request)
+
+      candidates = convert_candidates(@serializer.deserialize(response.payload))
+      lookup.result = candidates
+    end
+
+    def build_request(lookup)
+      request = Request.new
+
+      add_parameter(request, 'country', lookup.country)
+      add_parameter(request, 'geocode', lookup.geocode.to_s)
+      add_parameter(request, 'language', lookup.language)
+      add_parameter(request, 'freeform', lookup.freeform)
+      add_parameter(request, 'address1', lookup.address1)
+      add_parameter(request, 'address2', lookup.address2)
+      add_parameter(request, 'address3', lookup.address3)
+      add_parameter(request, 'address4', lookup.address4)
+      add_parameter(request, 'organization', lookup.organization)
+      add_parameter(request, 'locality', lookup.locality)
+      add_parameter(request, 'administrative_area', lookup.administrative_area)
+      add_parameter(request, 'postal_code', lookup.postal_code)
+
+      request
+    end
+
+    def add_parameter(request, key, value)
+      request.parameters[key] = value unless value.nil? or value.empty?
+    end
+
+    def convert_candidates(raw_candidates)
+      candidates = []
+
+      raw_candidates.each do |candidate|
+        candidates.push(Candidate.new(candidate))
+      end
+
+      candidates
+    end
+  end
+end

data/lib/smartystreets_ruby_sdk/international_street/components.rb

@@ -0,0 +1,55 @@
+module InternationalStreet
+  # See "https://smartystreets.com/docs/cloud/international-street-api#components"
+  class Components
+    attr_reader :premise, :thoroughfare_trailing_type, :sub_building, :locality, :post_box_number,
+                :thoroughfare_name, :thoroughfare_postdirection, :dependent_thoroughfare,
+                :thoroughfare, :dependent_thoroughfare_name, :postal_code_short, :dependent_thoroughfare_trailing_type,
+                :administrative_area, :post_box, :building_leading_type, :dependent_locality_name, :thoroughfare_type,
+                :dependent_thoroughfare_postdirection, :double_dependent_locality, :premise_number,
+                :dependent_thoroughfare_type, :post_box_type, :building, :sub_administrative_area, :postal_code_extra,
+                :sub_building_name, :postal_code, :dependent_locality, :premise_type, :sub_building_number,
+                :super_administrative_area, :premise_extra, :dependent_thoroughfare_predirection,
+                :building_trailing_type, :thoroughfare_predirection, :building_name, :country_iso_3, :sub_building_type
+
+    def initialize(obj)
+      @country_iso_3 = obj.fetch('country_iso_3', nil)
+      @super_administrative_area = obj.fetch('super_administrative_area', nil)
+      @administrative_area = obj.fetch('administrative_area', nil)
+      @sub_administrative_area = obj.fetch('sub_administrative_area', nil)
+      @dependent_locality= obj.fetch('dependent_locality', nil)
+      @dependent_locality_name = obj.fetch('dependent_locality_name', nil)
+      @double_dependent_locality = obj.fetch('double_dependent_locality', nil)
+      @locality = obj.fetch('locality', nil)
+      @postal_code = obj.fetch('postal_code', nil)
+      @postal_code_short = obj.fetch('postal_code_short', nil)
+      @postal_code_extra = obj.fetch('postal_code_extra', nil)
+      @premise = obj.fetch('premise', nil)
+      @premise_extra = obj.fetch('premise_extra', nil)
+      @premise_number = obj.fetch('premise_number', nil)
+      @premise_type = obj.fetch('premise_type', nil)
+      @thoroughfare = obj.fetch('thoroughfare', nil)
+      @thoroughfare_predirection = obj.fetch('thoroughfare_predirection', nil)
+      @thoroughfare_postdirection = obj.fetch('thoroughfare_postdirection', nil)
+      @thoroughfare_name = obj.fetch('thoroughfare_name', nil)
+      @thoroughfare_trailing_type = obj.fetch('thoroughfare_trailing_type', nil)
+      @thoroughfare_type = obj.fetch('thoroughfare_type', nil)
+      @dependent_thoroughfare = obj.fetch('dependent_thoroughfare', nil)
+      @dependent_thoroughfare_predirection = obj.fetch('dependent_thoroughfare_predirection', nil)
+      @dependent_thoroughfare_postdirection = obj.fetch('dependent_thoroughfare_postdirection', nil)
+      @dependent_thoroughfare_name = obj.fetch('dependent_thoroughfare_name', nil)
+      @dependent_thoroughfare_trailing_type = obj.fetch('dependent_thoroughfare_trailing_type', nil)
+      @dependent_thoroughfare_type = obj.fetch('dependent_thoroughfare_type', nil)
+      @building = obj.fetch('building', nil)
+      @building_leading_type = obj.fetch('building_leading_type', nil)
+      @building_name = obj.fetch('building_name', nil)
+      @building_trailing_type = obj.fetch('building_trailing_type', nil)
+      @sub_building_type = obj.fetch('sub_building_type', nil)
+      @sub_building_number = obj.fetch('sub_building_number', nil)
+      @sub_building_name = obj.fetch('sub_building_name', nil)
+      @sub_building = obj.fetch('sub_building', nil)
+      @post_box = obj.fetch('post_box', nil)
+      @post_box_type = obj.fetch('post_box_type', nil)
+      @post_box_number = obj.fetch('post_box_number', nil)
+    end
+  end
+end

data/lib/smartystreets_ruby_sdk/international_street/language_mode.rb

@@ -0,0 +1,5 @@
+module LanguageMode
+  NATIVE = 'native'.freeze
+
+  LATIN = 'latin'.freeze
+end

data/lib/smartystreets_ruby_sdk/international_street/lookup.rb

@@ -0,0 +1,80 @@
+module InternationalStreet
+  # In addition to holding all of the input data for this lookup, this class also will contain the
+  # result of the lookup after it comes back from the API.
+  #
+  # Note: Lookups must have certain required fields set with non-blank values.
+  # These can be found at the URL below.
+  #
+  # See "https://smartystreets.com/docs/cloud/international-street-api#http-input-fields"
+  #
+  # @geocode:: Disabled by default. Set to true to enable.
+  # @language:: When not set, the output language will match the language of the input values.
+  #     When set to language_mode.NATIVE, the results will always be in the language of the output country.
+  #     When set to language_mode.LATIN, the results will always be provided using a Latin character set.
+  class Lookup
+
+    attr_accessor :freeform, :locality, :postal_code, :address3, :address2, :inputId, :address1,
+                  :geocode, :administrative_area, :country, :organization, :language, :address4, :result
+
+    def initialize(freeform=nil, country=nil)
+      @result = []
+
+      @inputId = nil
+      @country = country
+      @geocode = nil
+      @language = nil
+      @freeform = freeform
+      @address1 = nil
+      @address2 = nil
+      @address3 = nil
+      @address4 = nil
+      @organization = nil
+      @locality = nil
+      @administrative_area = nil
+      @postal_code = nil
+    end
+
+    def missing_country
+      field_is_missing(@country)
+    end
+
+    def has_freeform
+      field_is_set(@freeform)
+    end
+
+    def missing_address1
+      field_is_missing(@address1)
+    end
+
+    def has_postal_code
+      field_is_set(@postal_code)
+    end
+
+    def missing_locality_or_administrative_area
+      field_is_missing(@locality) or field_is_missing(@administrative_area)
+    end
+
+    def field_is_missing(field)
+      field.nil? or field.empty?
+    end
+
+    def field_is_set(field)
+      not field_is_missing(field)
+    end
+
+    def ensure_enough_info
+      raise UnprocessableEntityError, 'Country field is required.' if missing_country
+
+      return true if has_freeform
+
+      raise UnprocessableEntityError, 'Either freeform or address1 is required.' if missing_address1
+
+      return true if has_postal_code
+
+      if missing_locality_or_administrative_area
+        raise UnprocessableEntityError, 'Insufficient information:'\
+              'One or more required fields were not set on the lookup.'
+      end
+    end
+  end
+end

data/lib/smartystreets_ruby_sdk/international_street/metadata.rb

@@ -0,0 +1,14 @@
+module InternationalStreet
+  # See "https://smartystreets.com/docs/cloud/international-street-api#metadata"
+  class Metadata
+
+    attr_reader :longitude, :geocode_precision, :max_geocode_precision, :latitude
+
+    def initialize(obj)
+      @latitude = obj.fetch('latitude', nil)
+      @longitude = obj.fetch('longitude', nil)
+      @geocode_precision = obj.fetch('geocode_precision', nil)
+      @max_geocode_precision = obj.fetch('max_geocode_precision', nil)
+    end
+  end
+end

data/lib/smartystreets_ruby_sdk/json_able.rb

@@ -3,15 +3,15 @@ require 'json'
 class JSONAble
   def to_json(options={})
     hash = {}
-    self.instance_variables.each do |var|
-      hash[var.to_s.delete('@')] = self.instance_variable_get var
+    instance_variables.each do |var|
+      hash[var.to_s.delete('@')] = instance_variable_get var
     end
     hash.to_json
   end
 
   def from_json!(string)
     JSON.load(string).each do |var, val|
-      self.instance_variable_set var, val
+      instance_variable_set var, val
     end
   end
 end

data/lib/smartystreets_ruby_sdk/native_sender.rb

@@ -29,11 +29,15 @@ class NativeSender
 
   def self.build_request(smarty_request)
     query = create_query(smarty_request)
-    request = Net::HTTP::Post.new(URI.parse("#{smarty_request.url_prefix}?#{query}"))
+    if smarty_request.payload.nil?
+      request = Net::HTTP::Get.new(URI.parse("#{smarty_request.url_prefix}?#{query}"))
+    else
+      request = Net::HTTP::Post.new(URI.parse("#{smarty_request.url_prefix}?#{query}"))
+    end
     request.content_type = 'application/json'
     request.body = smarty_request.payload
     request['User-Agent'] = "smartystreets (sdk:ruby@#{SmartystreetsRubySdk::VERSION})"
-    request['Referer'] = smarty_request.referer if smarty_request.referer != nil
+    request['Referer'] = smarty_request.referer unless smarty_request.referer.nil?
     set_custom_headers(smarty_request.headers, request)
     request
   end

data/lib/smartystreets_ruby_sdk/request.rb

@@ -1,5 +1,5 @@
 class Request
-  attr_accessor :parameters, :payload, :url_prefix, :referer, :headers
+  attr_accessor :parameters, :payload, :url_prefix, :referer, :headers, :content_type
 
   def initialize
     @parameters = {}
@@ -7,5 +7,6 @@ class Request
     @url_prefix = nil
     @referer = nil
     @headers = {}
+    @content_type = 'application/json'
   end
 end

data/lib/smartystreets_ruby_sdk/retry_sender.rb

@@ -1,6 +1,6 @@
 class RetrySender
   MAX_BACKOFF_DURATION = 10
-  STATUS_OK = '200'
+  STATUS_OK = '200'.freeze
 
   def initialize(max_retries, inner, sleeper, logger)
     @max_retries = max_retries
@@ -12,17 +12,15 @@ class RetrySender
   def send(request)
     response = @inner.send(request)
 
-    (0..@max_retries-1).each { |i|
-      if response.status_code == STATUS_OK
-        break
-      end
+    (0..@max_retries-1).each do |i|
+      break if response.status_code == STATUS_OK
 
       backoff(i)
 
       response = @inner.send(request)
-    }
+    end
 
-  response
+    response
   end
 
   def backoff(attempt)

data/lib/smartystreets_ruby_sdk/us_autocomplete.rb

@@ -0,0 +1,7 @@
+require_relative './us_autocomplete/lookup'
+require_relative './us_autocomplete/geolocation_type'
+require_relative './us_autocomplete/suggestion'
+require_relative './us_autocomplete/client'
+
+module USAutocomplete
+end

data/lib/smartystreets_ruby_sdk/us_autocomplete/client.rb

@@ -0,0 +1,66 @@
+require_relative '../request'
+require_relative '../exceptions'
+require_relative 'geolocation_type'
+require_relative 'suggestion'
+
+module USAutocomplete
+  # It is recommended to instantiate this class using ClientBuilder.build_us_autocomplete_api_client
+  class Client
+    def initialize(sender, serializer)
+      @sender = sender
+      @serializer = serializer
+    end
+
+    # Sends a Lookup object to the US Autocomplete API and stores the result in the Lookup's result field.
+    def send(lookup)
+      if not lookup or not lookup.prefix
+        raise SmartyException, 'Send() must be passed a Lookup with the prefix field set.'
+      end
+
+      request = build_request(lookup)
+
+      response = @sender.send(request)
+
+      result = @serializer.deserialize(response.payload)
+      suggestions = convert_suggestions(result.fetch('suggestions', []))
+      lookup.result = suggestions
+    end
+
+
+    def build_request(lookup)
+      request = Request.new
+
+      add_parameter(request, 'prefix', lookup.prefix)
+      add_parameter(request, 'suggestions', lookup.max_suggestions.to_s)
+      add_parameter(request, 'city_filter', build_filter_string(lookup.city_filter))
+      add_parameter(request, 'state_filter', build_filter_string(lookup.state_filter))
+      add_parameter(request, 'prefer', build_filter_string(lookup.prefer))
+      if lookup.geolocate_type != GeolocationType::NONE
+        request.parameters['geolocate'] = 'true'
+        request.parameters['geolocate_precision'] = lookup.geolocate_type
+      else
+        request.parameters['geolocate'] = 'false'
+      end
+
+      request
+    end
+
+    def build_filter_string(filter_list)
+      filter_list ? filter_list.join(',') : nil
+    end
+
+    def convert_suggestions(suggestion_hashes)
+      converted_suggestions = []
+
+      suggestion_hashes.each do |suggestion|
+        converted_suggestions.push(USAutocomplete::Suggestion.new(suggestion))
+      end
+
+      converted_suggestions
+    end
+
+    def add_parameter(request, key, value)
+      request.parameters[key] = value unless value.nil? or value.empty?
+    end
+  end
+end