haveapi-client 0.20.0 → 0.21.0

data/lib/haveapi/client/communicator.rb

@@ -34,10 +34,12 @@ module HaveAPI::Client
     # @return [:imperfect] if minor version differs
     # @return [false] if not compatible
     def compatible?
-      description_for(path_for, {describe: :versions})
-      @proto_version == HaveAPI::Client::PROTOCOL_VERSION ? :compatible
-                                                          : :imperfect
-
+      description_for(path_for, { describe: :versions })
+      if @proto_version == HaveAPI::Client::PROTOCOL_VERSION
+        :compatible
+      else
+        :imperfect
+      end
     rescue ProtocolError
       false
     end
@@ -45,14 +47,14 @@ module HaveAPI::Client
     # Authenticate user with selected +auth_method+.
     # +auth_method+ is a name of registered authentication provider.
     # +options+ are specific for each authentication provider.
-    def authenticate(auth_method, options = {}, &block)
+    def authenticate(auth_method, options = {}, &)
       desc = describe_api(@version)
 
       @auth = self.class.auth_methods[auth_method].new(
         self,
         desc[:authentication][auth_method],
         options,
-        &block
+        &
       )
       @rest = @auth.resource || @rest
     end
@@ -62,11 +64,11 @@ module HaveAPI::Client
     end
 
     def available_versions
-      description_for(path_for, {describe: :versions})
+      description_for(path_for, { describe: :versions })
     end
 
-    def describe_api(v=nil)
-      description_for(path_for(v), v.nil? ? {describe: :default} : {})
+    def describe_api(v = nil)
+      description_for(path_for(v), v.nil? ? { describe: :default } : {})
     end
 
     def describe_resource(path)
@@ -97,7 +99,7 @@ module HaveAPI::Client
       a = tmp[:actions][action]
 
       unless a # search in aliases
-         tmp[:actions].each do |_, v|
+        tmp[:actions].each_value do |v|
           if v[:aliases].include?(action.to_s)
             a = v
             break
@@ -124,43 +126,39 @@ module HaveAPI::Client
         params.delete(:meta)
       end
 
-      if %w(POST PUT).include?(action.http_method)
+      if %w[POST PUT].include?(action.http_method)
         ns = {}
         ns[input_namespace] = params if input_namespace
         ns[:_meta] = meta if meta
         ns.update(@auth.request_payload)
 
         args << ns.to_json
-        args << {content_type: :json, accept: :json, user_agent: @identity}.update(@auth.request_headers)
+        args << { content_type: :json, accept: :json, user_agent: @identity }.update(@auth.request_headers)
 
-      elsif %w(GET DELETE).include?(action.http_method)
+      elsif %w[GET DELETE].include?(action.http_method)
         get_params = {}
 
         params.each do |k, v|
           get_params["#{input_namespace}[#{k}]"] = v
         end
 
-        meta.each do |k, v|
-          get_params["_meta[#{k}]"] = v # FIXME: read _meta namespace from the description
-
-        end if meta
+        if meta
+          meta.each do |k, v|
+            get_params["_meta[#{k}]"] = v # FIXME: read _meta namespace from the description
+          end
+        end
 
-        args << {params: get_params.update(@auth.request_query_params), accept: :json, user_agent: @identity}.update(@auth.request_headers)
+        args << { params: get_params.update(@auth.request_query_params), accept: :json, user_agent: @identity }.update(@auth.request_headers)
       end
 
       begin
         response = parse(@rest[action.prepared_path].method(action.http_method.downcase.to_sym).call(*args))
-
       rescue RestClient::Forbidden
         return error('Access forbidden. Bad user name or password? Not authorized?')
-
-      rescue RestClient::ResourceNotFound => e
-        response = parse(e.http_body)
-
-      rescue RestClient::BadRequest => e
+      rescue RestClient::ResourceNotFound,
+             RestClient::BadRequest => e
         response = parse(e.http_body)
-
-      rescue => e
+      rescue StandardError => e
         return error("Fatal API error: #{e.inspect}")
       end
 
@@ -177,15 +175,16 @@ module HaveAPI::Client
     end
 
     private
+
     def ok(response)
-      {status: true, response: response}
+      { status: true, response: }
     end
 
-    def error(msg, errors={})
-      {status: false, message: msg, errors: errors}
+    def error(msg, errors = {})
+      { status: false, message: msg, errors: }
     end
 
-    def path_for(v=nil, r=nil)
+    def path_for(v = nil, r = nil)
       ret = '/'
 
       ret += "v#{v}/" if v
@@ -194,7 +193,7 @@ module HaveAPI::Client
       ret
     end
 
-    def description_for(path, query_params={})
+    def description_for(path, query_params = {})
       ret = parse(@rest[path].get_options({
           params: @auth.request_payload.update(@auth.request_query_params).update(query_params),
           user_agent: @identity
@@ -206,8 +205,7 @@ module HaveAPI::Client
 
       unless ret[:version]
         raise ProtocolError,
-            "Incompatible protocol version: the client uses v#{p_v} "+
-            "while the API server uses an unspecified version (pre 1.0)"
+              "Incompatible protocol version: the client uses v#{p_v} while the API server uses an unspecified version (pre 1.0)"
       end
 
       major1, minor1 = ret[:version].split('.')
@@ -215,8 +213,8 @@ module HaveAPI::Client
 
       if major1 != major2
         raise ProtocolError,
-            "Incompatible protocol version: the client uses v#{p_v} "+
-            "while the API server uses v#{ret[:version]}"
+              "Incompatible protocol version: the client uses v#{p_v} " \
+              "while the API server uses v#{ret[:version]}"
       end
 
       warn "The client uses protocol v#{p_v} while the API server uses v#{ret[:version]}"

data/lib/haveapi/client/exceptions.rb

@@ -1,15 +1,13 @@
 module HaveAPI::Client
-  class ProtocolError < StandardError ; end
+  class ProtocolError < StandardError; end
 
   class ActionFailed < StandardError
     attr_reader :response
 
     def initialize(response)
-      @response = response
-    end
+      super("#{response.action.name} failed: #{response.message}")
 
-    def message
-      "#{@response.action.name} failed: #{@response.message}"
+      @response = response
     end
   end
 
@@ -17,12 +15,10 @@ module HaveAPI::Client
     attr_reader :errors
 
     def initialize(action, errors)
+      super("#{action.name} failed: input parameters not valid")
+
       @action = action
       @errors = errors
     end
-
-    def message
-      "#{@action.name} failed: input parameters not valid"
-    end
   end
 end

data/lib/haveapi/client/parameters/resource.rb

@@ -16,6 +16,7 @@ module HaveAPI::Client
     end
 
     protected
+
     def coerce(v)
       if !v.is_a?(::Integer) && /\A\d+\z/ !~ v
         @errors << 'not a valid resource id'

data/lib/haveapi/client/parameters/typed.rb

@@ -40,10 +40,11 @@ module HaveAPI::Client
     end
 
     protected
+
     def coerce(raw)
       type = @desc[:type]
 
-      val = if type == 'Integer'
+      if type == 'Integer'
         raw.to_i
 
       elsif type == 'Float'
@@ -62,21 +63,18 @@ module HaveAPI::Client
         else
           begin
             DateTime.iso8601(raw).to_time
-
           rescue ArgumentError
             @errors << 'not in ISO 8601 format'
             nil
           end
         end
 
-      elsif %w(String Text).include?(type)
+      elsif %w[String Text].include?(type)
         raw.to_s
 
       else
         raw
       end
-
-      val
     end
   end
 end

data/lib/haveapi/client/params.rb

@@ -1,5 +1,5 @@
 module HaveAPI::Client
-  module Parameters ; end
+  module Parameters; end
 
   class Params
     attr_reader :errors, :params
@@ -16,12 +16,12 @@ module HaveAPI::Client
       @action.input_params.each do |name, p|
         next unless @data.has_key?(name)
 
-        if p[:type] == 'Resource'
-          @params[name] = Parameters::Resource.new(self, p, @data[name])
+        @params[name] = if p[:type] == 'Resource'
+                          Parameters::Resource.new(self, p, @data[name])
 
-        else
-          @params[name] = Parameters::Typed.new(self, p, @data[name])
-        end
+                        else
+                          Parameters::Typed.new(self, p, @data[name])
+                        end
       end
     end
 
@@ -36,10 +36,9 @@ module HaveAPI::Client
           next
         end
 
-        if !@params[name].valid?
+        unless @params[name].valid?
           error(name, @params[name].errors)
         end
-
       end
 
       @errors.empty?
@@ -58,6 +57,7 @@ module HaveAPI::Client
     end
 
     protected
+
     def error(param, msg)
       @errors[param] ||= []
 

data/lib/haveapi/client/resource.rb

@@ -71,6 +71,7 @@ module HaveAPI::Client
     end
 
     protected
+
     # Define access/write methods for action +action+.
     def define_action(action)
       action.aliases(true).each do |name|
@@ -116,7 +117,7 @@ module HaveAPI::Client
             if user_params.has_key?(:meta)
               meta = user_params[:meta]
 
-              %i(block block_interval block_timeout).each do |p|
+              %i[block block_interval block_timeout].each do |p|
                 client_opts[p] = meta.delete(p) if meta.has_key?(p)
               end
             end
@@ -126,21 +127,18 @@ module HaveAPI::Client
 
           ret = Response.new(action, action.execute(input_params))
 
-          raise ActionFailed.new(ret) unless ret.ok?
+          raise ActionFailed, ret unless ret.ok?
 
           return_value = case action.output && action.output_layout
-            when :object
-              ResourceInstance.new(@client, @api, self, action: action, response: ret)
-
-            when :object_list
-              ResourceInstanceList.new(@client, @api, self, action, ret)
+                         when :object
+                           ResourceInstance.new(@client, @api, self, action:, response: ret)
 
-            when :hash, :hash_list
-              ret
+                         when :object_list
+                           ResourceInstanceList.new(@client, @api, self, action, ret)
 
-            else
-              ret
-          end
+                         else # :hash, :hash_list
+                           ret
+                         end
 
           if action.blocking? && client_opts[:block]
             wait_opts = {}
@@ -165,7 +163,8 @@ module HaveAPI::Client
     # Called before defining a method named +name+ that will
     # invoke +action+.
     def define_method?(action, name)
-      return false if %i(new).include?(name.to_sym)
+      return false if %i[new].include?(name.to_sym)
+
       true
     end
 

data/lib/haveapi/client/resource_instance.rb

@@ -24,28 +24,28 @@ module HaveAPI::Client
         if response.is_a?(Hash)
           @params = response
           @prepared_args = response[:_meta][:path_params]
-          @meta = response[:_meta] unless @meta
+          @meta ||= response[:_meta]
 
         else
           @response = response
           @params = response.response
           @prepared_args = response.meta[:path_params]
-          @meta = response.meta unless @meta
+          @meta ||= response.meta
         end
 
         setup_from_clone(resource)
         define_attributes
       end
 
-      unless @persistent
-        setup_from_clone(resource)
-        define_implicit_attributes
-        define_attributes(@action.input_params)
-      end
+      return if @persistent
+
+      setup_from_clone(resource)
+      define_implicit_attributes
+      define_attributes(@action.input_params)
     end
 
     def new
-      raise NoMethodError.new
+      raise NoMethodError
     end
 
     # Invoke +create+ action if the object is not persistent,
@@ -58,13 +58,10 @@ module HaveAPI::Client
         @action.provide_args
         @response = Response.new(@action, @action.execute(attributes_for_api(@action)))
 
-        if @response.ok?
-          @params = @response.response
-          define_attributes
+        return nil unless @response.ok?
 
-        else
-          return nil
-        end
+        @params = @response.response
+        define_attributes
 
         @persistent = true
         self
@@ -73,7 +70,8 @@ module HaveAPI::Client
 
     # Call #save and raise ActionFailed if it fails.
     def save!
-      raise ActionFailed.new(@response) if save.nil?
+      raise ActionFailed, @response if save.nil?
+
       self
     end
 
@@ -104,68 +102,69 @@ module HaveAPI::Client
     end
 
     def to_s
-      "<#{self.class.to_s}:#{object_id}:#{@resource._name}>"
+      "<#{self.class}:#{object_id}:#{@resource._name}>"
     end
 
     protected
+
     # Define access/writer methods for object attributes.
     def define_attributes(params = nil)
       (params || @action.params).each do |name, param|
         case param[:type]
-          when 'Resource'
-            @resource_instances[name] = find_association(param, @params[name])
-
-            # id reader
-            ensure_method(:"#{name}_id") do
-              @params[name] && @params[name][ param[:value_id].to_sym ]
-            end
-
-            # id writer
-            ensure_method(:"#{name}_id=") do |id|
-              @params[name] ||= {}
-              @params[name][ param[:value_id].to_sym ] = id
-
-              @resource_instances[name] = find_association(
-                  param,
-                  {
-                      param[:value_id] => id,
-                      :_meta => {
-                          resolved: false,
-                          # TODO: this will not work for nested resources, as they have
-                          # multiple IDs
-                          path_params: [id],
-                      },
+        when 'Resource'
+          @resource_instances[name] = find_association(param, @params[name])
+
+          # id reader
+          ensure_method(:"#{name}_id") do
+            @params[name] && @params[name][ param[:value_id].to_sym ]
+          end
+
+          # id writer
+          ensure_method(:"#{name}_id=") do |id|
+            @params[name] ||= {}
+            @params[name][ param[:value_id].to_sym ] = id
+
+            @resource_instances[name] = find_association(
+              param,
+              {
+                  param[:value_id] => id,
+                  :_meta => {
+                      resolved: false,
+                      # TODO: this will not work for nested resources, as they have
+                      # multiple IDs
+                      path_params: [id]
                   }
-              )
-            end
+              }
+            )
+          end
 
-            # value reader
-            ensure_method(name) do
-              @resource_instances[name] && @resource_instances[name].resolve
-            end
+          # value reader
+          ensure_method(name) do
+            @resource_instances[name] && @resource_instances[name].resolve
+          end
 
-            # value writer
-            ensure_method(:"#{name}=") do |obj|
-              @params[name] ||= {}
-              @params[name][ param[:value_id].to_sym ] = obj.method(param[:value_id]).call
-              @params[name][ param[:value_label].to_sym ] = obj.method(param[:value_label]).call
+          # value writer
+          ensure_method(:"#{name}=") do |obj|
+            @params[name] ||= {}
+            @params[name][ param[:value_id].to_sym ] = obj.method(param[:value_id]).call
+            @params[name][ param[:value_label].to_sym ] = obj.method(param[:value_label]).call
 
-              @resource_instances[name] = obj
-            end
+            @resource_instances[name] = obj
+          end
 
-          else
-            # reader
-            ensure_method(name) { @params[name] }
+        else
+          # reader
+          ensure_method(name) { @params[name] }
 
-            # writer
-            ensure_method(:"#{name}=") { |new_val| @params[name] = new_val }
+          # writer
+          ensure_method(:"#{name}=") { |new_val| @params[name] = new_val }
         end
       end
     end
 
     # Define method +name+ with +block+ if it isn't defined yet.
-    def ensure_method(name, &block)
-      define_singleton_method(name, &block) unless respond_to?(name)
+    def ensure_method(name, &)
+      define_singleton_method(name, &) unless respond_to?(name)
     end
 
     # Define nil references to resource attributes.
@@ -185,13 +184,13 @@ module HaveAPI::Client
       return ret if action.input_layout != :object
 
       action.input_params.each do |name, param|
-        case param[:type]
-          when 'Resource'
-            ret[name] = @params[name][ param[:value_id].to_sym ]
+        ret[name] = case param[:type]
+                    when 'Resource'
+                      @params[name][ param[:value_id].to_sym ]
 
-          else
-            ret[name] = @params[name]
-        end
+                    else
+                      @params[name]
+                    end
       end
 
       ret
@@ -209,13 +208,13 @@ module HaveAPI::Client
 
       # FIXME: read _meta namespace from description
       ResourceInstance.new(
-          @client,
-          @api,
-          tmp,
-          action: tmp.actions[:show],
-          resolved: res_val[:_meta][:resolved],
-          response: res_val[:_meta][:resolved] ? res_val : nil,
-          meta: res_val[:_meta]
+        @client,
+        @api,
+        tmp,
+        action: tmp.actions[:show],
+        resolved: res_val[:_meta][:resolved],
+        response: res_val[:_meta][:resolved] ? res_val : nil,
+        meta: res_val[:_meta]
       )
     end
 

data/lib/haveapi/client/resource_instance_list.rb

@@ -2,10 +2,11 @@ module HaveAPI::Client
   # A list of ResourceInstance objects.
   class ResourceInstanceList < Array
     def initialize(client, api, resource, action, response)
+      super()
       @response = response
 
       response.response.each do |hash|
-        self << ResourceInstance.new(client, api, resource, action: action, response: hash)
+        self << ResourceInstance.new(client, api, resource, action:, response: hash)
       end
     end
 

data/lib/haveapi/client/response.rb

@@ -19,10 +19,10 @@ class HaveAPI::Client::Response
 
   def response
     case @action.output_layout
-      when :object, :object_list, :hash, :hash_list
-        @response[:response][@action.namespace(:output).to_sym]
-      else
-        @response[:response]
+    when :object, :object_list, :hash, :hash_list
+      @response[:response][@action.namespace(:output).to_sym]
+    else
+      @response[:response]
     end
   end
 
@@ -44,7 +44,7 @@ class HaveAPI::Client::Response
 
   # Access namespaced params directly.
   def [](key)
-    return unless %i(object hash).include?(@action.output_layout.to_sym)
+    return unless %i[object hash].include?(@action.output_layout.to_sym)
 
     @response[:response][@action.namespace(:output).to_sym][key]
   end
@@ -52,7 +52,7 @@ class HaveAPI::Client::Response
   # Iterate over namespaced items directly. Works for only for
   # object_list or hash_list.
   def each
-    return unless %i(list).include?(@action.layout.to_sym)
+    return unless %i[list].include?(@action.layout.to_sym)
 
     @response[:response][@action.namespace(:output).to_sym].each
   end
@@ -61,10 +61,10 @@ class HaveAPI::Client::Response
   # it is regularly called with the action's state.
   #
   # @see HaveAPI::Client::Action#wait_for_completion
-  def wait_for_completion(**kwargs, &block)
+  def wait_for_completion(**, &)
     id = meta[:action_state_id]
     return nil unless id
 
-    HaveAPI::Client::Action.wait_for_completion(@action.client, id, **kwargs, &block)
+    HaveAPI::Client::Action.wait_for_completion(@action.client, id, **, &)
   end
 end

data/lib/haveapi/client/validator.rb

@@ -1,12 +1,12 @@
 module HaveAPI::Client
-  module Validators ; end
+  module Validators; end
 
   class Validator
     class << self
       def name(v)
         Validator.register(v, self)
       end
-      
+
       def register(name, klass)
         @validators ||= {}
         @validators[name] = klass
@@ -14,9 +14,9 @@ module HaveAPI::Client
 
       def validate(validators, param, other_params)
         ret = []
-        
+
         validators.each do |name, desc|
-          fail "unsupported validator '#{name}'" if @validators[name].nil?
+          raise "unsupported validator '#{name}'" if @validators[name].nil?
 
           v = @validators[name].new(desc, param, other_params)
           ret.concat(v.errors) unless v.valid?
@@ -35,7 +35,7 @@ module HaveAPI::Client
     end
 
     def errors
-      @errors || [opts[:message] % { value: value }]
+      @errors || [format(opts[:message], value:)]
     end
 
     def valid?
@@ -43,9 +43,8 @@ module HaveAPI::Client
     end
 
     protected
-    def opts
-      @opts
-    end
+
+    attr_reader :opts
 
     def error(e)
       @errors ||= []

data/lib/haveapi/client/validators/confirmation.rb

@@ -9,6 +9,7 @@ module HaveAPI::Client
 
       if opts[:equal]
         return false if params[other].nil?
+
         value == params[other].value
 
       else