zendesk_api 0.0.9

data/lib/zendesk_api/configuration.rb

@@ -0,0 +1,52 @@
+module ZendeskAPI
+  class Configuration
+    # @return [String] The basic auth username.
+    attr_accessor :username
+
+    # @return [String] The basic auth password.
+    attr_accessor :password
+
+    # @return [String] The API url. Must be https unless {#allow_http} is set.
+    attr_accessor :url
+
+    # @return [Boolean] Whether to attempt to retry when rate-limited (http status: 429).
+    attr_accessor :retry
+
+    # @return [Logger] Logger to use when logging requests.
+    attr_accessor :logger
+
+    # @return [Hash] Client configurations (eg ssh config) to pass to Faraday
+    attr_accessor :client_options
+
+    # @return [Symbol] Faraday adapter
+    attr_accessor :adapter
+
+    # @return [Boolean] Whether to allow non-HTTPS connections for development purposes.
+    attr_accessor :allow_http
+
+    # Use this cache instead of default ZendeskAPI::LRUCache.new
+    # - must respond to read/write/fetch e.g. ActiveSupport::Cache::MemoryStore.new)
+    # - pass false to disable caching
+    # @return [ZendeskAPI::LRUCache]
+    attr_accessor :cache
+
+    def initialize
+      @client_options = {}
+      self.cache = ZendeskAPI::LRUCache.new(1000)
+    end
+
+    # Sets accept and user_agent headers, and url.
+    #
+    # @return [Hash] Faraday-formatted hash of options.
+    def options
+      {
+        :headers => {
+          :accept => 'application/json',
+          :accept_encoding => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+          :user_agent => "ZendeskAPI API #{ZendeskAPI::VERSION}"
+        },
+        :url => @url
+      }.merge(client_options)
+    end
+  end
+end

data/lib/zendesk_api/core_ext/inflection.rb

@@ -0,0 +1,13 @@
+require 'inflection'
+
+Inflection.plural_rule 'forum', 'forums'
+
+class String
+  def singular
+    Inflection.singular(self)
+  end
+  
+  def plural
+    Inflection.plural(self)
+  end
+end

data/lib/zendesk_api/core_ext/modulize.rb

@@ -0,0 +1,10 @@
+# From https://github.com/rubyworks/facets/blob/master/lib/core/facets/string/modulize.rb
+class String
+  def modulize
+    #gsub('__','/').  # why was this ever here?
+    gsub(/__(.?)/){ "::#{$1.upcase}" }.
+    gsub(/\/(.?)/){ "::#{$1.upcase}" }.
+    gsub(/(?:_+|-+)([a-z])/){ $1.upcase }.
+    gsub(/(\A|\s)([a-z])/){ $1 + $2.upcase }
+  end
+end

data/lib/zendesk_api/core_ext/snakecase.rb

@@ -0,0 +1,12 @@
+# From https://github.com/rubyworks/facets/blob/master/lib/core/facets/string/snakecase.rb
+class String
+  def snakecase
+    #gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr('-', '_').
+    gsub(/\s/, '_').
+    gsub(/__+/, '_').
+    downcase
+  end
+end

data/lib/zendesk_api/lru_cache.rb

@@ -0,0 +1,38 @@
+module ZendeskAPI
+  # http://codesnippets.joyent.com/posts/show/12329
+  class ZendeskAPI::LRUCache
+    attr_accessor :size
+
+    def initialize(size = 10)
+      @size = size
+      @store = {}
+      @lru = []
+    end
+
+    def write(key, value)
+      @store[key] = value
+      set_lru(key)
+      @store.delete(@lru.pop) if @lru.size > @size
+      value
+    end
+
+    def read(key)
+      set_lru(key)
+      @store[key]
+    end
+
+    def fetch(key)
+      if @store.has_key? key
+        read key
+      else
+        write key, yield
+      end
+    end
+
+    private
+
+    def set_lru(key)
+      @lru.unshift(@lru.delete(key) || key)
+    end
+  end
+end

data/lib/zendesk_api/middleware/request/etag_cache.rb

@@ -0,0 +1,38 @@
+require "faraday/middleware"
+
+module ZendeskAPI
+  module Middleware
+    module Request
+      # Request middleware that caches responses based on etags
+      # can be removed once this is merged: https://github.com/pengwynn/faraday_middleware/pull/42
+      class EtagCache < Faraday::Middleware
+        def initialize(app, options = {})
+          @app = app
+          @cache = options[:cache] ||
+            raise("need :cache option e.g. ActiveSupport::Cache::MemoryStore.new")
+          @cache_key_prefix = options.fetch(:cache_key_prefix, :faraday_etags)
+        end
+
+        def call(env)
+          return @app.call(env) unless [:get, :head].include?(env[:method])
+          cache_key = [@cache_key_prefix, env[:url].to_s]
+
+          # send known etag
+          if cached = @cache.read(cache_key)
+            env[:request_headers]["If-None-Match"] ||= cached[:response_headers]["Etag"]
+          end
+
+          @app.call(env).on_complete do
+            if cached && env[:status] == 304 # not modified
+              env[:body] = cached[:body]
+            end
+
+            if env[:status] == 200 && env[:response_headers]["Etag"] # modified and cacheable
+              @cache.write(cache_key, env)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_api/middleware/request/retry.rb

@@ -0,0 +1,39 @@
+require "faraday/middleware"
+
+module ZendeskAPI
+  module Middleware
+    module Request
+      # Faraday middleware to handle HTTP Status 429 (rate limiting) / 503 (maintenance)
+      class Retry < Faraday::Middleware
+        DEFAULT_RETRY_AFTER = 10
+        ERROR_CODES = [429, 503]
+
+        def initialize(app, options={})
+          super(app)
+          @logger = options[:logger]
+        end
+
+        def call(env)
+          response = @app.call(env)
+
+          if ERROR_CODES.include?(response.env[:status])
+            seconds_left = (response.env[:response_headers][:retry_after] || DEFAULT_RETRY_AFTER).to_i
+            @logger.warn "You have been rate limited. Retrying in #{seconds_left} seconds..." if @logger
+
+            seconds_left.times do |i|
+              sleep 1
+              time_left = seconds_left - i
+              @logger.warn "#{time_left}..." if time_left > 0 && time_left % 5 == 0 && @logger
+            end
+
+            @logger.warn "" if @logger
+
+            @app.call(env)
+          else
+            response
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_api/middleware/request/upload.rb

@@ -0,0 +1,32 @@
+require "faraday/middleware"
+require "mime/types"
+
+module ZendeskAPI
+  module Middleware
+    module Request
+      class Upload < Faraday::Middleware
+        def call(env)
+          if env[:body] && env[:body][:file]
+            file = env[:body].delete(:file)
+            case file
+            when File
+              path = file.path
+            when String
+              path = file
+            else
+              warn "WARNING: Passed invalid filename #{file} of type #{file.class} to upload"
+            end
+
+            if path
+              env[:body][:filename] ||= File.basename(path)
+              mime_type = MIME::Types.type_for(path).first || "application/octet-stream"
+              env[:body][:uploaded_data] = Faraday::UploadIO.new(path, mime_type)
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_api/middleware/response/callback.rb

@@ -0,0 +1,19 @@
+require "faraday/response"
+
+module ZendeskAPI
+  module Middleware
+    module Response
+      class Callback < Faraday::Response::Middleware
+        def initialize(app, client)
+          super(app)
+          @client = client
+        end
+
+        def on_complete(env)
+          super(env)
+          @client.callbacks.each {|c| c.call(env)}
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_api/middleware/response/deflate.rb

@@ -0,0 +1,18 @@
+require 'faraday_middleware/response_middleware'
+
+module ZendeskAPI
+  module Middleware
+    module Response
+      # Faraday middleware to handle content-encoding = inflate
+      class Deflate < FaradayMiddleware::ResponseMiddleware
+        define_parser do |body|
+          Zlib::Inflate.inflate(body)
+        end
+
+        def parse_response?(env)
+          super && env[:response_headers]['content-encoding'] == "deflate"
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_api/middleware/response/gzip.rb

@@ -0,0 +1,18 @@
+require 'faraday_middleware/response_middleware'
+
+module ZendeskAPI
+  module Middleware
+    module Response
+      # Faraday middleware to handle content-encoding = gzip
+      class Gzip < FaradayMiddleware::ResponseMiddleware
+        define_parser do |body|
+          Zlib::GzipReader.new(StringIO.new(body)).read
+        end
+
+        def parse_response?(env)
+          super && env[:response_headers]['content-encoding'] == "gzip"
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_api/middleware/response/parse_iso_dates.rb

@@ -0,0 +1,29 @@
+require 'time'
+require "faraday/response"
+
+module ZendeskAPI
+  module Middleware
+    module Response
+      # Parse ISO dates from response body
+      class ParseIsoDates < Faraday::Response::Middleware
+        def call(env)
+          response = @app.call(env)
+          parse_dates! response.env[:body]
+          response
+        end
+
+        private
+
+        def parse_dates!(value)
+          case value
+          when Hash then value.each { |key,element| value[key] = parse_dates!(element) }
+          when Array then value.each_with_index { |element, index| value[index] = parse_dates!(element) }
+          when /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z\Z/m then Time.parse(value)
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_api/rescue.rb

@@ -0,0 +1,44 @@
+module ZendeskAPI
+  module Rescue
+    def self.included(klass)
+      klass.extend(Methods)
+      klass.send(:include, Methods)
+    end
+
+    module Methods
+      def log_error(e, method = false)
+        if logger = (@client ? @client.config.logger : Kernel)
+          logger.warn "#{self} - #{method}" if method
+          logger.warn e.message
+          logger.warn e.backtrace.join("\n")
+          logger.warn "\t#{e.response[:body].inspect}" if e.response
+        end
+      end
+
+      def rescue_client_error(*args)
+        opts = args.last.is_a?(Hash) ? args.pop : {}
+
+        if args.any?
+          args.each do |method|
+            class_eval("alias :orig_#{method} :#{method}")
+            define_method method do |*args|
+              begin
+                send("orig_#{method}", *args)
+              rescue Faraday::Error::ClientError => e
+                log_error(e, method)
+                opts[:with].respond_to?(:call) ? opts[:with].call : opts[:with]
+              end
+            end
+          end
+        elsif block_given?
+          begin
+            yield
+          rescue Faraday::Error::ClientError => e
+            log_error(e)
+            opts[:with].respond_to?(:call) ? opts[:with].call : opts[:with]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zendesk_api/resource.rb

@@ -0,0 +1,133 @@
+require 'zendesk_api/trackie'
+require 'zendesk_api/actions'
+require 'zendesk_api/association'
+require 'zendesk_api/verbs'
+
+module ZendeskAPI
+  # Represents a resource that only holds data.
+  class Data
+    include Associations
+    include Rescue
+
+    class << self
+      # The singular resource name taken from the class name (e.g. ZendeskAPI::Ticket -> ticket)
+      def singular_resource_name
+        @singular_resource_name ||= to_s.split("::").last.snakecase
+      end
+
+      # The resource name taken from the class name (e.g. ZendeskAPI::Ticket -> tickets)
+      def resource_name
+        @resource_name ||= singular_resource_name.plural
+      end
+
+      alias :model_key :resource_name
+
+      # Rails tries to load dependencies, which messes up automatic resource our own loading
+      if method_defined?(:const_missing_without_dependencies)
+        alias :const_missing :const_missing_without_dependencies
+      end
+
+      def only_send_unnested_params
+        @unnested_params = true
+      end
+
+      def unnested_params
+        @unnested_params ||= false
+      end
+    end
+
+    # @return [Hash] The resource's attributes
+    attr_reader :attributes
+    # @return [ZendeskAPI::Association] The association
+    attr_accessor :association
+
+    # Create a new resource instance.
+    # @param [Client] client The client to use
+    # @param [Hash] attributes The optional attributes that describe the resource
+    def initialize(client, attributes = {})
+      raise "Expected a Hash for attributes, got #{attributes.inspect}" unless attributes.is_a?(Hash)
+      @association = attributes.delete(:association) || Association.new(:class => self.class)
+      @client = client
+      @attributes = ZendeskAPI::Trackie.new(attributes)
+      ZendeskAPI::Client.check_deprecated_namespace_usage @attributes, self.class.singular_resource_name
+
+      @attributes.clear_changes unless new_record?
+    end
+
+    # Passes the method onto the attributes hash.
+    # If the attributes are nested (e.g. { :tickets => { :id => 1 } }), passes the method onto the nested hash.
+    def method_missing(*args, &block)
+      raise NoMethodError, ":save is not defined" if args.first.to_sym == :save
+      @attributes.send(*args, &block)
+    end
+
+    # Returns the resource id of the object or nil
+    def id
+      key?(:id) ? method_missing(:id) : nil
+    end
+
+    # Has this been object been created server-side? Does this by checking for an id.
+    def new_record?
+      id.nil? 
+    end
+
+    # Returns the path to the resource
+    def path(*args)
+      @association.generate_path(self, *args)
+    end
+
+    def to_s
+      "#{self.class.singular_resource_name}: #{attributes.inspect}"
+    end
+    alias :inspect :to_s
+
+    def ==(other)
+      warn "Trying to compare #{other.class} to a Resource" if other && !other.is_a?(Data)
+      other.is_a?(self.class) && ((other.id && other.id == id) || (other.object_id == self.object_id))
+    end
+    alias :eql :==
+    alias :hash :id
+
+    def inspect
+      "#<#{self.class.name} #{@attributes.to_hash.inspect}>"
+    end
+
+    alias :to_param :attributes
+  end
+
+  # Indexable resource
+  class DataResource < Data
+    extend Verbs
+  end
+
+  # Represents a resource that can only GET
+  class ReadResource < DataResource
+    extend Read
+  end
+
+  # Represents a resource that can only POST
+  class CreateResource < DataResource
+    include Create
+  end
+
+  # Represents a resource that can only PUT
+  class UpdateResource < DataResource
+    include Update
+  end
+
+  # Represents a resource that can only DELETE
+  class DeleteResource < DataResource
+    include Destroy
+  end
+
+  # Represents a resource that can CRUD (create, read, update, delete).
+  class Resource < DataResource
+    extend Read
+    include Create
+
+    include Update 
+    include Destroy
+  end
+
+  class SingularResource < Resource; end
+end