lib/eco-rake/base/method_helpers.rb in eco-rake-0.2.6 vs lib/eco-rake/base/method_helpers.rb in eco-rake-0.2.7

@@ -5,45 +5,49 @@
       # @note missing arguments required arguments will be passed as `nil` value.
       # @return the result of the call.
       def safe_call(meth, *args, **kargs, &block)
         msg = "Expecting Method or Proc. Given: #{meth.class}"
         raise ArgumentError, msg unless [Method, Proc].any? {|c| meth.is_a?(c)}
+
         aux_curry(meth, :safe).call(*args, **kargs, &block)
       end
 
       # @param meth [Method, Proc, Lambda]
       # @param on_missing [Symbol] what should do when there are missing parameters
       #   - `:curry`   -> it does a curry with the parameters received (default)
       #   - `:call`    -> it calls anyway (will error).
       #   - `:safe`    -> it sets to `nil` the missing required arguments and does a call.
       #   - `:return`  -> it returns `nil` but doesn't call.
       # @return [Lambda, NilClass, Result]
-      def aux_curry(meth, on_missing = :curry)
+      def aux_curry(meth, on_missing = :curry) # rubocop:disable Metrics/AbcSize
         lambda do |*args, **kargs, &block|
           params    = meth.parameters
           kparams   = params.select  { |type, _| (type == :keyreq) || (type == :key) }
           aparams   = params.select  { |type, _| (type == :req)    || (type == :opt) }
 
           kreq_miss = kparams.select { |type, _| type == :keyreq }.map(&:last) - kargs.keys
           req_miss  = aparams.select { |type, _| type == :req    }.count       - args.count
-          req_miss  = req_miss >= 0 ? req_miss : 0
+          req_miss  = [req_miss, 0].max
           ready     = kreq_miss.empty? && req_miss.zero?
 
           if on_missing == :safe
             argrest = params.find { |type, _| type == :rest }
             keyrest = params.find { |type, _| type == :keyrest }
             kextras = kargs.keys - kparams.map(&:last)
             kextras.each { |name| kargs.delete(name) } unless keyrest
             args = args[0..(aparams.count-1)]          unless argrest || args.count <= aparams.count
+
             unless ready
               kreq_miss.each { |name| kargs[name] = nil }
               ary_nil = Array.new(req_miss, nil)
               args    = args.dup.push(*ary_nil)
               ready   = true
             end
           end
+
           return meth.call(*args, **kargs, &block) if ready || on_missing == :call
-          return nil                               if on_missing == :return
+          return                                   if on_missing == :return
+
           # (default) on_missing == :curry
           lambda do |*oth, **koth, &blk|
             curried = aux_curry(meth, on_missing)
             curried[*args, *oth, **kargs, **koth, &(blk || block)]
           end