intercom 1.0.0 → 2.0.0

data/lib/intercom/extended_api_operations/reply.rb

@@ -0,0 +1,16 @@
+require 'intercom/traits/api_resource'
+
+module Intercom
+  module ExtendedApiOperations
+    module Reply
+
+      def reply(reply_data)
+        collection_name = Utils.resource_class_to_collection_name(self.class)
+        # TODO: For server, we should not need to merge in :conversation_id here (already in the URL)
+        response = Intercom.post("/#{collection_name}/#{id}/reply", reply_data.merge(:conversation_id => id))
+        from_response(response)
+      end
+
+    end
+  end
+end

data/lib/intercom/extended_api_operations/tags.rb

@@ -0,0 +1,14 @@
+require 'intercom/traits/api_resource'
+
+module Intercom
+  module ExtendedApiOperations
+    module Tags
+
+      def tags
+        collection_name = Utils.resource_class_to_collection_name(self.class)
+        self.id ? Intercom::Tag.send("find_all_for_#{collection_name}", :id => id) : []
+      end
+
+    end
+  end
+end

data/lib/intercom/extended_api_operations/users.rb

@@ -0,0 +1,17 @@
+require 'intercom/traits/api_resource'
+
+module Intercom
+  module ExtendedApiOperations
+    module Users
+
+      def users
+        collection_name = Utils.resource_class_to_collection_name(self.class)
+        finder_details = {}
+        finder_details[:url] = "/#{collection_name}/#{id}/users"
+        finder_details[:params] = {}
+        CollectionProxy.new("users", finder_details)
+      end
+
+    end
+  end
+end

data/lib/intercom/generic_handlers/base_handler.rb

@@ -0,0 +1,22 @@
+module Intercom
+  module GenericHandlers
+    class BaseHandler
+      attr_reader :method_sym, :arguments, :entity
+
+      def initialize(method_sym, arguments, entity)
+        @method_sym = method_sym
+        @arguments = arguments
+        @entity = entity
+      end
+
+      def method_string
+        method_sym.to_s
+      end
+
+      def raise_no_method_missing_handler
+        raise Intercom::NoMethodMissingHandler, "Could not handle '#{method_string}'"
+      end
+    end
+
+  end
+end

data/lib/intercom/generic_handlers/count.rb

@@ -0,0 +1,59 @@
+require 'intercom/generic_handlers/base_handler'
+
+module Intercom
+  module GenericHandlers
+    module Count
+      module ClassMethods
+        def generic_count(method_sym, *arguments, &block)
+
+          handler_class = Class.new(GenericHandlers::BaseHandler) do
+            def handle
+              match = method_string.match(GenericHandlers::Count.count_breakdown_matcher)
+              if match && match[1] && match[2] && match[3].nil?
+                do_broken_down_count(match[1], match[2])
+              elsif method_string.end_with? '_count'
+                return do_count
+              else
+                raise_no_method_missing_handler
+              end
+            end
+
+            private
+
+            def do_count
+              entity.fetch_for_app.send(appwide_entity_to_count)['count']
+            rescue Intercom::AttributeNotSetError => ex
+              # Indicates this this kind of counting is not supported
+              raise_no_method_missing_handler
+            end
+
+            def do_broken_down_count(entity_to_count, count_context)
+              result = entity.fetch_broken_down_count(entity_to_count, count_context)
+              result.send(entity_to_count)[count_context]
+            rescue Intercom::BadRequestError => ex
+              # Indicates this this kind of counting is not supported
+              ex.application_error_code == 'parameter_invalid' ? raise_no_method_missing_handler : raise
+            end
+
+            def appwide_entity_to_count; method_string.gsub(/_count$/, ''); end
+          end
+
+          handler_class.new(method_sym, arguments, self).handle
+        end
+
+      end
+
+      def self.count_breakdown_matcher
+        /([[:alnum:]]+)_counts_for_each_([[:alnum:]]+)/
+      end
+
+      def self.handles_method?(method_sym)
+        method_sym.to_s.end_with? '_count' or method_sym.to_s.match(count_breakdown_matcher)
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/intercom/generic_handlers/tag.rb

@@ -0,0 +1,71 @@
+require 'intercom/generic_handlers/base_handler'
+
+module Intercom
+  module GenericHandlers
+    module Tag
+      module ClassMethods
+        def generic_tag(method_sym, *arguments, &block)
+
+          handler_class = Class.new(GenericHandlers::BaseHandler) do
+            def handle
+              if method_string.start_with? 'tag_'
+                return do_tagging
+              elsif method_string.start_with? 'untag_'
+                return do_untagging
+              else
+                raise_no_method_missing_handler
+              end
+            end
+
+            private
+
+            def do_tagging
+              entity.create(:name => arguments[0], tagging_context.to_sym => tag_object_list(arguments))
+            end
+
+            def do_untagging
+              current_tag = find_tag(arguments[0])
+              return untag_via_save(current_tag) if current_tag
+            end
+
+            def find_tag(name_arg)
+              Intercom::Tag.find(:name => name_arg)
+            rescue Intercom::ResourceNotFound
+              return nil # Ignore if tag has since been deleted
+            end
+
+            def untag_via_save(current_tag)
+              current_tag.name = arguments[0]
+              current_tag.send("#{untagging_context}=", untag_object_list(arguments))
+              current_tag.save
+            end
+            
+            def tag_object_list(args)
+              to_tag_object_list = args[1].map { |id| { :id => id } }
+            end
+            
+            def untag_object_list(args)
+              to_tag = tag_object_list(args)
+              to_tag.map { |tag_object| tag_object[:untag] = true }
+              to_tag
+            end
+
+            def tagging_context; method_string.gsub(/^tag_/, ''); end
+            def untagging_context; method_string.gsub(/^untag_/, ''); end
+          end
+
+          handler_class.new(method_sym, arguments, self).handle
+        end
+
+      end
+
+      def self.handles_method?(method_sym)
+        method_sym.to_s.start_with?('tag_') || method_sym.to_s.start_with?('untag_')
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/intercom/generic_handlers/tag_find_all.rb

@@ -0,0 +1,47 @@
+require 'intercom/generic_handlers/base_handler'
+
+module Intercom
+  module GenericHandlers
+    module TagFindAll
+      module ClassMethods
+        def generic_tag_find_all(method_sym, *arguments, &block)
+
+          handler_class = Class.new(GenericHandlers::BaseHandler) do
+            def handle
+              if method_string.start_with? 'find_all_for_'
+                return do_tag_find_all
+              else
+                raise_no_method_missing_handler
+              end
+            end
+
+            private
+
+            def do_tag_find_all
+              Intercom::Tag.find_all(cleaned_arguments.merge(:taggable_type => Utils.singularize(context)))
+            end
+
+            def cleaned_arguments
+              cleaned_args = arguments[0]
+              cleaned_args[:taggable_id] = cleaned_args.delete(:id) if cleaned_args.has_key?(:id)
+              cleaned_args
+            end
+
+            def context; method_string.gsub(/^find_all_for_/, ''); end
+          end
+
+          handler_class.new(method_sym, arguments, self).handle
+        end
+
+      end
+
+      def self.handles_method?(method_sym)
+        method_sym.to_s.start_with? 'find_all_for_'
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/intercom/lib/dynamic_accessors.rb

@@ -0,0 +1,59 @@
+module Intercom
+  module Lib
+    module DynamicAccessors
+
+      class << self
+
+        def define_accessors(attribute, value, object)
+          klass = object.class
+          if attribute.to_s.end_with? '_at'
+            define_date_based_accessors(attribute, value, klass)
+          elsif object.flat_store_attribute?(attribute)
+            define_flat_store_based_accessors(attribute, value, klass)
+          else
+            define_standard_accessors(attribute, value, klass)
+          end
+        end
+
+        private
+
+        def define_flat_store_based_accessors(attribute, value, klass)
+          klass.class_eval %Q"
+            def #{attribute}=(value)
+              mark_field_as_changed!(:#{attribute})
+              @#{attribute} = Intercom::Lib::FlatStore.new(value)
+            end
+            def #{attribute}
+              @#{attribute}
+            end
+          "
+        end
+
+        def define_date_based_accessors(attribute, value, klass)
+          klass.class_eval %Q"
+            def #{attribute}=(value)
+              mark_field_as_changed!(:#{attribute})
+              @#{attribute} = value.nil? ? nil : value.to_i
+            end
+            def #{attribute}
+              @#{attribute}.nil? ? nil : Time.at(@#{attribute})
+            end
+          "
+        end
+
+        def define_standard_accessors(attribute, value, klass)
+            klass.class_eval %Q"
+              def #{attribute}=(value)
+                mark_field_as_changed!(:#{attribute})
+                @#{attribute} = value
+              end
+              def #{attribute}
+                @#{attribute}
+              end
+            "
+        end
+
+      end
+    end
+  end
+end

data/lib/intercom/lib/dynamic_accessors_on_method_missing.rb

@@ -0,0 +1,53 @@
+module Intercom
+  module Lib
+    class DynamicAccessorsOnMethodMissing
+
+      attr_reader :method_sym, :method_string, :arguments, :object, :klass
+
+      def initialize(method_sym, *arguments, object)
+        @method_sym = method_sym
+        @method_string = method_sym.to_s
+        @arguments = arguments
+        @klass = object.class
+        @object = object
+      end
+
+      def define_accessors_or_call(&block)
+        return yield if not_an_accessor?
+        if setter?
+          Lib::DynamicAccessors.define_accessors(attribute_name, *arguments, object)
+          object.send(method_sym, *arguments)
+        else # getter
+          if trying_to_access_private_variable?
+            yield
+          else
+            raise Intercom::AttributeNotSetError, attribute_not_set_error_message
+          end
+        end
+      end
+
+      private
+
+      def not_an_accessor?
+        (method_string.end_with? '?') || (method_string.end_with? '!') || arguments.length > 1
+      end
+
+      def setter?
+        method_string.end_with? '='
+      end
+
+      def attribute_name
+        method_string.gsub(/=$/, '')
+      end
+
+      def trying_to_access_private_variable?
+        object.instance_variable_defined?("@#{method_string}")
+      end
+
+      def attribute_not_set_error_message
+        "'#{method_string}' called on #{klass} but it has not been set an " +
+        "attribute or does not exist as a method"
+      end
+    end
+  end
+end

data/lib/intercom/lib/flat_store.rb

@@ -0,0 +1,31 @@
+module Intercom
+  module Lib
+
+    # Sub-class of {Hash} for storing custom data attributes.
+    # Doesn't allow nested Hashes or Arrays. And requires {String} or {Symbol} keys.
+    class FlatStore < Hash
+
+      def initialize(attributes={})
+        (attributes).each do |key, value|
+          validate_key_and_value(key, value)
+          self[key] = value
+        end
+      end
+
+      def []=(key, value)
+        validate_key_and_value(key, value)
+        super(key.to_s, value)
+      end
+
+      def [](key)
+        super(key.to_s)
+      end
+
+      private
+      def validate_key_and_value(key, value)
+        raise ArgumentError.new("This does not support nested data structures (key: #{key}, value: #{value}") if value.is_a?(Array) || value.is_a?(Hash)
+        raise ArgumentError.new("Key must be String or Symbol: #{key}") unless key.is_a?(String) || key.is_a?(Symbol)
+      end
+    end
+  end
+end

data/lib/intercom/lib/typed_json_deserializer.rb

@@ -0,0 +1,52 @@
+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
+
+        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
+
+        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 deserialize_collection(collection_json)
+          collection_json.map { |item_json| TypedJsonDeserializer.new(item_json).deserialize }
+        end
+
+        def deserialize_object(object_json)
+          entity_class = Utils.constantize_singular_resource_name(object_entity_key)
+          entity_class.from_api(object_json)
+        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