zendesk2 1.9.0 → 1.10.0

data/lib/zendesk2/model.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Zendesk2::Model
   include Cistern::Model
 
@@ -14,12 +15,12 @@ module Zendesk2::Model
   def save
     save!
   rescue Zendesk2::Error => exception
-    self.errors = exception.response[:body]["details"].inject({}){|r,(k,v)| r.merge(k => v.map{|e| e["type"] || e["description"]})} rescue nil
+    self.errors = error_details(exception)
     self
   end
 
   def destroyed?
-    !self.reload
+    !reload
   end
 
   def destroy
@@ -31,7 +32,7 @@ module Zendesk2::Model
   # re-define Cistern::Attributes#missing_attributes to require non-blank
   def missing_attributes(args)
     missing, required = super(args)
-    blank, still_required = required.partition { |_,v| "" == v }
+    blank, still_required = required.partition { |_, v| '' == v }
     missing.merge!(Hash[blank])
 
     [missing, Hash[still_required]]
@@ -41,4 +42,14 @@ module Zendesk2::Model
     merge_attributes(attributes)
     save!
   end
+
+  private
+
+  def error_details(exception)
+    exception.response[:body]['details'].inject({}) do |a, (k, v)|
+      a.merge(k => v.map { |e| e['type'] || e['description'] })
+    end
+  rescue
+    nil
+  end
 end

data/lib/zendesk2/organization.rb

@@ -1,7 +1,7 @@
+# frozen_string_literal: true
 class Zendesk2::Organization
   include Zendesk2::Model
 
-
   # @return [integer] Automatically assigned when creating organization
   identity :id, type: :integer # ro[yes] required[no]
 
@@ -35,19 +35,19 @@ class Zendesk2::Organization
   def destroy!
     requires :identity
 
-    cistern.destroy_organization("organization" => {"id" => self.identity})
+    cistern.destroy_organization('organization' => { 'id' => identity })
   end
 
   def save!
     data = if new_record?
              requires :name
 
-             cistern.create_organization("organization" => self.attributes)
+             cistern.create_organization('organization' => attributes)
            else
              requires :identity
 
-             cistern.update_organization("organization" => self.attributes)
-           end.body["organization"]
+             cistern.update_organization('organization' => attributes)
+           end.body['organization']
 
     merge_attributes(data)
   end
@@ -57,7 +57,7 @@ class Zendesk2::Organization
     requires :identity
 
     cistern.users.load(
-      cistern.get_organization_users("organization" => {"id" => self.identity}).body["users"]
+      cistern.get_organization_users('organization' => { 'id' => identity }).body['users']
     )
   end
 
@@ -73,7 +73,7 @@ class Zendesk2::Organization
     requires :identity
 
     cistern.tickets.load(
-      cistern.get_organization_tickets("organization_id" => self.identity).body["tickets"]
+      cistern.get_organization_tickets('organization_id' => identity).body['tickets']
     )
   end
 end

data/lib/zendesk2/organizations.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class Zendesk2::Organizations
   include Zendesk2::Collection
 
@@ -12,32 +13,33 @@ class Zendesk2::Organizations
   assoc_accessor :user
 
   def find_by_external_id(external_id)
-    body = cistern.get_organization_by_external_id("external_id" => external_id).body
-    if data = body.delete("organizations")
-      collection = self.clone.load(data)
-      collection.merge_attributes(Cistern::Hash.slice(body, "count", "next_page", "previous_page"))
+    body = cistern.get_organization_by_external_id('external_id' => external_id).body
+    data = body.delete('organizations')
+    if data
+      collection = clone.load(data)
+      collection.merge_attributes(Cistern::Hash.slice(body, 'count', 'next_page', 'previous_page'))
       collection
     end
   end
 
   self.collection_method = :get_organizations
-  self.collection_root   = "organizations"
+  self.collection_root   = 'organizations'
   self.model_method      = :get_organization
-  self.model_root        = "organization"
-  self.search_type       = "organization"
+  self.model_root        = 'organization'
+  self.search_type       = 'organization'
   self.search_request    = :search_organization
 
-  def collection_page(params={})
-    collection_method = if self.user_id
+  def collection_page(params = {})
+    collection_method = if user_id
                           :get_user_organizations
                         else
                           :get_organizations
                         end
 
-    body = cistern.send(collection_method, Cistern::Hash.stringify_keys(self.attributes.merge(params))).body
+    body = cistern.send(collection_method, Cistern::Hash.stringify_keys(attributes.merge(params))).body
 
-    self.load(body[collection_root])
-    self.merge_attributes(Cistern::Hash.slice(body, "count", "next_page", "previous_page"))
+    load(body[collection_root])
+    merge_attributes(Cistern::Hash.slice(body, 'count', 'next_page', 'previous_page'))
     self
   end
 end

data/lib/zendesk2/paged_collection.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
 # adds {#create!} method to {Cistern::Collection}.
 module Zendesk2::PagedCollection
   def self.included(klass)
     klass.send(:attribute, :count)
-    klass.send(:attribute, :next_page_link, {:aliases => "next_page"})
-    klass.send(:attribute, :previous_page_link, {:aliases => "previous_page"})
+    klass.send(:attribute, :next_page_link, aliases: 'next_page')
+    klass.send(:attribute, :previous_page_link, aliases: 'previous_page')
     klass.send(:extend, ClassMethods)
   end
 
+  # add methods for explicitly defining constants within the collection response
   module ClassMethods
     attr_accessor :collection_method, :collection_root, :model_method, :model_root
 
@@ -15,14 +17,25 @@ module Zendesk2::PagedCollection
     end
   end
 
-  def collection_method; self.class.collection_method; end
-  def collection_root; self.class.collection_root; end
-  def model_method; self.class.model_method; end
-  def model_root; self.class.model_root; end
+  def collection_method
+    self.class.collection_method
+  end
+
+  def collection_root
+    self.class.collection_root
+  end
+
+  def model_method
+    self.class.model_method
+  end
+
+  def model_root
+    self.class.model_root
+  end
 
   def new_page
-    page = self.class.new(cistern: self.cistern)
-    page.merge_attributes(self.class.scopes.inject({}){|r,k| r.merge(k.to_s => send(k))})
+    page = self.class.new(cistern: cistern)
+    page.merge_attributes(self.class.scopes.inject({}) { |a, e| a.merge(e.to_s => public_send(e)) })
     page
   end
 
@@ -44,26 +57,18 @@ module Zendesk2::PagedCollection
     end
   end
 
-  def all_entries
-    each_entry.to_a
-  end
-
   def next_page
     if next_page_link
-      options = {"url" => next_page_link}
-      if self.respond_to?(:filtered) # searchable
-        options.merge!("filtered" => self.filtered)
-      end
+      options = { 'url' => next_page_link }
+      options['filtered'] = filtered if respond_to?(:filtered) # searchable
       new_page.all(options)
     end
   end
 
   def previous_page
     if previous_page_link
-      options = {"url" => previous_page_link}
-      if self.respond_to?(:filtered) # searchable
-        options.merge!("filtered" => self.filtered)
-      end
+      options = { 'url' => previous_page_link }
+      options['filtered'] = filtered if respond_to?(:filtered) # searchable
       new_page.all(options)
     end
   end
@@ -72,8 +77,8 @@ module Zendesk2::PagedCollection
   #
   # @raise [Zendesk2::Error] if creation was unsuccessful
   # @return [Zendesk::Model]
-  def create!(attributes={})
-    model = self.new(Zendesk2.stringify_keys(attributes).merge(Zendesk2.stringify_keys(self.attributes)))
+  def create!(attributes = {})
+    model = new(Zendesk2.stringify_keys(attributes).merge(Zendesk2.stringify_keys(self.attributes)))
     model.save!
   end
 
@@ -81,8 +86,8 @@ module Zendesk2::PagedCollection
   #
   # @see {#create!} to raise an exception on failure
   # @return [Zendesk::Model, FalseClass]
-  def create(attributes={})
-    model = self.new(attributes.merge(Zendesk2.stringify_keys(self.attributes)))
+  def create(attributes = {})
+    model = new(attributes.merge(Zendesk2.stringify_keys(self.attributes)))
     model.save
   end
 
@@ -94,7 +99,7 @@ module Zendesk2::PagedCollection
   end
 
   # Fetch a collection of resources
-  def all(params={})
+  def all(params = {})
     if search_query?(params)
       search_page(params)
     else
@@ -119,19 +124,18 @@ module Zendesk2::PagedCollection
   # @raise [Zendesk2::Error] if the record cannot be found or other request error
   # @return [Zendesk2::Model] fetched resource corresponding to value of {Zendesk2::Collection#model}
   def get!(identity_or_hash)
-    scoped_attributes = self.class.scopes.inject({}){|r,k| r.merge(k.to_s => send(k))}
+    scoped_attributes = self.class.scopes.inject({}) { |a, e| a.merge(e.to_s => send(e)) }
 
     if identity_or_hash.is_a?(Hash)
       scoped_attributes.merge!(identity_or_hash)
     else
-      scoped_attributes.merge!("id" => identity_or_hash)
+      scoped_attributes['id'] = identity_or_hash
     end
 
     scoped_attributes = { model_root => scoped_attributes }
 
-    if data = self.cistern.send(model_method, scoped_attributes).body[self.model_root]
-      new(data)
-    end
+    data = cistern.send(model_method, scoped_attributes).body[model_root]
+    new(data) if data
   end
 
   # Quiet version of {#get!}
@@ -148,20 +152,20 @@ module Zendesk2::PagedCollection
   protected
 
   def search_query?(params)
-    !!params["filtered"] && !!params["url"]
+    params['filtered'] && params['url']
   end
 
   def search_page(params)
-    query = Faraday::NestedParamsEncoder.decode(URI.parse(params.fetch("url")).query)
+    query = Faraday::NestedParamsEncoder.decode(URI.parse(params.fetch('url')).query)
 
-    search(query.delete("query"), query)
+    search(query.delete('query'), query)
   end
 
   def collection_page(params)
-    scoped_attributes = self.class.scopes.inject({}) { |r, k| r.merge(k.to_s => send(k)) }.merge(params)
+    scoped_attributes = self.class.scopes.inject({}) { |a, e| a.merge(e.to_s => send(e)) }.merge(params)
     body = cistern.send(collection_method, scoped_attributes).body
 
-    self.load(body[collection_root]) # 'results' is the key for paged seraches
-    self.merge_attributes(Cistern::Hash.slice(body, "count", "next_page", "previous_page"))
+    load(body[collection_root]) # 'results' is the key for paged seraches
+    merge_attributes(Cistern::Hash.slice(body, 'count', 'next_page', 'previous_page'))
   end
 end

data/lib/zendesk2/rate_limit.rb

@@ -1,10 +1,11 @@
-require "logger"
+# frozen_string_literal: true
+require 'logger'
 
+# Faraday middleware to block and sleep on rate limit events
 class Zendesk2::RateLimit
-
   attr_reader :logger
 
-  def initialize(app, options={})
+  def initialize(app, options = {})
     @app    = app
     @logger = options[:logger] || ::Logger.new(nil)
   end

data/lib/zendesk2/real.rb

@@ -1,29 +1,32 @@
+# frozen_string_literal: true
 class Zendesk2::Real
-
   attr_accessor :username, :url, :token, :logger, :jwt_token, :last_request
 
-  def initialize(options={})
-    @url = if url = options[:url] || Zendesk2.defaults[:url]
-             URI.parse(url).to_s
-           end
+  # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+  def initialize(options = {})
+    url = options[:url] || Zendesk2.defaults[:url]
+
+    @url = (URI.parse(url).to_s if url)
 
     @logger   = options[:logger]   || Logger.new(nil)
-    adapter   = options[:adapter]  || Faraday.default_adapter
+    @adapter  = options[:adapter]  || Faraday.default_adapter
     @username = options[:username] || Zendesk2.defaults[:username]
     @token    = options.fetch(:token, Zendesk2.defaults[:token])
     password  = options[:password] || Zendesk2.defaults[:password]
 
-    cistern_options = options[:cistern_options] || {}
-
     @auth_token  = password || @token
     @auth_id     = "#{@username}/token" if @auth_token == @token
     @jwt_token   = options[:jwt_token]
 
-    raise "Missing required options: :url" unless @url
-    raise "Missing required options: :username" unless @auth_id
-    raise "Missing required options: :password or :token" unless password || @token
+    raise 'Missing required options: :url' unless @url
+    raise 'Missing required options: :username' unless @auth_id
+    raise 'Missing required options: :password or :token' unless password || @token
+
+    connection
+  end
 
-    @cistern = Faraday.new({url: @url}.merge(cistern_options)) do |connection|
+  def connection
+    @connection ||= Faraday.new(url: @url) do |connection|
       # response
       connection.use Faraday::Request::BasicAuthentication, @auth_id, @auth_token
       connection.use Faraday::Response::RaiseError
@@ -35,27 +38,27 @@ class Zendesk2::Real
 
       # idempotency
       connection.request :retry,
-        :max                 => 30,
-        :interval            => 1,
-        :interval_randomness => 0.2,
-        :backoff_factor      => 2
+                         max: 30,
+                         interval: 1,
+                         interval_randomness: 0.2,
+                         backoff_factor: 2
 
       # rate limit
       connection.use Zendesk2::RateLimit, logger: @logger
 
       connection.use Zendesk2::Logger, @logger
-      connection.adapter(*adapter)
+      connection.adapter(*@adapter)
     end
   end
 
-  def request(options={})
+  def request(options = {})
     method  = options[:method] || :get
-    url     = options[:url] || File.join(@url, "/api/v2", options[:path])
+    url     = options[:url] || File.join(@url, '/api/v2', options[:path])
     params  = options[:params] || {}
     body    = options[:body]
-    headers = { "User-Agent" => Zendesk2::USER_AGENT }.merge(options[:headers] || {})
+    headers = { 'User-Agent' => Zendesk2::USER_AGENT }.merge(options[:headers] || {})
 
-    @cistern.send(method) do |req|
+    connection.send(method) do |req|
       req.url(url)
       req.headers.merge!(headers)
       req.params.merge!(params)
@@ -64,6 +67,6 @@ class Zendesk2::Real
   rescue Faraday::ConnectionFailed
     raise
   rescue Faraday::Error::ClientError => e
-    raise Zendesk2::Error.new(e)
+    raise Zendesk2::Error, e
   end
 end

data/lib/zendesk2/request.rb

@@ -1,5 +1,5 @@
+# frozen_string_literal: true
 module Zendesk2::Request
-
   class << self
     alias cistern_included included
 
@@ -10,8 +10,9 @@ module Zendesk2::Request
     end
   end
 
+  # provide class-level request information
   module ClassMethods
-    def request_method(request_method=nil)
+    def request_method(request_method = nil)
       @request_method ||= request_method
     end
 
@@ -36,15 +37,15 @@ module Zendesk2::Request
     end
 
     def error_map
-      @@error_map ||= {
-        :invalid => [422, {
-          "error"       => "RecordInvalid",
-          "description" => "Record validation errors",
-        }],
-        :not_found => [404, {
-          "error"       => "RecordNotFound",
-          "description" => "Not found",
-        }],
+      @error_map ||= {
+        invalid: [422, {
+          'error'       => 'RecordInvalid',
+          'description' => 'Record validation errors',
+        },],
+        not_found: [404, {
+          'error'       => 'RecordNotFound',
+          'description' => 'Not found',
+        },],
       }
     end
   end
@@ -55,23 +56,25 @@ module Zendesk2::Request
     @params = Cistern::Hash.stringify_keys(params)
   end
 
-  def _mock(params={})
+  def _mock(params = {})
     setup(params)
     mock
   end
 
-  def _real(params={})
+  def _real(params = {})
     setup(params)
     real
   end
 
   def page_params!(options)
-    page_params = if url = options.delete("url")
+    url = options.delete('url')
+
+    page_params = if url
                     Faraday::NestedParamsEncoder.decode(URI.parse(url).query)
                   else
                     Cistern::Hash.stringify_keys(options)
                   end
-    Cistern::Hash.slice(page_params, "per_page", "page", "query")
+    Cistern::Hash.slice(page_params, 'per_page', 'page', 'query')
   end
 
   def page_params?
@@ -79,9 +82,7 @@ module Zendesk2::Request
   end
 
   def request_params
-    page_params = if page_params?
-                    page_params!(self.params)
-                  end
+    page_params = (page_params!(params) if page_params?)
 
     if self.class.request_params
       self.class.request_params.call(self)
@@ -94,7 +95,7 @@ module Zendesk2::Request
     case (generator = self.class.request_path)
     when Proc then
       generator.call(self)
-    else raise ArgumentError.new("Couldn't generate request_path from #{generator.inspect}")
+    else raise ArgumentError, "Couldn't generate request_path from #{generator.inspect}"
     end
   end
 
@@ -109,97 +110,92 @@ module Zendesk2::Request
 
   def pluralize(word)
     pluralized = word.dup
-    [[/y$/, 'ies'], [/$/, 's']].find{|regex, replace| pluralized.gsub!(regex, replace) if pluralized.match(regex)}
+    [[/y$/, 'ies'], [/$/, 's']].find { |regex, replace| pluralized.gsub!(regex, replace) if pluralized.match(regex) }
     pluralized
   end
 
   def data
-    self.cistern.data
+    cistern.data
   end
 
   def html_url_for(path)
     File.join(cistern.url, path.to_s)
   end
 
-  def url_for(path, options={})
+  def url_for(path, options = {})
     URI.parse(
-      File.join(cistern.url, "/api/v2", path.to_s)
+      File.join(cistern.url, '/api/v2', path.to_s),
     ).tap do |uri|
-      if query = options[:query]
-        uri.query = Faraday::NestedParamsEncoder.encode(query)
-      end
+      query = options[:query]
+      query && (uri.query = Faraday::NestedParamsEncoder.encode(query))
     end.to_s
   end
 
-  def real(params={})
-    cistern.request(:method => self.class.request_method,
-                    :path   => self.request_path,
-                    :body   => self.request_body,
-                    :url    => params["url"],
-                    :params => self.request_params,
-                   )
+  def real(params = {})
+    cistern.request(method: self.class.request_method,
+                    path: request_path,
+                    body: request_body,
+                    url: params['url'],
+                    params: request_params,)
   end
 
-  def real_request(params={})
+  def real_request(params = {})
     request({
-      :method => self.class.request_method,
-      :path   => self.request_path(params),
-      :body   => self.request_body(params),
-    }.merge(cistern::hash.slice(params, :method, :path, :body, :headers)))
+      method: self.class.request_method,
+      path: request_path(params),
+      body: request_body(params),
+    }.merge(cistern.hash.slice(params, :method, :path, :body, :headers),),)
   end
 
-  def mock_response(body, options={})
+  def mock_response(body, options = {})
     response(
-      :method        => self.class.request_method,
-      :path          => options[:path]    || self.request_path,
-      :request_body  => self.request_body,
-      :response_body => body,
-      :headers       => options[:headers] || {},
-      :status        => options[:status]  || 200,
-      :params        => options[:params]  || self.request_params,
+      method: self.class.request_method,
+      path: options[:path] || request_path,
+      request_body: request_body,
+      response_body: body,
+      headers: options[:headers] || {},
+      status: options[:status]  || 200,
+      params: options[:params]  || request_params,
     )
   end
 
-  def find!(collection, identity, options={})
-    if resource = self.cistern.data[collection][identity.to_i]
-      resource
-    else
-      error!(options[:error] || :not_found, options)
-    end
+  def find!(collection, identity, options = {})
+    resource = cistern.data[collection][identity.to_i]
+    resource || error!(options[:error] || :not_found, options)
   end
 
-  def delete!(collection, identity, options={})
-    self.cistern.data[collection].delete(identity.to_i) ||
+  def delete!(collection, identity, options = {})
+    cistern.data[collection].delete(identity.to_i) ||
       error!(options[:error] || :not_found, options)
   end
 
-  def error!(type, options={})
+  def error!(type, options = {})
     status, body = self.class.error_map[type]
-    body.merge!("details" => options[:details]) if options[:details]
+    body['details'] = options[:details] if options[:details]
 
     response(
-      :path   => self.request_path,
-      :status => status,
-      :body   => body,
+      path: request_path,
+      status: status,
+      body: body,
     )
   end
 
-  def resources(collection, options={})
+  def resources(collection, options = {})
     page = collection.is_a?(Array) ? collection : cistern.data[collection.to_sym].values
     root = options.fetch(:root) { !collection.is_a?(Array) && collection.to_s }
 
     mock_response(
       root    => page,
-      "count" => page.size,
+      'count' => page.size,
     )
   end
 
-  def page(collection, options={})
+  def page(collection, options = {})
     url_params = options[:params] || params
     page_params = page_params!(params)
 
-    page_size  = (page_params.delete("per_page") || 50).to_i
-    page_index = (page_params.delete("page") || 1).to_i
+    page_size  = (page_params.delete('per_page') || 50).to_i
+    page_index = (page_params.delete('page') || 1).to_i
     root       = options.fetch(:root) { !collection.is_a?(Array) && collection.to_s }
     path       = options[:path] || request_path
 
@@ -210,24 +206,24 @@ module Zendesk2::Request
     total_pages = (count / page_size) + 1
 
     next_page = if page_index < total_pages
-                  url_for(path, query: {"page" => page_index + 1, "per_page" =>  page_size}.merge(url_params))
+                  url_for(path, query: { 'page' => page_index + 1, 'per_page' => page_size }.merge(url_params))
                 end
     previous_page = if page_index > 1
-                      url_for(path, query: {"page" => page_index - 1, "per_page" =>  page_size}.merge(url_params))
+                      url_for(path, query: { 'page' => page_index - 1, 'per_page' => page_size }.merge(url_params))
                     end
 
     resource_page = resources.slice(offset, page_size)
 
     body = {
       root            => resource_page,
-      "count"         => count,
-      "next_page"     => next_page,
-      "previous_page" => previous_page,
+      'count'         => count,
+      'next_page'     => next_page,
+      'previous_page' => previous_page,
     }
 
     response(
-      :body => body,
-      :path => path
+      body: body,
+      path: path,
     )
   end
 
@@ -245,18 +241,18 @@ module Zendesk2::Request
   # \@request_body is special because it's need for spec assertions but
   # {Faraday::Env} replaces the request body with the response body after
   # the request and the reference is lost
-  def response(options={})
+  def response(options = {})
     body                 = options[:response_body] || options[:body]
     method               = options[:method]        || :get
     params               = options[:params]
     cistern.last_request = options[:request_body]
-    status               = options[:status]        || 200
+    status               = options[:status] || 200
 
     path = options[:path]
     url  = options[:url] || url_for(path, query: params)
 
-    request_headers  = {"Accept"       => "application/json"}
-    response_headers = {"Content-Type" => "application/json; charset=utf-8"}
+    request_headers  = { 'Accept'       => 'application/json' }
+    response_headers = { 'Content-Type' => 'application/json; charset=utf-8' }
 
     # request phase
     # * :method - :get, :post, ...
@@ -269,17 +265,17 @@ module Zendesk2::Request
     # * :body   - the response body
     # * :response_headers
     env = Faraday::Env.from(
-      :method           => method,
-      :url              => URI.parse(url),
-      :body             => body,
-      :request_headers  => request_headers,
-      :response_headers => response_headers,
-      :status           => status,
+      method: method,
+      url: URI.parse(url),
+      body: body,
+      request_headers: request_headers,
+      response_headers: response_headers,
+      status: status,
     )
 
     Faraday::Response::RaiseError.new.on_complete(env) ||
       Faraday::Response.new(env)
   rescue Faraday::Error::ClientError => e
-    raise Zendesk2::Error.new(e)
+    raise Zendesk2::Error, e
   end
 end