rubocop 0.47.1 → 0.48.0

data/lib/rubocop/cop/rails/dynamic_find_by.rb

@@ -30,19 +30,23 @@ module RuboCop
         METHOD_PATTERN = /^find_by_(.+?)(!)?$/
 
         def on_send(node)
-          _receiver, method, _args = *node
-          method_name = method.to_s
+          method_name = node.method_name.to_s
+
           return if whitelist.include?(method_name)
+
           static_name = static_method_name(method_name)
+
           return unless static_name
 
-          add_offense(node, :expression, format(MSG, static_name, method))
+          add_offense(node, :expression,
+                      format(MSG, static_name, node.method_name))
         end
 
         def autocorrect(node)
           _receiver, method, *args = *node
           static_name = static_method_name(method.to_s)
           keywords = column_keywords(method)
+
           return if keywords.size != args.size
 
           lambda do |corrector|

data/lib/rubocop/cop/rails/exit.rb

@@ -20,8 +20,8 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         MSG = 'Do not use `exit` in Rails applications.'.freeze
-        TARGET_METHODS = [:exit, :exit!].freeze
-        EXPLICIT_RECEIVERS = [:Kernel, :Process].freeze
+        TARGET_METHODS = %i(exit exit!).freeze
+        EXPLICIT_RECEIVERS = %i(Kernel Process).freeze
 
         def on_send(node)
           add_offense(node, :selector) if offending_node?(node)
@@ -30,11 +30,9 @@ module RuboCop
         private
 
         def offending_node?(node)
-          receiver_node, method_name, *arg_nodes = *node
-
-          right_method_name?(method_name) &&
-            right_argument_count?(arg_nodes) &&
-            right_receiver?(receiver_node)
+          right_method_name?(node.method_name) &&
+            right_argument_count?(node.arguments) &&
+            right_receiver?(node.receiver)
         end
 
         def right_method_name?(method_name)
@@ -44,15 +42,17 @@ module RuboCop
         # More than 1 argument likely means it is a different
         # `exit` implementation than the one we are preventing.
         def right_argument_count?(arg_nodes)
-          arg_nodes.length <= 1
+          arg_nodes.size <= 1
         end
 
         # Only register if exit is being called explicitly on
         # Kernel or Process or if receiver node is nil for plain
         # `exit` calls.
         def right_receiver?(receiver_node)
-          return true if receiver_node.nil?
+          return true unless receiver_node
+
           _a, receiver_node_class, _c = *receiver_node
+
           EXPLICIT_RECEIVERS.include?(receiver_node_class)
         end
       end

data/lib/rubocop/cop/rails/file_path.rb

@@ -17,11 +17,7 @@ module RuboCop
       class FilePath < Cop
         MSG = 'Please use `Rails.root.join(\'path\', \'to\')` instead.'.freeze
 
-        def_node_search :file_join_nodes, <<-PATTERN
-          (send (const nil :File) :join ...)
-        PATTERN
-
-        def_node_search :file_join_nodes?, <<-PATTERN
+        def_node_matcher :file_join_nodes?, <<-PATTERN
           (send (const nil :File) :join ...)
         PATTERN
 
@@ -29,7 +25,7 @@ module RuboCop
           (send (const nil :Rails) :root)
         PATTERN
 
-        def_node_search :rails_root_join_nodes, <<-PATTERN
+        def_node_matcher :rails_root_join_nodes?, <<-PATTERN
           (send (send (const nil :Rails) :root) :join ...)
         PATTERN
 
@@ -47,20 +43,15 @@ module RuboCop
 
         def check_for_file_join_with_rails_root(node)
           return unless file_join_nodes?(node)
-          return unless file_join_nodes(node).map(&:method_args)
-                                             .flatten
-                                             .any? { |e| rails_root_nodes?(e) }
+          return unless node.method_args.any? { |e| rails_root_nodes?(e) }
 
           register_offense(node)
         end
 
         def check_for_rails_root_join_with_slash_separated_path(node)
           return unless rails_root_nodes?(node)
-          return unless rails_root_join_nodes(node).map(&:method_args)
-                                                   .flatten
-                                                   .any? do |arg|
-                                                     arg.source =~ %r{/}
-                                                   end
+          return unless rails_root_join_nodes?(node)
+          return unless node.method_args.any? { |arg| arg.source =~ %r{/} }
 
           register_offense(node)
         end

data/lib/rubocop/cop/rails/find_by.rb

@@ -15,30 +15,28 @@ module RuboCop
       #   User.find_by(name: 'Bruce')
       class FindBy < Cop
         MSG = 'Use `find_by` instead of `where.%s`.'.freeze
-        TARGET_SELECTORS = [:first, :take].freeze
+        TARGET_SELECTORS = %i(first take).freeze
 
-        def_node_matcher :where_first, <<-PATTERN
-          (send $(send _ :where ...) ${:first :take})
+        def_node_matcher :where_first?, <<-PATTERN
+          (send (send _ :where ...) {:first :take})
         PATTERN
 
         def on_send(node)
-          return unless (recv_and_method = where_first(node))
-          receiver, second_method = *recv_and_method
+          return unless where_first?(node)
 
-          range = range_between(receiver.loc.selector.begin_pos,
+          range = range_between(node.receiver.loc.selector.begin_pos,
                                 node.loc.selector.end_pos)
 
-          add_offense(node, range, format(MSG, second_method))
+          add_offense(node, range, format(MSG, node.method_name))
         end
 
         def autocorrect(node)
-          receiver, second_method = where_first(node)
           # Don't autocorrect where(...).first, because it can return different
           # results from find_by. (They order records differently, so the
           # 'first' record can be different.)
-          return if second_method == :first
+          return if node.method?(:first)
 
-          where_loc = receiver.loc.selector
+          where_loc = node.receiver.loc.selector
           first_loc = range_between(node.loc.dot.begin_pos,
                                     node.loc.selector.end_pos)
 

data/lib/rubocop/cop/rails/find_each.rb

@@ -15,23 +15,20 @@ module RuboCop
       class FindEach < Cop
         MSG = 'Use `find_each` instead of `each`.'.freeze
 
-        SCOPE_METHODS = [:all, :where, :not].freeze
+        SCOPE_METHODS = %i(all where not).freeze
+        IGNORED_METHODS = %i(order limit select).freeze
 
         def on_send(node)
-          receiver, method, _selector = *node
-          return unless receiver && method == :each
+          return unless node.receiver && node.method?(:each)
 
-          _model, preceding_method = *receiver
-          return unless SCOPE_METHODS.include?(preceding_method)
+          return unless SCOPE_METHODS.include?(node.receiver.method_name)
           return if method_chain(node).any? { |m| ignored_by_find_each?(m) }
 
           add_offense(node, node.loc.selector, MSG)
         end
 
         def autocorrect(node)
-          each_loc = node.loc.selector
-
-          ->(corrector) { corrector.replace(each_loc, 'find_each') }
+          ->(corrector) { corrector.replace(node.loc.selector, 'find_each') }
         end
 
         private
@@ -42,7 +39,7 @@ module RuboCop
 
         def ignored_by_find_each?(relation_method)
           # Active Record's #find_each ignores various extra parameters
-          [:order, :limit, :select].include?(relation_method)
+          IGNORED_METHODS.include?(relation_method)
         end
       end
     end

data/lib/rubocop/cop/rails/has_and_belongs_to_many.rb

@@ -9,6 +9,7 @@ module RuboCop
 
         def on_send(node)
           return unless node.command?(:has_and_belongs_to_many)
+
           add_offense(node, :selector)
         end
       end

data/lib/rubocop/cop/rails/http_positional_arguments.rb

@@ -5,7 +5,10 @@ module RuboCop
     module Rails
       # This cop is used to identify usages of http methods like `get`, `post`,
       # `put`, `patch` without the usage of keyword arguments in your tests and
-      # change them to use keyword arguments.
+      # change them to use keyword args.  This cop only applies to Rails >= 5 .
+      # If you are not running Rails < 5 you should disable # the
+      # Rails/HttpPositionalArguments cop or set your TargetRailsVersion in your
+      # .rubocop.yml file to 4.0, etc.
       #
       # @example
       #   # bad
@@ -14,12 +17,16 @@ module RuboCop
       #   # good
       #   get :new, params: { user_id: 1 }
       class HttpPositionalArguments < Cop
+        extend TargetRailsVersion
+
         MSG = 'Use keyword arguments instead of ' \
               'positional arguments for http call: `%s`.'.freeze
-        KEYWORD_ARGS = [
-          :headers, :env, :params, :body, :flash, :as, :xhr, :session, :method
-        ].freeze
-        HTTP_METHODS = [:get, :post, :put, :patch, :delete, :head].freeze
+        KEYWORD_ARGS = %i(
+          headers env params body flash as xhr session method
+        ).freeze
+        HTTP_METHODS = %i(get post put patch delete head).freeze
+
+        minimum_target_rails_version 5.0
 
         def_node_matcher :http_request?, <<-END
           (send nil {#{HTTP_METHODS.map(&:inspect).join(' ')}} !nil $_data ...)
@@ -80,7 +87,8 @@ module RuboCop
         # the data is the http parameters and environment sent in
         # the Rails 5 http call
         def autocorrect(node)
-          _receiver, http_method, http_path, *data = *node
+          http_path, *data = *node.arguments
+
           controller_action = http_path.source
           params = convert_hash_data(data.first, 'params')
           headers = convert_hash_data(data.last, 'headers') if data.size > 1
@@ -88,7 +96,7 @@ module RuboCop
           code_to_replace = node.loc.expression
           # what to replace with
           format = parentheses?(node) ? '%s(%s%s%s)' : '%s %s%s%s'
-          new_code = format(format, http_method, controller_action,
+          new_code = format(format, node.method_name, controller_action,
                             params, headers)
           ->(corrector) { corrector.replace(code_to_replace, new_code) }
         end

data/lib/rubocop/cop/rails/output.rb

@@ -9,15 +9,13 @@ module RuboCop
               "Use Rails's logger if you want to log.".freeze
 
         def_node_matcher :output?, <<-PATTERN
-          (send nil {:ap :p :pp :pretty_print :print :puts} $...)
+          (send nil {:ap :p :pp :pretty_print :print :puts} ...)
         PATTERN
 
         def on_send(node)
-          output?(node) do |args|
-            return if args.empty?
+          return unless output?(node) && node.arguments?
 
-            add_offense(node, :selector)
-          end
+          add_offense(node, :selector)
         end
       end
     end

data/lib/rubocop/cop/rails/output_safety.rb

@@ -30,8 +30,8 @@ module RuboCop
               'prefer `safe_join` or other Rails tag helpers instead.'.freeze
 
         def on_send(node)
-          _receiver, method_name, *_args = *node
-          ignore_node(node) if method_name == :safe_join
+          ignore_node(node) if node.method?(:safe_join)
+
           return unless !part_of_ignored_node?(node) &&
                         (looks_like_rails_html_safe?(node) ||
                         looks_like_rails_raw?(node))
@@ -42,15 +42,11 @@ module RuboCop
         private
 
         def looks_like_rails_html_safe?(node)
-          receiver, method_name, *args = *node
-
-          receiver && method_name == :html_safe && args.empty?
+          node.receiver && node.method?(:html_safe) && !node.arguments?
         end
 
         def looks_like_rails_raw?(node)
-          receiver, method_name, *args = *node
-
-          receiver.nil? && method_name == :raw && args.one?
+          node.command?(:raw) && node.arguments.one?
         end
       end
     end

data/lib/rubocop/cop/rails/pluralization_grammar.rb

@@ -29,42 +29,43 @@ module RuboCop
         MSG = 'Prefer `%s.%s`.'.freeze
 
         def on_send(node)
-          receiver, method_name, *_args = *node
-          return unless duration_method?(method_name)
-          return unless literal_number?(receiver)
-
-          number, = *receiver
-          if expect_singular_method?(number, method_name)
-            add_offense(node,
-                        :expression,
-                        format(MSG, number, singularize(method_name)))
-          elsif expect_plural_method?(number, method_name)
-            add_offense(node,
-                        :expression,
-                        format(MSG, number, pluralize(method_name)))
-          end
+          return unless duration_method?(node.method_name)
+          return unless literal_number?(node.receiver)
+
+          return unless offense?(node)
+
+          add_offense(node, :expression)
         end
 
         private
 
+        def message(node)
+          number, = *node.receiver
+
+          format(MSG, number, correct_method(node.method_name.to_s))
+        end
+
         def autocorrect(node)
           lambda do |corrector|
             method_name = node.loc.selector.source
-            replacement = if plural_method?(method_name)
-                            singularize(method_name)
-                          else
-                            pluralize(method_name)
-                          end
-            corrector.replace(node.loc.selector, replacement)
+
+            corrector.replace(node.loc.selector, correct_method(method_name))
           end
         end
 
-        def expect_singular_method?(number, method_name)
-          singular_receiver?(number) && plural_method?(method_name)
+        def correct_method(method_name)
+          if plural_method?(method_name)
+            singularize(method_name)
+          else
+            pluralize(method_name)
+          end
         end
 
-        def expect_plural_method?(number, method_name)
-          plural_receiver?(number) && singular_method?(method_name)
+        def offense?(node)
+          number, = *node.receiver
+
+          singular_receiver?(number) && plural_method?(node.method_name) ||
+            plural_receiver?(number) && singular_method?(node.method_name)
         end
 
         def plural_method?(method_name)

data/lib/rubocop/cop/rails/present.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cops checks for code that can be changed to `blank?`.
+      # Settings:
+      #   NotNilAndNotEmpty: Convert checks for not `nil` and `not empty?`
+      #                      to `present?`
+      #   NotBlank: Convert usages of not `blank?` to `present?`
+      #   UnlessBlank: Convert usages of `unless` `blank?` to `if` `present?`
+      #
+      # @example
+      #   # NotNilAndNotEmpty: true
+      #     # bad
+      #     !foo.nil? && !foo.empty?
+      #     foo != nil && !foo.empty?
+      #     !foo.blank?
+      #
+      #     # good
+      #     foo.present?
+      #
+      #   # NotBlank: true
+      #     # bad
+      #     !foo.blank?
+      #     not foo.blank?
+      #
+      #     # good
+      #     foo.present?
+      #
+      #   # UnlessBlank: true
+      #     # bad
+      #     something unless foo.blank?
+      #
+      #     # good
+      #     something if  foo.present?
+      class Present < Cop
+        MSG_NOT_BLANK = 'Use `%s.present?` instead of `%s`.'.freeze
+        MSG_EXISTS_AND_NOT_EMPTY = 'Use `%s.present?` instead of `%s`.'.freeze
+        MSG_UNLESS_BLANK = 'Use `if %s.present?` instead of `%s`.'.freeze
+
+        def_node_matcher :exists_and_not_empty?, <<-PATTERN
+          (and
+              {
+                (send (send $_ :nil?) :!)
+                (send (send $_ :!) :!)
+                (send $_ :!= (:nil))
+                $_
+              }
+              {
+                (send (send $_ :empty?) :!)
+              }
+          )
+        PATTERN
+
+        def_node_matcher :not_blank?, '(send (send $_ :blank?) :!)'
+
+        def_node_matcher :unless_blank?, <<-PATTERN
+          (:if $(send $_ :blank?) {nil (...)} ...)
+        PATTERN
+
+        def on_send(node)
+          return unless cop_config['NotBlank']
+
+          not_blank?(node) do |receiver|
+            add_offense(node,
+                        :expression,
+                        format(MSG_NOT_BLANK, receiver.source, node.source))
+          end
+        end
+
+        def on_and(node)
+          return unless cop_config['NotNilAndNotEmpty']
+
+          exists_and_not_empty?(node) do |variable1, variable2|
+            return unless variable1 == variable2
+
+            add_offense(node,
+                        :expression,
+                        format(MSG_EXISTS_AND_NOT_EMPTY,
+                               variable1.source,
+                               node.source))
+          end
+        end
+
+        def on_or(node)
+          return unless cop_config['NilOrEmpty']
+
+          exists_and_not_empty?(node) do |variable1, variable2|
+            return unless variable1 == variable2
+
+            add_offense(node, :expression, MSG_EXISTS_AND_NOT_EMPTY)
+          end
+        end
+
+        def on_if(node)
+          return unless cop_config['UnlessBlank']
+          return unless node.unless?
+
+          unless_blank?(node) do |method_call, receiver|
+            range = unless_condition(node, method_call)
+            add_offense(node,
+                        range,
+                        format(MSG_UNLESS_BLANK, receiver.source, range.source))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            method_call, variable1 = unless_blank?(node)
+
+            if method_call && variable1
+              corrector.replace(node.loc.keyword, 'if')
+              range = method_call.loc.expression
+            else
+              variable1, _variable2 =
+                exists_and_not_empty?(node) || not_blank?(node)
+              range = node.loc.expression
+            end
+
+            corrector.replace(range, "#{variable1.source}.present?")
+          end
+        end
+
+        private
+
+        def unless_condition(node, method_call)
+          if node.modifier_form?
+            node.loc.keyword.join(node.loc.expression.end)
+          else
+            node.loc.expression.begin.join(method_call.loc.expression)
+          end
+        end
+      end
+    end
+  end
+end