intercom 1.0.0 → 2.0.0

data/lib/intercom/message.rb

@@ -0,0 +1,9 @@
+require 'intercom/api_operations/save'
+require 'intercom/traits/api_resource'
+
+module Intercom
+  class Message
+    include ApiOperations::Save
+    include Traits::ApiResource
+  end
+end

data/lib/intercom/note.rb

@@ -1,45 +1,17 @@
-require 'intercom/user_resource'
+require 'intercom/api_operations/save'
+require 'intercom/api_operations/list'
+require 'intercom/api_operations/find_all'
+require 'intercom/api_operations/find'
+require 'intercom/api_operations/load'
+require 'intercom/traits/api_resource'
 
 module Intercom
-
-  ##
-  # Represents a note on a user
-  #
-  # A note contains a note (the text of the note you want to leave)
-  #
-  # == Examples
-  #
-  #  note = Intercom::Note.create(:email => "person@example.com", :body => "This is the note you want to make on the user account")
-
-  # You can also create a note and save it like this:
-  #  note = Intercom::Note.new
-  #  note.body = "This is the note you want to make on the user account"
-  #  note.save
-
-  class Note < UserResource
-    ##
-    # Creates a new Note using params and saves it
-    # @see #save
-    def self.create(params)
-      requires_parameters(params, %W(body))
-      Note.new(params).save
-    end
-
-    ##
-    # Records a note on a user of your application
-    def save
-      response = Intercom.post("/v1/users/notes", to_hash)
-      self.update_from_api_response(response)
-    end
-
-    ##
-    # Set the text of the note for the user
-    def body=(body)
-      @attributes["body"] = body
-    end
-
-    def user
-      User.from_api(@attributes['user'])
-    end
+  class Note
+    include ApiOperations::Save
+    include ApiOperations::List
+    include ApiOperations::FindAll
+    include ApiOperations::Find
+    include ApiOperations::Load
+    include Traits::ApiResource
   end
-end
+end

data/lib/intercom/request.rb

@@ -12,7 +12,6 @@ module Intercom
 
     def set_common_headers(method, base_uri)
       method.basic_auth(CGI.unescape(base_uri.user), CGI.unescape(base_uri.password))
-      method.add_field('Accept', 'application/json')
       method.add_field('AcceptEncoding', 'gzip, deflate')
     end
 
@@ -40,7 +39,7 @@ module Intercom
     end
 
     def self.default_headers
-      {'Accept-Encoding' => 'gzip, deflate', 'Accept' => 'application/json'}
+      {'Accept-Encoding' => 'gzip, deflate', 'Accept' => 'application/vnd.intercom.3+json'}
     end
 
     def client(uri)
@@ -60,9 +59,13 @@ module Intercom
       set_common_headers(net_http_method, base_uri)
       client(base_uri).start do |http|
         response = http.request(net_http_method)
-        raise_errors_on_failure(response)
         decoded = decode(response['content-encoding'], response.body)
-        JSON.parse(decoded) unless decoded.strip.empty?
+        unless decoded.strip.empty?
+          parsed_body = JSON.parse(decoded)
+          raise_application_errors_on_failure(parsed_body, response.code.to_i) if parsed_body['type'] == 'error.list'
+        end
+        raise_errors_on_failure(response)
+        parsed_body
       end
     rescue Timeout::Error
       raise Intercom::ServiceUnavailableError
@@ -87,6 +90,39 @@ module Intercom
       end
     end
 
+    def raise_application_errors_on_failure(error_list_details, http_code)
+      # Currently, we don't support multiple errors
+      error_details = error_list_details['errors'].first
+      error_code = error_details['type'] || error_details['code']
+      parsed_http_code = (http_code > 0 ? http_code : nil)
+      error_context = {
+        :http_code => parsed_http_code,
+        :application_error_code => error_code
+      }
+      case error_code
+      when 'unauthorized'
+        raise Intercom::AuthenticationError.new(error_details['message'], error_context)
+      when "bad_request", "missing_parameter", 'parameter_invalid'
+        raise Intercom::BadRequestError.new(error_details['message'], error_context)
+      when "not_found"
+        raise Intercom::ResourceNotFound.new(error_details['message'], error_context)
+      when "rate_limit_exceeded"
+        raise Intercom::RateLimitExceeded.new(error_details['message'], error_context)
+      when nil, ''
+        raise Intercom::UnexpectedError.new(message_for_unexpected_error_without_type(error_details, parsed_http_code), error_context)
+      else
+        raise Intercom::UnexpectedError.new(message_for_unexpected_error_with_type(error_details, parsed_http_code), error_context)
+      end
+    end
+
+    def message_for_unexpected_error_with_type(error_details, parsed_http_code)
+      "The error of type '#{error_details['type']}' is not recognized. It occurred with the message: #{error_details['message']} and http_code: '#{parsed_http_code}'. Please contact Intercom with these details."
+    end
+
+    def message_for_unexpected_error_without_type(error_details, parsed_http_code)
+      "An unexpected error occured. It occurred with the message: #{error_details['message']} and http_code: '#{parsed_http_code}'. Please contact Intercom with these details."
+    end
+
     def self.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('&')

data/lib/intercom/segment.rb

@@ -0,0 +1,14 @@
+require 'intercom/api_operations/count'
+require 'intercom/api_operations/find'
+require 'intercom/api_operations/save'
+require 'intercom/traits/api_resource'
+
+module Intercom
+  class Segment
+    include ApiOperations::List
+    include ApiOperations::Find
+    include ApiOperations::Save
+    include ApiOperations::Count
+    include Traits::ApiResource
+  end
+end

data/lib/intercom/tag.rb

@@ -1,82 +1,23 @@
-require 'intercom/requires_parameters'
-require 'intercom/hashable_object'
+require 'intercom/api_operations/count'
+require 'intercom/api_operations/save'
+require 'intercom/api_operations/list'
+require 'intercom/api_operations/find'
+require 'intercom/api_operations/find_all'
+require 'intercom/traits/api_resource'
+require 'intercom/traits/generic_handler_binding'
+require 'intercom/generic_handlers/tag'
+require 'intercom/generic_handlers/tag_find_all'
 
 module Intercom
-
-  ##
-  # Represents a tag
-  #
-  # A tag consists of a name, and (optionally) users that you would like to tag. Returns details about the tag and a count of the number of users currently tagged.
-  #
-  # == Examples
-  #
-  #  tag = Intercom::Tag.create(:name => "Super Tag", :user_ids => ['abc123', 'def456'])
-  #  tag = Intercom::Tag.create(:name => "Super Tag", :emails => ['bob@example.com', 'joe@example.com'])
-  #
-  #  You can also create a tag and save it like this:
-  #  tag = Intercom::Tag.new
-  #  tag.name = "Super Tag"
-  #  tag.user_ids = ['abc123', 'def456']
-  #  tag.tag_or_untag = "tag"
-  #  tag.save
-  #
-  #  Or update a tag and save it like this:
-  #  tag = Intercom::Tag.find_by_name "Super Tag"
-  #  tag.user_ids = ['abc123']
-  #  tag.tag_or_untag = "untag"
-  #  tag.save
-
   class Tag
-    extend RequiresParameters
-    include HashableObject
-
-    attr_accessor :name
-    attr_reader :segment, :tagged_user_count, :id
-    attr_writer :user_ids, :emails, :tag_or_untag
-
-    def initialize(attributes={})
-      from_hash(attributes)
-    end
-
-    ##
-    # Finds a Tag using params
-    def self.find(params)
-      response = Intercom.get("/v1/tags", params)
-      from_api(response)
-    end
-
-    def self.from_api(api_response)
-      tag = Tag.new
-      tag.from_hash(api_response)
-      tag.displayable_self
-    end
-
-    ##
-    # Finds a Tag using a name
-    def self.find_by_name(name)
-      find({:name => name})
-    end
-
-    ##
-    # Creates a new Tag using params and saves it
-    # @see #save
-    def self.create(params)
-      requires_parameters(params, %W(name))
-      Tag.new(params).save
-    end
-
-    ##
-    # Saves a Tag on your application
-    def save
-      response = Intercom.post("/v1/tags", to_wire)
-      self.from_hash(response)
-      displayable_self
-    end
-
-    ##
-    # Create a new clean instance to return (only showing the readable attributes)
-    def displayable_self
-      Tag.new(self.displayable_attributes)
-    end
+    include ApiOperations::Count
+    include ApiOperations::Save
+    include ApiOperations::List
+    include ApiOperations::Find
+    include ApiOperations::FindAll
+    include Traits::ApiResource
+    include Traits::GenericHandlerBinding
+    include GenericHandlers::Tag
+    include GenericHandlers::TagFindAll
   end
-end
+end

data/lib/intercom/traits/api_resource.rb

@@ -0,0 +1,120 @@
+require 'intercom/lib/flat_store'
+require 'intercom/lib/dynamic_accessors'
+require 'intercom/lib/dynamic_accessors_on_method_missing'
+require 'intercom/traits/dirty_tracking'
+require 'intercom/lib/typed_json_deserializer'
+
+module Intercom
+  module Traits
+
+    module ApiResource
+      include DirtyTracking
+
+      attr_accessor :id
+
+      def initialize(attributes = {})
+        from_hash(attributes)
+      end
+
+      def from_response(response)
+        from_hash(response)
+        reset_changed_fields!
+        self
+      end
+
+      def from_hash(hash)
+        hash.each do |attribute, value|
+          next if type_field?(attribute)
+          initialize_property(attribute, value)
+        end
+        initialize_missing_flat_store_attributes if respond_to? :flat_store_attributes
+        self
+      end
+
+      def to_hash
+        instance_variables_excluding_dirty_tracking_field.inject({}) do |hash, variable|
+          hash[variable.to_s.delete("@")] = instance_variable_get(variable)
+          hash
+        end
+      end
+
+      def to_submittable_hash
+        submittable_hash = {}
+        to_hash.each do |attribute, value|
+          submittable_hash[attribute] = value if submittable_attribute?(attribute, value)
+        end
+        submittable_hash
+      end
+
+      def method_missing(method_sym, *arguments, &block)
+        Lib::DynamicAccessorsOnMethodMissing.new(method_sym, *arguments, self).
+          define_accessors_or_call { super }
+      end
+
+      def flat_store_attribute?(attribute)
+        (respond_to?(:flat_store_attributes)) && (flat_store_attributes.map(&:to_s).include?(attribute.to_s))
+      end
+
+      private
+
+      def initialize_property(attribute, value)
+        Lib::DynamicAccessors.define_accessors(attribute, value, self) unless accessors_already_defined?(attribute)
+        set_property(attribute, value)
+      end
+
+      def accessors_already_defined?(attribute)
+        respond_to?(attribute) && respond_to?("#{attribute}=")
+      end
+
+      def set_property(attribute, value)
+        if typed_value?(value)
+          value_to_set = Intercom::Lib::TypedJsonDeserializer.new(value).deserialize
+        elsif flat_store_attribute?(attribute)
+          value_to_set = Intercom::Lib::FlatStore.new(value)
+        else
+          value_to_set = value
+        end
+        call_setter_for_attribute(attribute, value_to_set)
+      end
+
+      def typed_value?(value)
+        value.is_a? Hash and !!value['type']
+      end
+
+      def call_setter_for_attribute(attribute, value)
+        setter_method = "#{attribute.to_s}="
+        self.send(setter_method, value)
+      end
+
+      def type_field?(attribute)
+        attribute == 'type'
+      end
+
+      def initialize_missing_flat_store_attributes
+        flat_store_attributes.each do |attribute|
+          unless instance_variables_excluding_dirty_tracking_field.map(&:to_s).include? "@#{attribute}"
+            initialize_property(attribute, {})
+          end
+        end
+      end
+
+      def submittable_attribute?(attribute, value)
+        # FlatStores always submitted, even if not changed, as we don't track their dirtyness
+        value.is_a?(Intercom::Lib::FlatStore) || field_changed?(attribute)
+      end
+
+      module ClassMethods
+        def from_api(api_response)
+          object = self.new
+          object.from_response(api_response)
+          object
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+    end
+  end
+end

data/lib/intercom/traits/dirty_tracking.rb

@@ -0,0 +1,33 @@
+require 'set'
+
+module Intercom
+  module Traits
+    module DirtyTracking
+
+      def reset_changed_fields!
+        @changed_fields = Set.new
+      end
+
+      def mark_fields_as_changed!(field_names)
+        @changed_fields ||= Set.new
+        field_names.each do |attr|
+          @changed_fields.add(attr.to_s)
+        end
+      end
+
+      def mark_field_as_changed!(field_name)
+        @changed_fields ||= Set.new
+        @changed_fields.add(field_name.to_s)
+      end
+
+      def field_changed?(field_name)
+        @changed_fields ||= Set.new
+        @changed_fields.include?(field_name.to_s)
+      end
+
+      def instance_variables_excluding_dirty_tracking_field
+        instance_variables.reject{|var| var == :@changed_fields}
+      end
+    end
+  end
+end

data/lib/intercom/traits/generic_handler_binding.rb

@@ -0,0 +1,29 @@
+module Intercom
+  module Traits
+
+    # Allows us to have one class level method missing handler across all entities
+    # which can dispatch to the appropriate function based on the method name
+    module GenericHandlerBinding
+
+      module ClassMethods
+        def method_missing(method_sym, *arguments, &block)
+          if respond_to? :generic_tag and GenericHandlers::Tag.handles_method?(method_sym)
+            return generic_tag(method_sym, *arguments, block)
+          elsif respond_to? :generic_tag_find_all and GenericHandlers::TagFindAll.handles_method?(method_sym)
+            return generic_tag_find_all(method_sym, *arguments, block)
+          elsif respond_to? :generic_count and GenericHandlers::Count.handles_method?(method_sym)
+            return generic_count(method_sym, *arguments, block)
+          end
+          super
+        rescue Intercom::NoMethodMissingHandler
+          super
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+    end
+  end
+end