intercom 2.5.4 → 3.0.0b1

data/lib/intercom/api_operations/count.rb

@@ -1,16 +0,0 @@
-module Intercom
-  module ApiOperations
-    module Count
-      module ClassMethods
-        def count
-          singular_resource_name = Utils.resource_class_to_singular_name(self)
-          Intercom::Count.send("#{singular_resource_name}_count")
-        end
-      end
-
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-    end
-  end
-end

data/lib/intercom/count.rb

@@ -1,21 +0,0 @@
-require 'intercom/traits/api_resource'
-require 'intercom/api_operations/find'
-require 'intercom/traits/generic_handler_binding'
-require 'intercom/generic_handlers/count'
-
-module Intercom
-  class Count
-    include ApiOperations::Find
-    include Traits::ApiResource
-    include Traits::GenericHandlerBinding
-    include GenericHandlers::Count
-
-    def self.fetch_for_app
-      Intercom::Count.find({})
-    end
-
-    def self.fetch_broken_down_count(entity_to_count, count_context)
-      Intercom::Count.find(:type => entity_to_count, :count => count_context)
-    end
-  end
-end

data/lib/intercom/extended_api_operations/reply.rb

@@ -1,16 +0,0 @@
-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/generic_handlers/base_handler.rb

@@ -1,22 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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
-              # 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

@@ -1,71 +0,0 @@
-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)
-              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

@@ -1,47 +0,0 @@
-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/notification.rb

@@ -1,20 +0,0 @@
-require 'intercom/traits/api_resource'
-
-module Intercom
-  class Notification
-    include Traits::ApiResource
-
-    def model
-      data.item
-    end
-
-    def model_type
-      model.class
-    end
-
-    def load
-      model.load
-    end
-
-  end
-end

data/lib/intercom/traits/generic_handler_binding.rb

@@ -1,29 +0,0 @@
-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

data/spec/unit/intercom/collection_proxy_spec.rb

@@ -1,34 +0,0 @@
-require "spec_helper"
-
-describe Intercom::CollectionProxy do
-
-  it "stops iterating if no next link" do
-    Intercom.expects(:get).with("/users", {}).returns(page_of_users(false))
-    emails = []
-    Intercom::User.all.each { |user| emails << user.email }
-    emails.must_equal %W(user1@example.com user2@example.com user3@example.com)
-  end
-
-  it "keeps iterating if next link" do
-    Intercom.expects(:get).with("/users", {}).returns(page_of_users(true))
-    Intercom.expects(:get).with('https://api.intercom.io/users?per_page=50&page=2', {}).returns(page_of_users(false))
-    emails = []
-    Intercom::User.all.each { |user| emails << user.email }
-  end
-
-  it "supports indexed array access" do
-    Intercom.expects(:get).with("/users", {}).returns(page_of_users(false))
-    Intercom::User.all[0].email.must_equal 'user1@example.com'
-  end
-
-  it "supports map" do
-    Intercom.expects(:get).with("/users", {}).returns(page_of_users(false))
-    emails = Intercom::User.all.map { |user| user.email }
-    emails.must_equal %W(user1@example.com user2@example.com user3@example.com)
-  end
-
-  it "supports querying" do
-    Intercom.expects(:get).with("/users", {:tag_name => 'Taggart J'}).returns(page_of_users(false))
-    Intercom::User.find_all(:tag_name => 'Taggart J').map(&:email).must_equal %W(user1@example.com user2@example.com user3@example.com)
-  end
-end

data/spec/unit/intercom/notification_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-
-describe "Intercom::Notification" do
-
-  it "converts notification hash to object" do
-    payload = Intercom::Notification.new(test_user_notification)
-    payload.must_be_instance_of Intercom::Notification
-  end
-
-  it "returns correct model type for User" do
-    payload = Intercom::Notification.new(test_user_notification)
-    payload.model_type.must_equal Intercom::User
-  end
-
-  it "returns correct User notification topic" do
-    payload = Intercom::Notification.new(test_user_notification)
-    payload.topic.must_equal "user.created"
-  end
-
-  it "returns instance of User" do
-    payload = Intercom::Notification.new(test_user_notification)
-    payload.model.must_be_instance_of Intercom::User
-  end
-
-  it "returns instance of Conversation" do
-    payload = Intercom::Notification.new(test_conversation_notification)
-    payload.model.must_be_instance_of Intercom::Conversation
-  end
-
-  it "returns correct model type for Conversation" do
-    payload = Intercom::Notification.new(test_conversation_notification)
-    payload.model_type.must_equal Intercom::Conversation
-  end
-
-  it "returns correct Conversation notification topic" do
-    payload = Intercom::Notification.new(test_conversation_notification)
-    payload.topic.must_equal "conversation.user.created"
-  end
-
-  it "returns inner User object for Conversation" do
-    payload = Intercom::Notification.new(test_conversation_notification)
-    payload.model.user.must_be_instance_of Intercom::User
-  end
-  
-  it "returns inner User object with nil tags" do
-    user_notification = {
-      "type" => "notification_event",
-      "app_id" => "aa11aa",
-      "data" => {
-        "type" => "notification_event_data",
-        "item" => {
-          "type" => "user",
-          "id" => "abc123def",
-          "user_id" => "666",
-          "email" => "joe@example.com",
-          "name" => "Joe",
-          "tags" => {
-            "type" => "tag.list",
-            "tags" => nil
-          }
-        }
-      },  
-    }
-    payload = Intercom::Notification.new(user_notification)
-    payload.model.tags.must_equal([])
-  end
-
-end