desk_api 0.5.8 → 0.6.0

data/lib/desk_api.rb

@@ -1,5 +1,5 @@
 require 'uri'
-require 'json'
+require 'faraday'
 require 'forwardable'
 require 'addressable/uri'
 
@@ -25,4 +25,4 @@ module DeskApi
   end
 
   setup
-end
+end

data/lib/desk_api/client.rb

@@ -34,6 +34,11 @@ class DeskApi::Client
     request(:patch, path, params)
   end
 
+  # allow lookup by url
+  def by_url(url)
+    DeskApi::Resource.new(self, DeskApi::Resource.build_self_link(url))
+  end
+
 private
   # If the method is missing create a resource
   def method_missing(method, params = {}, &block)
@@ -53,4 +58,4 @@ private
   def connection
     @connection ||= Faraday.new endpoint, connection_options, &middleware
   end
-end
+end

data/lib/desk_api/configuration.rb

@@ -1,9 +1,11 @@
-require 'faraday_middleware'
-require 'faraday_middleware/version'
-require 'faraday_middleware/response/parse_dates'
+require 'faraday'
 
 require 'desk_api/default'
 require 'desk_api/request/retry'
+require 'desk_api/request/oauth'
+require 'desk_api/request/encode_json'
+require 'desk_api/response/parse_dates'
+require 'desk_api/response/parse_json'
 require 'desk_api/response/raise_error'
 require 'desk_api/error/configuration_error'
 require 'desk_api/error/client_error'
@@ -29,6 +31,24 @@ module DeskApi::Configuration
         :connection_options
       ]
     end
+
+    def included(base)
+      if Gem::Version.new(Faraday::VERSION) >= Gem::Version.new('0.9.0')
+        Faraday::Request.register_middleware desk_encode_json: DeskApi::Request::EncodeJson
+        Faraday::Request.register_middleware desk_oauth: DeskApi::Request::OAuth
+        Faraday::Request.register_middleware desk_retry: DeskApi::Request::Retry
+        Faraday::Response.register_middleware desk_parse_dates: DeskApi::Response::ParseDates
+        Faraday::Response.register_middleware desk_parse_json: DeskApi::Response::ParseJson
+        Faraday::Response.register_middleware desk_raise_error: DeskApi::Response::RaiseError
+      else
+        Faraday.register_middleware :request, desk_encode_json: DeskApi::Request::EncodeJson
+        Faraday.register_middleware :request, desk_oauth: DeskApi::Request::OAuth
+        Faraday.register_middleware :request, desk_retry: DeskApi::Request::Retry
+        Faraday.register_middleware :response, desk_parse_dates: DeskApi::Response::ParseDates
+        Faraday.register_middleware :response, desk_parse_json: DeskApi::Response::ParseJson
+        Faraday.register_middleware :response, desk_raise_error: DeskApi::Response::RaiseError
+      end
+    end
   end
 
   # if subdomain is set make sure endpoint is correct
@@ -38,28 +58,16 @@ module DeskApi::Configuration
 
   def middleware
     @middleware ||= Proc.new do |builder|
-      if Gem::Version.new(FaradayMiddleware::VERSION) >= Gem::Version.new('0.9.0')
-        builder.request :json
-        builder.request :basic_authentication, @username, @password if basic_auth.values.all?
-        builder.request :oauth, oauth if oauth.values.all?
-        builder.request :retry
-
-        builder.response :dates
-        builder.response :raise_desk_error, DeskApi::Error::ClientError
-        builder.response :raise_desk_error, DeskApi::Error::ServerError
-        builder.response :json, content_type: /application\/json/
-      else
-        builder.use FaradayMiddleware::EncodeJson
-        builder.use Faraday::Request::BasicAuthentication, @username, @password if basic_auth.values.all?
-        builder.use FaradayMiddleware::OAuth, oauth if oauth.values.all?
-        builder.use DeskApi::Request::Retry
-
-        builder.use FaradayMiddleware::ParseDates
-        builder.use DeskApi::Response::RaiseError, DeskApi::Error::ClientError
-        builder.use DeskApi::Response::RaiseError, DeskApi::Error::ServerError
-        builder.use FaradayMiddleware::ParseJson, content_type: /application\/json/
-      end
-      
+      builder.request :desk_encode_json
+      builder.request :basic_auth, @username, @password if basic_auth.values.all?
+      builder.request :desk_oauth, oauth if oauth.values.all?
+      builder.request :desk_retry
+
+      builder.response :desk_parse_dates
+      builder.response :desk_raise_error, DeskApi::Error::ClientError
+      builder.response :desk_raise_error, DeskApi::Error::ServerError
+      builder.response :desk_parse_json
+
       builder.adapter Faraday.default_adapter
     end
   end
@@ -136,4 +144,4 @@ private
       raise(DeskApi::Error::ConfigurationError, "Invalid endpoint specified: `#{endpoint}` must be a valid url.")
     end
   end
-end
+end

data/lib/desk_api/request/encode_json.rb

@@ -0,0 +1,11 @@
+module DeskApi::Request
+  class EncodeJson < Faraday::Middleware
+    dependency 'json'
+
+    def call(env)
+      env[:request_headers]['Content-Type'] = 'application/json'
+      env[:body] = ::JSON.dump(env[:body]) if env[:body] and not env[:body].to_s.empty?
+      @app.call env
+    end
+  end
+end

data/lib/desk_api/request/oauth.rb

@@ -0,0 +1,20 @@
+module DeskApi::Request
+  class OAuth < Faraday::Middleware
+    dependency 'simple_oauth'
+
+    def initialize(app, options)
+      super(app)
+      @options = options
+    end
+
+    def call(env)
+      env[:request_headers]['Authorization'] = oauth(env).to_s
+      @app.call env
+    end
+
+  private
+    def oauth(env)
+      SimpleOAuth::Header.new env[:method], env[:url].to_s, {}, @options
+    end
+  end
+end

data/lib/desk_api/request/retry.rb

@@ -1,52 +1,47 @@
-module DeskApi
-  module Request
-    class Retry < Faraday::Request::Retry
-      def initialize(app, options = {})
-        @max = options[:max] || 3
-        @interval = options[:interval] || 10
-        super(app)
-      end
+module DeskApi::Request
+  class Retry < Faraday::Middleware
+    def initialize(app, options = {})
+      @max = options[:max] || 3
+      @interval = options[:interval] || 10
+      super(app)
+    end
 
-      def call(env)
-        retries   = @retries
-        env_clone = env.clone
-        begin
-          @app.call(env)
-        rescue DeskApi::Error::TooManyRequests => e
-          if retries > 0 and e.rate_limit.reset_in
-            retries = 0
-            sleep e.rate_limit.reset_in
-            env = env_clone
-            retry
-          end
-          raise
-        rescue exception_matcher
-          if retries > 0
-            retries -= 1
-            sleep @interval
-            env = env_clone
-            retry
-          end
-          raise
+    def call(env)
+      retries   = @max
+      request_body = env[:body]
+      begin
+        env[:body] = request_body
+        @app.call(env)
+      rescue DeskApi::Error::TooManyRequests => e
+        if retries > 0
+          retries = 0
+          sleep e.rate_limit.reset_in
+          retry
         end
+        raise
+      rescue exception_matcher
+        if retries > 0
+          retries -= 1
+          sleep @interval
+          retry
+        end
+        raise
       end
+    end
 
-      def exception_matcher
-        exceptions = [Errno::ETIMEDOUT, 'Timeout::Error', Faraday::Error::TimeoutError]
-        matcher = Module.new
-        (class << matcher; self; end).class_eval do
-          define_method(:===) do |error|
-            exceptions.any? do |ex|
-              if ex.is_a? Module then error.is_a? ex
-              else error.class.to_s == ex.to_s
-              end
+    def exception_matcher
+      exceptions = [Errno::ETIMEDOUT, 'Timeout::Error', Faraday::Error::TimeoutError]
+      matcher = Module.new
+      (class << matcher; self; end).class_eval do
+        define_method(:===) do |error|
+          exceptions.any? do |ex|
+            if ex.is_a? Module then error.is_a? ex
+            else error.class.to_s == ex.to_s
             end
           end
         end
-        matcher
       end
+      matcher
     end
-
-    Faraday.register_middleware :request, retry: lambda { Retry }
   end
-end
+end

data/lib/desk_api/resource.rb

@@ -1,4 +1,8 @@
 class DeskApi::Resource
+  # by_url is deprecated on resources
+  extend Forwardable
+  def_delegator :@_client, :by_url, :by_url
+
   class << self
     def build_self_link(link, params = {})
       link = {'href'=>link} if link.kind_of?(String)
@@ -7,11 +11,13 @@ class DeskApi::Resource
   end
 
   def initialize(client, definition = {}, loaded = false)
-    @_client, @_definition, @_loaded, @_changed = client, definition, loaded, {}
+    reset!
+    @_client, @_definition, @_loaded = client, definition, loaded
+    # better default
   end
 
   def create(params = {})
-    self.class.new(@_client, @_client.post(clean_base_url, params).body, true)
+    new_resource(@_client.post(clean_base_url, params).body, true)
   end
 
   def update(params = {})
@@ -30,26 +36,51 @@ class DeskApi::Resource
     params = { q: params } if params.kind_of?(String)
     url = Addressable::URI.parse(clean_base_url + '/search')
     url.query_values = params
-    self.class.new(@_client, self.class.build_self_link(url.to_s))
+    new_resource(self.class.build_self_link(url.to_s))
   end
 
   def find(id, options = {})
-    res = self.class.new(@_client, self.class.build_self_link("#{clean_base_url}/#{id}"))
+    res = new_resource(self.class.build_self_link("#{clean_base_url}/#{id}"))
     res.embed(*(options[:embed].kind_of?(Array) ? options[:embed] : [options[:embed]])) if options[:embed]
     res.exec!
   end
   alias_method :by_id, :find
 
+  def next!
+    self.load
+    next_page = @_definition['_links']['next']
+
+    if next_page
+      @_definition = self.class.build_self_link(next_page)
+      self.reset!
+    end
+
+  end
+
+  def all(&block)
+    raise ArgumentError, "Block must be given for #all" unless block_given?
+    each_page do |page, page_num|
+      page.entries.each { |resource| yield resource, page_num }
+    end
+  end
+
+  def each_page
+    raise ArgumentError, "Block must be given for #each_page" unless block_given?
+    page = self.first.per_page(self.query_params['per_page'] || 1000).dup
+    begin
+      yield page, page.page
+    end while page.next!
+  rescue NoMethodError => err
+    raise NoMethodError, "#each_page and #all are only available on resources which offer pagination"
+  end
+
+
   def embed(*embedds)
     # make sure we don't try to embed anything that's not defined
     # add it to the query
     self.tap{ |res| res.query_params = { embed: embedds.join(',') } }
   end
 
-  def by_url(url)
-    self.class.new(@_client, self.class.build_self_link(url))
-  end
-
   def get_self
     @_definition['_links']['self']
   end
@@ -63,6 +94,16 @@ class DeskApi::Resource
     @_definition['_links']['self']['href'] = value
   end
 
+  def to_hash
+    self.load
+
+    {}.tap do |hash|
+      @_definition.each do |k, v|
+        hash[k] = v
+      end
+    end
+  end
+
   def resource_type
     get_self['class']
   end
@@ -100,7 +141,7 @@ class DeskApi::Resource
   end
 
   def respond_to?(method, include_private = false)
-    self.exec! unless @_loaded
+    self.load
     meth = method.to_s
 
     return true if is_embedded?(meth)
@@ -114,6 +155,15 @@ class DeskApi::Resource
   def reload!
     self.exec! true
   end
+  alias_method :load!, :reload!
+
+  def load
+    self.exec! unless @_loaded
+  end
+
+  def loaded?
+    @_loaded
+  end
 
 protected
 
@@ -127,11 +177,16 @@ protected
     self
   end
 
+  def reset!
+    @_links, @_embedded, @_changed, @_loaded = {}, {}, {}, false
+    self
+  end
+
 private
-  attr_accessor :_client, :_loaded, :_changed, :_definition
+  attr_accessor :_client, :_loaded, :_changed, :_embedded, :_links, :_definition
 
   def filter_update_actions(params = {})
-    params.select{ |key, _| key.to_s.include?('update_action') }
+    params.select{ |key, _| key.to_s.include?('_action') }
   end
 
   def is_field?(method)
@@ -151,28 +206,37 @@ private
   end
 
   def get_embedded_resource(method)
-    embedds = @_definition['_embedded']
+    return @_embedded[method] if @_embedded.key?(method)
+    @_embedded[method] = @_definition['_embedded'][method]
 
-    if embedds[method].kind_of?(Array) and not embedds[method].first.kind_of?(self.class)
-      embedds[method].map!{ |definition| self.class.new(@_client, definition, true) }
-    elsif not embedds[method].kind_of?(self.class)
-      embedds[method] = self.class.new(@_client, embedds[method], true)
+    if @_embedded[method].kind_of?(Array)
+      @_embedded[method].tap do |ary|
+        ary.map!{ |definition| new_resource(definition, true) } unless ary.first.kind_of?(self.class)
+      end
     else
-      embedds[method]
+      @_embedded[method] = new_resource(@_embedded[method], true)
     end
   end
 
   def get_linked_resource(method)
-    links = @_definition['_links']
+    return @_links[method] if @_links.key?(method)
+    @_links[method] = @_definition['_links'][method]
+
+    if @_links[method] and not @_links[method].kind_of?(self.class)
+      @_links[method] = new_resource(self.class.build_self_link(@_links[method]))
+    end
+  end
 
-    return nil if links[method].nil?
-    return links[method] if links[method].kind_of?(self.class)
+  def new_resource(definition, loaded=false, client=@_client)
+    self.class.new(client, definition, loaded)
+  end
 
-    links[method] = self.class.new(@_client, self.class.build_self_link(links[method]))
+  def request(method, url, params={}, client=@_client)
+    client.send(method, url, params)
   end
 
   def method_missing(method, *args, &block)
-    self.exec! unless @_loaded
+    self.load
 
     meth = method.to_s
 

data/lib/desk_api/response/parse_dates.rb

@@ -0,0 +1,28 @@
+module DeskApi::Response
+  class ParseDates < Faraday::Response::Middleware
+    dependency 'time'
+    
+    def on_complete(env)
+      env[:body] = parse_dates env[:body]
+    end
+
+  private
+
+    def parse_dates(value)
+      case value
+      when Hash
+        value.each_pair do |key, element|
+          value[key] = parse_dates element
+        end
+      when Array
+        value.each_with_index do |element, index|
+          value[index] = parse_dates element
+        end
+      when /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z\Z/m
+        Time.parse value
+      else
+        value
+      end
+    end
+  end
+end