zendesk_api 0.2.6 → 0.3.0

data/lib/zendesk_api/association.rb

@@ -71,7 +71,7 @@ module ZendeskAPI
 
     def _side_load(resource, side_loads)
       side_loads.map! do |side_load|
-        resource.send(:wrap_resource, side_load, options[:class], options)
+        resource.send(:wrap_resource, side_load, options)
       end
 
       ZendeskAPI::Collection.new(resource.client, options[:class]).tap do |collection|

data/lib/zendesk_api/associations.rb

@@ -10,11 +10,13 @@ module ZendeskAPI
   # @private
   module Associations
     def self.included(base)
-      base.send(:extend, ClassMethods)
+      base.extend ClassMethods
     end
 
-    def wrap_resource(resource, klass, class_level_association)
+    def wrap_resource(resource, class_level_association)
       instance_association = Association.new(class_level_association.merge(:parent => self))
+      klass = class_level_association[:class]
+
       case resource
       when Hash
         klass.new(@client, resource.merge(:association => instance_association))
@@ -30,6 +32,11 @@ module ZendeskAPI
     module ClassMethods
       include Rescue
 
+      def self.extended(klass)
+        klass.extend Has
+        klass.extend HasMany
+      end
+
       def associations
         @associations ||= []
       end
@@ -44,133 +51,155 @@ module ZendeskAPI
         end
       end
 
-      # Represents a parent-to-child association between resources. Options to pass in are: class, path.
-      # @param [Symbol] resource_name_or_class The underlying resource name or a class to get it from
-      # @param [Hash] class_level_options The options to pass to the method definition.
-      def has(resource_name_or_class, class_level_options = {})
-        if klass = class_level_options.delete(:class)
-          resource_name = resource_name_or_class
-        else
-          klass = resource_name_or_class
-          resource_name = klass.singular_resource_name
-        end
+      private
 
-        class_level_association = {
+      def build_association(klass, resource_name, options)
+        {
           :class => klass,
           :name => resource_name,
-          :inline => class_level_options.delete(:inline),
-          :path => class_level_options.delete(:path),
-          :include => (class_level_options.delete(:include) || klass.resource_name).to_s,
-          :include_key => (class_level_options.delete(:include_key) || :id).to_s,
-          :singular => true
+          :inline => options.delete(:inline),
+          :path => options.delete(:path),
+          :include => (options.delete(:include) || klass.resource_name).to_s,
+          :include_key => (options.delete(:include_key) || :id).to_s,
+          :singular => options.delete(:singular)
         }
+      end
 
-        associations << class_level_association
+      def define_used(association)
+        define_method "#{association[:name]}_used?" do
+          !!instance_variable_get("@#{association[:name]}")
+        end
+      end
 
-        id_column = "#{resource_name}_id"
+      module Has
+        # Represents a parent-to-child association between resources. Options to pass in are: class, path.
+        # @param [Symbol] resource_name_or_class The underlying resource name or a class to get it from
+        # @param [Hash] class_level_options The options to pass to the method definition.
+        def has(resource_name_or_class, class_level_options = {})
+          if klass = class_level_options.delete(:class)
+            resource_name = resource_name_or_class
+          else
+            klass = resource_name_or_class
+            resource_name = klass.singular_resource_name
+          end
+
+          class_level_association = build_association(klass, resource_name, class_level_options)
+          class_level_association.merge!(:singular => true, :id_column => "#{resource_name}_id")
 
-        define_method "#{resource_name}_used?" do
-          !!instance_variable_get("@#{resource_name}")
+          associations << class_level_association
+
+          define_used(class_level_association)
+          define_has_getter(class_level_association)
+          define_has_setter(class_level_association)
         end
 
-        define_method resource_name do |*args|
-          instance_options = args.last.is_a?(Hash) ? args.pop : {}
-
-          # return if cached
-          cached = instance_variable_get("@#{resource_name}")
-          return cached if cached && !instance_options[:reload]
-
-          # find and cache association
-          instance_association = Association.new(class_level_association.merge(:parent => self))
-          resource = if klass.respond_to?(:find) && resource_id = method_missing(id_column)
-            klass.find(@client, :id => resource_id, :association => instance_association)
-          elsif found = method_missing(resource_name.to_sym)
-            wrap_resource(found, klass, class_level_association)
-          elsif klass.superclass == DataResource
-            rescue_client_error do
-              response = @client.connection.get(instance_association.generate_path(:with_parent => true))
-              klass.new(@client, response.body[klass.singular_resource_name].merge(:association => instance_association))
+        private
+
+        def define_has_getter(association)
+          klass = association[:class] # shorthand
+
+          define_method association[:name] do |*args|
+            instance_options = args.last.is_a?(Hash) ? args.pop : {}
+
+            # return if cached
+            cached = instance_variable_get("@#{association[:name]}")
+            return cached if cached && !instance_options[:reload]
+
+            # find and cache association
+            instance_association = Association.new(association.merge(:parent => self))
+            resource = if klass.respond_to?(:find) && resource_id = method_missing(association[:id_column])
+              klass.find(@client, :id => resource_id, :association => instance_association)
+            elsif found = method_missing(association[:name].to_sym)
+              wrap_resource(found, association)
+            elsif klass.superclass == DataResource
+              rescue_client_error do
+                response = @client.connection.get(instance_association.generate_path(:with_parent => true))
+                klass.new(@client, response.body[klass.singular_resource_name].merge(:association => instance_association))
+              end
             end
-          end
 
-          send("#{id_column}=", resource.id) if resource && has_key?(id_column)
-          instance_variable_set("@#{resource_name}", resource)
+            send("#{association[:id_column]}=", resource.id) if resource && has_key?(association[:id_column])
+            instance_variable_set("@#{association[:name]}", resource)
+          end
         end
 
-        define_method "#{resource_name}=" do |resource|
-          resource = wrap_resource(resource, klass, class_level_association)
-          send("#{id_column}=", resource.id) if has_key?(id_column)
-          instance_variable_set("@#{resource_name}", resource)
+        def define_has_setter(association)
+          define_method "#{association[:name]}=" do |resource|
+            resource = wrap_resource(resource, association)
+            send("#{association[:id_column]}=", resource.id) if has_key?(association[:id_column])
+            instance_variable_set("@#{association[:name]}", resource)
+          end
         end
       end
 
-      # Represents a parent-to-children association between resources. Options to pass in are: class, path.
-      # @param [Symbol] resource_name_or_class The underlying resource name or class to get it from
-      # @param [Hash] class_level_options The options to pass to the method definition.
-      def has_many(resource_name_or_class, class_level_options = {})
-        if klass = class_level_options.delete(:class)
-          resource_name = resource_name_or_class
-        else
-          klass = resource_name_or_class
-          resource_name = klass.resource_name
-        end
-
-        class_level_association = {
-          :class => klass,
-          :name => resource_name,
-          :inline => class_level_options.delete(:inline),
-          :path => class_level_options.delete(:path),
-          :include => (class_level_options.delete(:include) || klass.resource_name).to_s,
-          :include_key => (class_level_options.delete(:include_key) || :id).to_s,
-          :singular => false
-        }
+      module HasMany
+        # Represents a parent-to-children association between resources. Options to pass in are: class, path.
+        # @param [Symbol] resource_name_or_class The underlying resource name or class to get it from
+        # @param [Hash] class_level_options The options to pass to the method definition.
+        def has_many(resource_name_or_class, class_level_options = {})
+          if klass = class_level_options.delete(:class)
+            resource_name = resource_name_or_class
+          else
+            klass = resource_name_or_class
+            resource_name = klass.resource_name
+          end
 
-        associations << class_level_association
+          class_level_association = build_association(klass, resource_name, class_level_options)
+          class_level_association.merge!(:singular => false, :id_column => "#{resource_name}_ids")
 
-        id_column = "#{resource_name}_ids"
+          associations << class_level_association
 
-        define_method "#{resource_name}_used?" do
-          !!instance_variable_get("@#{resource_name}")
+          define_used(class_level_association)
+          define_has_many_getter(class_level_association)
+          define_has_many_setter(class_level_association)
         end
 
-        define_method resource_name do |*args|
-          instance_opts = args.last.is_a?(Hash) ? args.pop : {}
+        private
+
+        def define_has_many_getter(association)
+          klass = association[:class]
+
+          define_method association[:name] do |*args|
+            instance_opts = args.last.is_a?(Hash) ? args.pop : {}
 
-          # return if cached
-          cached = instance_variable_get("@#{resource_name}")
-          return cached if cached && !instance_opts[:reload]
+            # return if cached
+            cached = instance_variable_get("@#{association[:name]}")
+            return cached if cached && !instance_opts[:reload]
 
-          # find and cache association
-          instance_association = Association.new(class_level_association.merge(:parent => self))
-          singular_resource_name = Inflection.singular(resource_name.to_s)
+            # find and cache association
+            instance_association = Association.new(association.merge(:parent => self))
+            singular_resource_name = Inflection.singular(association[:name].to_s)
 
-          resources = if (ids = method_missing("#{singular_resource_name}_ids")) && ids.any?
-            ids.map do |id|
-              klass.find(@client, :id => id, :association => instance_association)
-            end.compact
-          elsif (resources = method_missing(resource_name.to_sym)) && resources.any?
-            resources.map do |res|
-              klass.new(@client, res.merge(:association => instance_association))
+            resources = if (ids = method_missing("#{singular_resource_name}_ids")) && ids.any?
+              ids.map do |id|
+                klass.find(@client, :id => id, :association => instance_association)
+              end.compact
+            elsif (resources = method_missing(association[:name].to_sym)) && resources.any?
+              resources.map do |res|
+                klass.new(@client, res.merge(:association => instance_association))
+              end
+            else
+              ZendeskAPI::Collection.new(@client, klass, instance_opts.merge(:association => instance_association))
             end
-          else
-            ZendeskAPI::Collection.new(@client, klass, instance_opts.merge(:association => instance_association))
-          end
 
-          send("#{id_column}=", resources.map(&:id)) if resource && has_key?(id_column)
-          instance_variable_set("@#{resource_name}", resources)
+            send("#{association[:id_column]}=", resources.map(&:id)) if resource && has_key?(association[:id_column])
+            instance_variable_set("@#{association[:name]}", resources)
+          end
         end
 
-        define_method "#{resource_name}=" do |resources|
-          if resources.is_a?(Array)
-            resources.map! { |attr| wrap_resource(attr, klass, class_level_association) }
-            send(resource_name).replace(resources)
-          else
-            resources.association = instance_association
-            instance_variable_set("@#{resource_name}", resources)
-          end
+        def define_has_many_setter(association)
+          define_method "#{association[:name]}=" do |resources|
+            if resources.is_a?(Array)
+              resources.map! { |attr| wrap_resource(attr, association) }
+              send(association[:name]).replace(resources)
+            else
+              resources.association = Association.new(association.merge(:parent => self))
+              instance_variable_set("@#{association[:name]}", resources)
+            end
 
-          send("#{id_column}=", resources.map(&:id)) if resources && has_key?(id_column)
-          resource
+            send("#{association[:id_column]}=", resources.map(&:id)) if resources && has_key?(association[:id_column])
+            resource
+          end
         end
       end
     end

data/lib/zendesk_api/client.rb

@@ -78,34 +78,16 @@ module ZendeskAPI
       @config = ZendeskAPI::Configuration.new
       yield config
 
-      if !config.allow_http && config.url !~ /^https/
-        raise ArgumentError, "zendesk_api is ssl only; url must begin with https://"
-      end
-
-      config.retry = !!config.retry # nil -> false
-
-      if config.token && !config.password
-        config.password = config.token
-        config.username += "/token" unless config.username.end_with?("/token")
-      end
-
-      if config.logger.nil? || config.logger == true
-        require 'logger'
-        config.logger = Logger.new($stderr)
-        config.logger.level = Logger::WARN
-      end
-
       @callbacks = []
-
       @resource_cache = {}
 
-      if logger = config.logger
-        insert_callback do |env|
-          if warning = env[:response_headers]["X-Zendesk-API-Warn"]
-            logger.warn "WARNING: #{warning}"
-          end
-        end
-      end
+      check_url
+
+      config.retry = !!config.retry # nil -> false
+
+      set_token_auth
+      set_default_logger
+      add_warning_callback
     end
 
     # Creates a connection if there is none, otherwise returns the existing connection.
@@ -162,5 +144,42 @@ module ZendeskAPI
         builder.adapter *config.adapter || Faraday.default_adapter
       end
     end
+
+    private
+
+    def check_url
+      if !config.allow_http && config.url !~ /^https/
+        raise ArgumentError, "zendesk_api is ssl only; url must begin with https://"
+      end
+
+      if config.url !~ %r{api/v2}
+        warn "this gem doesn't support the v1 api"
+      end
+    end
+
+    def set_token_auth
+      if config.token && !config.password
+        config.password = config.token
+        config.username += "/token" unless config.username.end_with?("/token")
+      end
+    end
+
+    def set_default_logger
+      if config.logger.nil? || config.logger == true
+        require 'logger'
+        config.logger = Logger.new($stderr)
+        config.logger.level = Logger::WARN
+      end
+    end
+
+    def add_warning_callback
+      return unless logger = config.logger
+
+      insert_callback do |env|
+        if warning = env[:response_headers]["X-Zendesk-API-Warn"]
+          logger.warn "WARNING: #{warning}"
+        end
+      end
+    end
   end
 end

data/lib/zendesk_api/collection.rb

@@ -27,32 +27,21 @@ module ZendeskAPI
     # @param [String] resource The resource being collected.
     # @param [Hash] options Any additional options to be passed in.
     def initialize(client, resource, options = {})
-      @client, @resource = client, resource.resource_name
+      @client, @resource_class, @resource = client, resource, resource.resource_name
       @options = Hashie::Mash.new(options)
 
-      @verb = @options.delete(:verb)
-      @collection_path = @options.delete(:collection_path)
-
-      association_options = { :path => @options.delete(:path) }
-      association_options[:path] ||= @collection_path.join("/") if @collection_path
-      @association = @options.delete(:association) || Association.new(association_options.merge(:class => resource))
+      set_association_from_options
+      join_special_params
 
-      # some params use comma-joined strings instead of query-based arrays for multiple values
-      @options.each do |k, v|
-        if SPECIALLY_JOINED_PARAMS.include?(k.to_sym) && v.is_a?(Array)
-          @options[k] = v.join(',')
-        end
-      end
-
-      @collection_path ||= [@resource]
-      @resource_class = resource
-      @fetchable = true
+      @verb = @options.delete(:verb)
       @includes = Array(@options.delete(:include))
 
       # Used for Attachments, TicketComment
       if @resource_class.is_a?(Class) && @resource_class.superclass == ZendeskAPI::Data
         @resources = []
         @fetchable = false
+      else
+        @fetchable = true
       end
     end
 
@@ -158,39 +147,16 @@ module ZendeskAPI
     # Executes actual GET from API and loads resources into proper class.
     # @param [Boolean] reload Whether to disregard cache
     def fetch(reload = false)
-      return @resources if @resources && (!@fetchable || !reload)
-
-      if association && association.options.parent && association.options.parent.new_record?
+      if @resources && (!@fetchable || !reload)
+        return @resources
+      elsif association && association.options.parent && association.options.parent.new_record?
         return @resources = []
       end
 
-      if @query
-        path = @query
-        @query = nil
-      else
-        path = self.path
-      end
-
-      @response = @client.connection.send(@verb || "get", path) do |req|
-        opts = @options.delete_if {|k, v| v.nil?}
-
-        req.params.merge!(:include => @includes.join(",")) if @includes.any?
-
-        if %w{put post}.include?(@verb.to_s)
-          req.body = opts
-        else
-          req.params.merge!(opts)
-        end
-      end
-
-      body = @response.body.dup
-
-      results = body.delete(@resource_class.model_key) || body.delete("results")
-      @resources = results.map {|res| @resource_class.new(@client, res)}
-
-      set_page_and_count(body)
-      set_includes(@resources, @includes, body)
+      @response = get_response(@query || self.path)
+      handle_response(@response.body.dup)
 
+      @query = nil
       @resources
     end
 
@@ -238,8 +204,7 @@ module ZendeskAPI
       if @options["page"]
         clear_cache
         @options["page"] += 1
-      elsif @next_page
-        @query = @next_page
+      elsif @query = @next_page
         fetch(true)
       else
         clear_cache
@@ -255,8 +220,7 @@ module ZendeskAPI
       if @options["page"] && @options["page"] > 1
         clear_cache
         @options["page"] -= 1
-      elsif @prev_page
-        @query = @prev_page
+      elsif @query = @prev_page
         fetch(true)
       else
         clear_cache
@@ -277,16 +241,12 @@ module ZendeskAPI
 
     # Sends methods to underlying array of resources.
     def method_missing(name, *args, &block)
-      methods = @resource_class.singleton_methods(false).map(&:to_sym)
-
-      if methods.include?(name)
-        @resource_class.send(name, @client, *args, &block)
+      if resource_methods.include?(name)
+        collection_method(name, *args, &block)
       elsif Array.new.respond_to?(name)
-        to_a.send(name, *args, &block)
+        array_method(name, *args, &block)
       else
-        opts = args.last.is_a?(Hash) ? args.last : {}
-        opts.merge!(:collection_path => @collection_path.dup.push(name))
-        self.class.new(@client, @resource_class, @options.merge(opts))
+        next_collection(name, *args, &block)
       end
     end
 
@@ -316,5 +276,70 @@ module ZendeskAPI
         @options["page"] = $1.to_i + 1
       end
     end
+
+    ## Initialize
+
+    def join_special_params
+      # some params use comma-joined strings instead of query-based arrays for multiple values
+      @options.each do |k, v|
+        if SPECIALLY_JOINED_PARAMS.include?(k.to_sym) && v.is_a?(Array)
+          @options[k] = v.join(',')
+        end
+      end
+    end
+
+    def set_association_from_options
+      @collection_path = @options.delete(:collection_path)
+
+      association_options = { :path => @options.delete(:path) }
+      association_options[:path] ||= @collection_path.join("/") if @collection_path
+      @association = @options.delete(:association) || Association.new(association_options.merge(:class => @resource_class))
+
+      @collection_path ||= [@resource]
+    end
+
+    ## Fetch
+
+    def get_response(path)
+      @response = @client.connection.send(@verb || "get", path) do |req|
+        opts = @options.delete_if {|_, v| v.nil?}
+
+        req.params.merge!(:include => @includes.join(",")) if @includes.any?
+
+        if %w{put post}.include?(@verb.to_s)
+          req.body = opts
+        else
+          req.params.merge!(opts)
+        end
+      end
+    end
+
+    def handle_response(body)
+      results = body.delete(@resource_class.model_key) || body.delete("results")
+      @resources = results.map {|res| @resource_class.new(@client, res)}
+
+      set_page_and_count(body)
+      set_includes(@resources, @includes, body)
+    end
+
+    ## Method missing
+
+    def array_method(name, *args, &block)
+      to_a.send(name, *args, &block)
+    end
+
+    def next_collection(name, *args, &block)
+      opts = args.last.is_a?(Hash) ? args.last : {}
+      opts.merge!(:collection_path => @collection_path.dup.push(name))
+      self.class.new(@client, @resource_class, @options.merge(opts))
+    end
+
+    def collection_method(name, *args, &block)
+      @resource_class.send(name, @client, *args, &block)
+    end
+
+    def resource_methods
+      @resource_methods ||= @resource_class.singleton_methods(false).map(&:to_sym)
+    end
   end
 end