intercom 3.9.5 → 4.1.3

data/lib/intercom/contact.rb

@@ -1,11 +1,30 @@
+# frozen_string_literal: true
+
+require 'intercom/traits/incrementable_attributes'
 require 'intercom/traits/api_resource'
+require 'intercom/api_operations/nested_resource'
 
 module Intercom
   class Contact
+    include Traits::IncrementableAttributes
     include Traits::ApiResource
+    include ApiOperations::NestedResource
+
+    nested_resource_methods :tag, operations: %i[add delete list]
+    nested_resource_methods :note, operations: %i[create list]
+    nested_resource_methods :company, operations: %i[add delete list]
+    nested_resource_methods :segment, operations: %i[list]
+
+    def self.collection_proxy_class
+      Intercom::BaseCollectionProxy
+    end
+
+    def identity_vars
+      [:id]
+    end
 
-    def identity_vars ; [:email, :user_id] ; end
-    def flat_store_attributes ; [:custom_attributes] ; end
-    def update_verb; 'put' ; end
+    def flat_store_attributes
+      [:custom_attributes]
+    end
   end
 end

data/lib/intercom/conversation.rb

@@ -1,7 +1,12 @@
 require 'intercom/traits/api_resource'
+require 'intercom/api_operations/nested_resource'
 
 module Intercom
   class Conversation
     include Traits::ApiResource
+    include ApiOperations::NestedResource
+
+    nested_resource_methods :tag, operations: %i[add delete]
+    nested_resource_methods :contact, operations: %i[add delete], path: :customers
   end
 end

data/lib/intercom/data_attribute.rb

@@ -0,0 +1,7 @@
+require 'intercom/traits/api_resource'
+
+module Intercom
+  class DataAttribute
+    include Traits::ApiResource
+  end
+end

data/lib/intercom/deprecated_leads_collection_proxy.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Intercom
+  class DeprecatedLeadsCollectionProxy < ClientCollectionProxy
+    def fetch(next_page)
+      response_hash = if next_page
+                        @client.get(next_page, {})
+                      else
+                        @client.get(@url, @params)
+                      end
+      transform(response_hash)
+    end
+
+    def transform(response_hash)
+      response_hash['type'] = 'lead.list'
+      leads_list = response_hash.delete('contacts')
+      leads_list.each { |lead| lead['type'] = 'lead' }
+      response_hash['leads'] = leads_list
+      response_hash
+    end
+  end
+end

data/lib/intercom/deprecated_resources.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Intercom
+  module DeprecatedResources
+    def deprecated__leads
+      Intercom::Service::Lead.new(self)
+    end
+
+    def deprecated__users
+      Intercom::Service::User.new(self)
+    end
+  end
+end

data/lib/intercom/errors.rb

@@ -96,6 +96,9 @@ module Intercom
   # Raised when a CDA is invalid
   class InvalidDocumentError < IntercomError; end
 
+  # Raised when a merge is invalid
+  class InvalidMergeError < IntercomError; end
+
   #
   # Non-public errors (internal to the gem)
   #

data/lib/intercom/extended_api_operations/segments.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'intercom/client_collection_proxy'
 require 'intercom/utils'
 
@@ -6,7 +8,7 @@ module Intercom
     module Segments
       def by_segment(id)
         collection_name = Utils.resource_class_to_collection_name(collection_class)
-        ClientCollectionProxy.new(collection_name, finder_details: {url: "/#{collection_name}?segment_id=#{id}"}, client: @client)
+        ClientCollectionProxy.new(collection_name, collection_class, details: { url: "/#{collection_name}?segment_id=#{id}" }, client: @client)
       end
     end
   end

data/lib/intercom/extended_api_operations/tags.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'intercom/client_collection_proxy'
 require 'intercom/utils'
 
@@ -6,7 +8,7 @@ module Intercom
     module Tags
       def by_tag(id)
         collection_name = Utils.resource_class_to_collection_name(collection_class)
-        ClientCollectionProxy.new(collection_name, finder_details: {url: "/#{collection_name}?tag_id=#{id}"}, client: @client)
+        ClientCollectionProxy.new(collection_name, collection_class, details: { url: "/#{collection_name}?tag_id=#{id}" }, client: @client)
       end
     end
   end

data/lib/intercom/lead.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'intercom/traits/api_resource'
+
+module Intercom
+  class Lead
+    include Traits::ApiResource
+
+    def identity_vars
+      %i[email user_id]
+    end
+
+    def flat_store_attributes
+      [:custom_attributes]
+    end
+
+    def update_verb
+      'put'
+    end
+  end
+end

data/lib/intercom/lib/dynamic_accessors.rb

@@ -5,20 +5,19 @@ module Intercom
       class << self
 
         def define_accessors(attribute, value, object)
-          klass = object.class
           if attribute.to_s.end_with?('_at') && attribute.to_s != 'update_last_request_at'
-            define_date_based_accessors(attribute, value, klass)
+            define_date_based_accessors(attribute, value, object)
           elsif object.flat_store_attribute?(attribute)
-            define_flat_store_based_accessors(attribute, value, klass)
+            define_flat_store_based_accessors(attribute, value, object)
           else
-            define_standard_accessors(attribute, value, klass)
+            define_standard_accessors(attribute, value, object)
           end
         end
 
         private
 
-        def define_flat_store_based_accessors(attribute, value, klass)
-          klass.class_eval %Q"
+        def define_flat_store_based_accessors(attribute, value, object)
+          object.instance_eval %Q"
             def #{attribute}=(value)
               mark_field_as_changed!(:#{attribute})
               @#{attribute} = Intercom::Lib::FlatStore.new(value)
@@ -29,8 +28,8 @@ module Intercom
           "
         end
 
-        def define_date_based_accessors(attribute, value, klass)
-          klass.class_eval %Q"
+        def define_date_based_accessors(attribute, value, object)
+          object.instance_eval %Q"
             def #{attribute}=(value)
               mark_field_as_changed!(:#{attribute})
               @#{attribute} = value.nil? ? nil : value.to_i
@@ -41,8 +40,8 @@ module Intercom
           "
         end
 
-        def define_standard_accessors(attribute, value, klass)
-            klass.class_eval %Q"
+        def define_standard_accessors(attribute, value, object)
+            object.instance_eval %Q"
               def #{attribute}=(value)
                 mark_field_as_changed!(:#{attribute})
                 @#{attribute} = value

data/lib/intercom/lib/typed_json_deserializer.rb

@@ -1,54 +1,59 @@
+# frozen_string_literal: true
+
 require 'intercom/utils'
 
 module Intercom
   module Lib
-      # Responsibility: To decide whether we are deserializing a collection or an
-      # entity of a particular type and to dispatch deserialization
-      class TypedJsonDeserializer
-        attr_reader :json
-
-        def initialize(json)
-          @json = json
-        end
+    # Responsibility: To decide whether we are deserializing a collection or an
+    # entity of a particular type and to dispatch deserialization
+    class TypedJsonDeserializer
+      attr_reader :json
+
+      def initialize(json, client)
+        @json = json
+        @client = client
+      end
 
-        def deserialize
-          if blank_object_type?(object_type)
-            raise DeserializationError, "No type field was found to facilitate deserialization"
-          elsif list_object_type?(object_type)
-            deserialize_collection(json[object_entity_key])
-          else # singular object type
-            deserialize_object(json)
-          end
+      def deserialize
+        if blank_object_type?(object_type)
+          raise DeserializationError, 'No type field was found to facilitate deserialization'
+        elsif list_object_type?(object_type)
+          deserialize_collection(json[object_entity_key])
+        else # singular object type
+          deserialize_object(json)
         end
+      end
 
-        private
+      private
 
-        def blank_object_type?(object_type)
-          object_type.nil? || object_type == ''
-        end
+      def blank_object_type?(object_type)
+        object_type.nil? || object_type == ''
+      end
 
-        def list_object_type?(object_type)
-          object_type.end_with?('.list')
-        end
+      def list_object_type?(object_type)
+        object_type.end_with?('.list')
+      end
 
-        def deserialize_collection(collection_json)
-          return [] if collection_json == nil
-          collection_json.map { |item_json| TypedJsonDeserializer.new(item_json).deserialize }
-        end
+      def deserialize_collection(collection_json)
+        return [] if collection_json.nil?
 
-        def deserialize_object(object_json)
-          entity_class = Utils.constantize_singular_resource_name(object_entity_key)
-          entity_class.from_api(object_json)
-        end
+        collection_json.map { |item_json| TypedJsonDeserializer.new(item_json, @client).deserialize }
+      end
 
-        def object_type
-          @object_type ||= json['type']
-        end
+      def deserialize_object(object_json)
+        entity_class = Utils.constantize_singular_resource_name(object_entity_key)
+        deserialized = entity_class.from_api(object_json)
+        deserialized.client = @client
+        deserialized
+      end
 
-        def object_entity_key
-          @object_entity_key ||= Utils.entity_key_from_type(object_type)
-        end
+      def object_type
+        @object_type ||= json['type']
+      end
 
+      def object_entity_key
+        @object_entity_key ||= Utils.entity_key_from_type(object_type)
       end
+    end
   end
 end

data/lib/intercom/note.rb

@@ -4,5 +4,9 @@ require 'intercom/traits/api_resource'
 module Intercom
   class Note
     include Traits::ApiResource
+
+    def self.collection_proxy_class
+      Intercom::BaseCollectionProxy
+    end
   end
 end

data/lib/intercom/request.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cgi'
 require 'net/https'
 
@@ -23,17 +25,18 @@ module Intercom
       private def method_with_body(http_method, path, params)
         request = http_method.send(:new, path, default_headers)
         request.body = params.to_json
-        request["Content-Type"] = "application/json"
+        request['Content-Type'] = 'application/json'
         request
       end
 
       private def default_headers
-        {'Accept-Encoding' => 'gzip, deflate', 'Accept' => 'application/vnd.intercom.3+json', 'User-Agent' => "Intercom-Ruby/#{Intercom::VERSION}"}
+        { 'Accept-Encoding' => 'gzip, deflate', 'Accept' => 'application/vnd.intercom.3+json', 'User-Agent' => "Intercom-Ruby/#{Intercom::VERSION}" }
       end
 
       private def append_query_string_to_url(url, params)
         return url if params.empty?
-        query_string = params.map { |k, v| "#{k.to_s}=#{CGI::escape(v.to_s)}" }.join('&')
+
+        query_string = params.map { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }.join('&')
         url + "?#{query_string}"
       end
     end
@@ -46,11 +49,11 @@ module Intercom
 
     attr_accessor :handle_rate_limit
 
-    def execute(target_base_url=nil, username:, secret: nil, read_timeout: 90, open_timeout: 30, api_version: nil)
+    def execute(target_base_url = nil, token:, read_timeout: 90, open_timeout: 30, api_version: nil)
       retries = 3
       base_uri = URI.parse(target_base_url)
       set_common_headers(net_http_method, base_uri)
-      set_basic_auth(net_http_method, username, secret)
+      set_auth_header(net_http_method, token)
       set_api_version(net_http_method, api_version) if api_version
       begin
         client(base_uri, read_timeout: read_timeout, open_timeout: open_timeout).start do |http|
@@ -71,7 +74,7 @@ module Intercom
             if @handle_rate_limit
               seconds_to_retry = (@rate_limit_details[:reset_at] - Time.now.utc).ceil
               if (retries -= 1) < 0
-                raise Intercom::RateLimitExceeded.new('Rate limit retries exceeded. Please examine current API Usage.')
+                raise Intercom::RateLimitExceeded, 'Rate limit retries exceeded. Please examine current API Usage.'
               else
                 sleep seconds_to_retry unless seconds_to_retry < 0
                 retry
@@ -80,11 +83,11 @@ module Intercom
               raise e
             end
           rescue Timeout::Error
-            raise Intercom::ServiceUnavailableError.new('Service Unavailable [request timed out]')
+            raise Intercom::ServiceUnavailableError, 'Service Unavailable [request timed out]'
           end
         end
       rescue Timeout::Error
-        raise Intercom::ServiceConnectionError.new('Failed to connect to service [connection attempt timed out]')
+        raise Intercom::ServiceConnectionError, 'Failed to connect to service [connection attempt timed out]'
       end
     end
 
@@ -114,8 +117,9 @@ module Intercom
     end
 
     private def decode(content_encoding, body)
-      return body if (!body) || body.empty? || content_encoding != 'gzip'
-      Zlib::GzipReader.new(StringIO.new(body)).read.force_encoding("utf-8")
+      return body if !body || body.empty? || content_encoding != 'gzip'
+
+      Zlib::GzipReader.new(StringIO.new(body)).read.force_encoding('utf-8')
     end
 
     private def json_parse_response(str, code)
@@ -123,7 +127,7 @@ module Intercom
 
       JSON.parse(str)
     rescue JSON::ParserError
-      msg = <<~MSG.gsub(/[[:space:]]+/, " ").strip # #squish from ActiveSuppor
+      msg = <<~MSG.gsub(/[[:space:]]+/, ' ').strip # #squish from ActiveSuppor
         Expected a JSON response body. Instead got '#{str}'
         with status code '#{code}'.
       MSG
@@ -139,12 +143,12 @@ module Intercom
       @rate_limit_details = rate_limit_details
     end
 
-    private def set_common_headers(method, base_uri)
+    private def set_common_headers(method, _base_uri)
       method.add_field('AcceptEncoding', 'gzip, deflate')
     end
 
-    private def set_basic_auth(method, username, secret)
-      method.basic_auth(CGI.unescape(username), CGI.unescape(secret))
+    private def set_auth_header(method, token)
+      method.add_field('Authorization', "Bearer #{token}")
     end
 
     private def set_api_version(method, api_version)
@@ -155,21 +159,21 @@ module Intercom
       code = res.code.to_i
 
       if code == 404
-        raise Intercom::ResourceNotFound.new('Resource Not Found')
+        raise Intercom::ResourceNotFound, 'Resource Not Found'
       elsif code == 401
-        raise Intercom::AuthenticationError.new('Unauthorized')
+        raise Intercom::AuthenticationError, 'Unauthorized'
       elsif code == 403
-        raise Intercom::AuthenticationError.new('Forbidden')
+        raise Intercom::AuthenticationError, 'Forbidden'
       elsif code == 429
-        raise Intercom::RateLimitExceeded.new('Rate Limit Exceeded')
+        raise Intercom::RateLimitExceeded, 'Rate Limit Exceeded'
       elsif code == 500
-        raise Intercom::ServerError.new('Server Error')
+        raise Intercom::ServerError, 'Server Error'
       elsif code == 502
-        raise Intercom::BadGatewayError.new('Bad Gateway Error')
+        raise Intercom::BadGatewayError, 'Bad Gateway Error'
       elsif code == 503
-        raise Intercom::ServiceUnavailableError.new('Service Unavailable')
+        raise Intercom::ServiceUnavailableError, 'Service Unavailable'
       elsif code == 504
-        raise Intercom::GatewayTimeoutError.new('Gateway Timeout')
+        raise Intercom::GatewayTimeoutError, 'Gateway Timeout'
       end
     end
 
@@ -180,10 +184,10 @@ module Intercom
       error_field = error_details['field']
       parsed_http_code = (http_code > 0 ? http_code : nil)
       error_context = {
-        :http_code => parsed_http_code,
-        :application_error_code => error_code,
-        :field => error_field,
-        :request_id => error_list_details['request_id']
+        http_code: parsed_http_code,
+        application_error_code: error_code,
+        field: error_field,
+        request_id: error_list_details['request_id']
       }
       case error_code
       when 'unauthorized', 'forbidden', 'token_not_found'
@@ -194,19 +198,19 @@ module Intercom
         raise Intercom::TokenRevokedError.new(error_details['message'], error_context)
       when 'token_unauthorized'
         raise Intercom::TokenUnauthorizedError.new(error_details['message'], error_context)
-      when "bad_request", "missing_parameter", 'parameter_invalid', 'parameter_not_found'
+      when 'bad_request', 'missing_parameter', 'parameter_invalid', 'parameter_not_found'
         raise Intercom::BadRequestError.new(error_details['message'], error_context)
-      when "not_restorable"
+      when 'not_restorable'
         raise Intercom::BlockedUserError.new(error_details['message'], error_context)
-      when "not_found", "company_not_found"
+      when 'not_found', 'company_not_found'
         raise Intercom::ResourceNotFound.new(error_details['message'], error_context)
-      when "admin_not_found"
+      when 'admin_not_found'
         raise Intercom::AdminNotFound.new(error_details['message'], error_context)
-      when "rate_limit_exceeded"
+      when 'rate_limit_exceeded'
         raise Intercom::RateLimitExceeded.new(error_details['message'], error_context)
-      when "custom_data_limit_reached"
+      when 'custom_data_limit_reached'
         raise Intercom::CDALimitReachedError.new(error_details['message'], error_context)
-      when "invalid_document"
+      when 'invalid_document'
         raise Intercom::InvalidDocumentError.new(error_details['message'], error_context)
       when 'service_unavailable'
         raise Intercom::ServiceUnavailableError.new(error_details['message'], error_context)

data/lib/intercom/scroll_collection_proxy.rb

@@ -1,32 +1,34 @@
-require "intercom/utils"
+# frozen_string_literal: true
 
-module Intercom
-  class ScrollCollectionProxy
+require 'intercom/utils'
+require 'intercom/base_collection_proxy'
 
-    attr_reader :resource_name, :scroll_url, :resource_class, :scroll_param, :records
+module Intercom
+  class ScrollCollectionProxy < BaseCollectionProxy
+    attr_reader :scroll_url, :scroll_param, :records
 
-    def initialize(resource_name, finder_details: {}, client:)
+    def initialize(resource_name, resource_class, details: {}, client:)
       @resource_name = resource_name
-      @resource_class = Utils.constantize_resource_name(resource_name)
-      @scroll_url = (finder_details[:url] || "/#{@resource_name}") + '/scroll'
+      @resource_class = resource_class
+      @scroll_url = (details[:url] || "/#{@resource_name}") + '/scroll'
       @client = client
-
     end
 
-    def next(scroll_parameter=nil)
+    def next(scroll_parameter = nil)
       @records = []
-      if not scroll_parameter
-        #First time so do initial get without scroll_param
-        response_hash = @client.get(@scroll_url, '')
-      else
-        #Not first call so use get next page
-        response_hash = @client.get(@scroll_url, scroll_param: scroll_parameter)
-      end
-      raise Intercom::HttpError.new('Http Error - No response entity returned') unless response_hash
+      response_hash = if !scroll_parameter
+                        # First time so do initial get without scroll_param
+                        @client.get(@scroll_url, '')
+                      else
+                        # Not first call so use get next page
+                        @client.get(@scroll_url, scroll_param: scroll_parameter)
+                      end
+      raise Intercom::HttpError, 'Http Error - No response entity returned' unless response_hash
+
       @scroll_param = extract_scroll_param(response_hash)
-      top_level_entity_key = deserialize_response_hash(response_hash)
+      top_level_entity_key = entity_key_from_response(response_hash)
       response_hash[top_level_entity_key] = response_hash[top_level_entity_key].map do |object_json|
-        Lib::TypedJsonDeserializer.new(object_json).deserialize
+        Lib::TypedJsonDeserializer.new(object_json, @client).deserialize
       end
       @records = response_hash[@resource_name]
       self
@@ -35,47 +37,41 @@ module Intercom
     def each(&block)
       scroll_param = nil
       loop do
-        if not scroll_param
-          response_hash = @client.get(@scroll_url, '')
-        else
-          response_hash = @client.get(@scroll_url, scroll_param: scroll_param)
-        end
-        raise Intercom::HttpError.new('Http Error - No response entity returned') unless response_hash
-        response_hash[deserialize_response_hash(response_hash)].each do |object_json|
-          block.call Lib::TypedJsonDeserializer.new(object_json).deserialize
+        response_hash = if !scroll_param
+                          @client.get(@scroll_url, '')
+                        else
+                          @client.get(@scroll_url, scroll_param: scroll_param)
+                        end
+        raise Intercom::HttpError, 'Http Error - No response entity returned' unless response_hash
+
+        top_level_entity_key = entity_key_from_response(response_hash)
+        response_hash[top_level_entity_key].each do |object_json|
+          block.call Lib::TypedJsonDeserializer.new(object_json, @client).deserialize
         end
         scroll_param = extract_scroll_param(response_hash)
-        break if not records_present?(response_hash)
+        break unless records_present?(response_hash)
       end
       self
     end
 
-    def [](target_index)
-      self.each_with_index do |item, index|
-        return item if index == target_index
-      end
-      nil
-    end
-
-    include Enumerable
-
     private
 
-    def deserialize_response_hash(response_hash)
-      top_level_type = response_hash.delete('type')
+    def entity_key_from_response(response_hash)
+      top_level_type = response_hash['type']
       if resource_name == 'subscriptions'
-        top_level_entity_key = 'items'
+        'items'
       else
-        top_level_entity_key = Utils.entity_key_from_type(top_level_type)
+        Utils.entity_key_from_type(top_level_type)
       end
     end
 
     def records_present?(response_hash)
-      (response_hash[@resource_name].length > 0)
+      !response_hash[entity_key_from_response(response_hash)].empty?
     end
 
     def extract_scroll_param(response_hash)
       return nil unless records_present?(response_hash)
+
       response_hash['scroll_param']
     end
   end