rubocop 0.49.1 → 0.52.0

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

@@ -16,11 +16,11 @@ module RuboCop
       class ScopeArgs < Cop
         MSG = 'Use `lambda`/`proc` instead of a plain method call.'.freeze
 
-        def_node_matcher :scope?, '(send nil :scope _ $send)'
+        def_node_matcher :scope?, '(send nil? :scope _ $send)'
 
         def on_send(node)
           scope?(node) do |second_arg|
-            add_offense(second_arg, :expression)
+            add_offense(second_arg)
           end
         end
       end

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

@@ -38,7 +38,7 @@ module RuboCop
                                     update_counters].freeze
 
         def_node_matcher :good_touch?, <<-PATTERN
-          (send (const nil :FileUtils) :touch ...)
+          (send (const nil? :FileUtils) :touch ...)
         PATTERN
 
         def on_send(node)
@@ -52,7 +52,7 @@ module RuboCop
 
           return if good_touch?(node)
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
 
         private

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

@@ -74,7 +74,7 @@ module RuboCop
 
           message = build_message(klass, method_name, node)
 
-          add_offense(node, :selector, message)
+          add_offense(node, location: :selector, message: message)
         end
 
         def build_message(klass, method_name, node)
@@ -148,7 +148,8 @@ module RuboCop
 
           return if node.arguments?
 
-          add_offense(selector_node, :selector, MSG_LOCALTIME)
+          add_offense(selector_node,
+                      location: :selector, message: MSG_LOCALTIME)
         end
 
         def danger_chain?(chain)

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

@@ -26,7 +26,7 @@ module RuboCop
       #
       # @example
       #   # this will return a Relation that pluck is called on
-      #   Model.where(...).pluck(:id).uniq
+      #   Model.where(cond: true).pluck(:id).uniq
       #
       #   # an association on an instance will return a CollectionProxy
       #   instance.assoc.pluck(:id).uniq
@@ -55,7 +55,9 @@ module RuboCop
                      aggressive_node_match(node)
                    end
 
-          add_offense(node, :selector, format(MSG, method)) if method
+          return unless method
+
+          add_offense(node, location: :selector, message: format(MSG, method))
         end
 
         def autocorrect(node)

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks that environments called with `Rails.env` predicates
+      # exist.
+      #
+      # @example
+      #   # bad
+      #   Rails.env.proudction?
+      #
+      #   # good
+      #   Rails.env.production?
+      class UnknownEnv < Cop
+        include NameSimilarity
+
+        MSG = 'Unknown environment `%<name>s`.'.freeze
+        MSG_SIMILAR = 'Unknown environment `%<name>s`. ' \
+                      'Did you mean `%<similar>s`?'.freeze
+
+        def_node_matcher :unknown_environment?, <<-PATTERN
+          (send
+            (send
+              {(const nil? :Rails) (const (cbase) :Rails)}
+              :env)
+            $#unknown_env_name?)
+        PATTERN
+
+        def on_send(node)
+          unknown_environment?(node) do |name|
+            add_offense(node, location: :selector, message: message(name))
+          end
+        end
+
+        private
+
+        def collect_variable_like_names(_scope)
+          environments.map { |env| env + '?' }
+        end
+
+        def message(name)
+          similar = find_similar_name(name.to_s, [])
+          if similar
+            format(MSG_SIMILAR, name: name, similar: similar)
+          else
+            format(MSG, name: name)
+          end
+        end
+
+        def unknown_env_name?(name)
+          name = name.to_s
+          name.end_with?('?') &&
+            !environments.include?(name[0..-2])
+        end
+
+        def environments
+          cop_config['Environments']
+        end
+      end
+    end
+  end
+end

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

@@ -26,7 +26,14 @@ module RuboCop
         def on_send(node)
           return unless !node.receiver && BLACKLIST.include?(node.method_name)
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.selector, 'validates')
+            correct_validate_type(corrector, node)
+          end
         end
 
         private
@@ -39,13 +46,6 @@ module RuboCop
           WHITELIST[BLACKLIST.index(method.to_sym)]
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector, 'validates')
-            correct_validate_type(corrector, node)
-          end
-        end
-
         def correct_validate_type(corrector, node)
           options = node.arguments.find { |arg| !arg.sym_type? }
           validate_type = node.method_name.to_s.split('_')[1]

data/lib/rubocop/cop/registry.rb

@@ -156,7 +156,8 @@ module RuboCop
 
       def resolve_badge(given_badge, real_badge, source_path)
         unless given_badge.match?(real_badge)
-          warn "#{source_path}: #{given_badge} has the wrong namespace - " \
+          path = PathUtil.smart_path(source_path)
+          warn "#{path}: #{given_badge} has the wrong namespace - " \
                "should be #{real_badge.department}"
         end
 

data/lib/rubocop/cop/security/eval.rb

@@ -14,14 +14,14 @@ module RuboCop
       class Eval < Cop
         MSG = 'The use of `eval` is a serious security risk.'.freeze
 
-        def_node_matcher :eval?, <<-END
-          (send {nil (send nil :binding)} :eval $!str ...)
-        END
+        def_node_matcher :eval?, <<-PATTERN
+          (send {nil? (send nil? :binding)} :eval $!str ...)
+        PATTERN
 
         def on_send(node)
           eval?(node) do |code|
             return if code.dstr_type? && code.recursive_literal?
-            add_offense(node, :selector)
+            add_offense(node, location: :selector)
           end
         end
       end

data/lib/rubocop/cop/security/json_load.rb

@@ -23,15 +23,17 @@ module RuboCop
       #   JSON.parse("{}")
       #
       class JSONLoad < Cop
-        MSG = 'Prefer `JSON.parse` over `JSON.%s`.'.freeze
+        MSG = 'Prefer `JSON.parse` over `JSON.%<method>s`.'.freeze
 
-        def_node_matcher :json_load, <<-END
-          (send (const {nil cbase} :JSON) ${:load :restore} ...)
-        END
+        def_node_matcher :json_load, <<-PATTERN
+          (send (const {nil? cbase} :JSON) ${:load :restore} ...)
+        PATTERN
 
         def on_send(node)
           json_load(node) do |method|
-            add_offense(node, :selector, format(MSG, method))
+            add_offense(node,
+                        location: :selector,
+                        message: format(MSG, method: method))
           end
         end
 

data/lib/rubocop/cop/security/marshal_load.rb

@@ -19,16 +19,18 @@ module RuboCop
       #   Marshal.load(Marshal.dump({}))
       #
       class MarshalLoad < Cop
-        MSG = 'Avoid using `Marshal.%s`.'.freeze
+        MSG = 'Avoid using `Marshal.%<method>s`.'.freeze
 
-        def_node_matcher :marshal_load, <<-END
-          (send (const {nil cbase} :Marshal) ${:load :restore}
-          !(send (const {nil cbase} :Marshal) :dump ...))
-        END
+        def_node_matcher :marshal_load, <<-PATTERN
+          (send (const {nil? cbase} :Marshal) ${:load :restore}
+          !(send (const {nil? cbase} :Marshal) :dump ...))
+        PATTERN
 
         def on_send(node)
           marshal_load(node) do |method|
-            add_offense(node, :selector, format(MSG, method))
+            add_offense(node,
+                        location: :selector,
+                        message: format(MSG, method: method))
           end
         end
       end

data/lib/rubocop/cop/security/yaml_load.rb

@@ -18,13 +18,13 @@ module RuboCop
       class YAMLLoad < Cop
         MSG = 'Prefer using `YAML.safe_load` over `YAML.load`.'.freeze
 
-        def_node_matcher :yaml_load, <<-END
-          (send (const {nil cbase} :YAML) :load ...)
-        END
+        def_node_matcher :yaml_load, <<-PATTERN
+          (send (const {nil? cbase} :YAML) :load ...)
+        PATTERN
 
         def on_send(node)
           yaml_load(node) do
-            add_offense(node, :selector)
+            add_offense(node, location: :selector)
           end
         end
 

data/lib/rubocop/cop/style/alias.rb

@@ -3,49 +3,52 @@
 module RuboCop
   module Cop
     module Style
-      # This cop finds uses of `alias` where `alias_method` would be more
-      # appropriate (or is simply preferred due to configuration), and vice
-      # versa.
-      # It also finds uses of `alias :symbol` rather than `alias bareword`.
+      # This cop enforces the use of either `#alias` or `#alias_method`
+      # depending on configuration.
+      # It also flags uses of `alias :symbol` rather than `alias bareword`.
+      #
+      # @example EnforcedStyle: prefer_alias (default)
+      #   # bad
+      #   alias_method :bar, :foo
+      #   alias :bar :foo
+      #
+      #   # good
+      #   alias bar foo
+      #
+      # @example EnforcedStyle: prefer_alias_method
+      #   # bad
+      #   alias :bar :foo
+      #   alias bar foo
+      #
+      #   # good
+      #   alias_method :bar, :foo
       class Alias < Cop
         include ConfigurableEnforcedStyle
 
         MSG_ALIAS = 'Use `alias_method` instead of `alias`.'.freeze
-        MSG_ALIAS_METHOD = 'Use `alias` instead of `alias_method` %s.'.freeze
-        MSG_SYMBOL_ARGS  = 'Use `alias %s` instead of `alias %s`.'.freeze
+        MSG_ALIAS_METHOD = 'Use `alias` instead of `alias_method` ' \
+                           '%<current>s.'.freeze
+        MSG_SYMBOL_ARGS  = 'Use `alias %<prefer>s` instead of ' \
+                           '`alias %<current>s`.'.freeze
 
         def on_send(node)
           return unless node.command?(:alias_method)
-          return if style == :prefer_alias_method
-          return if scope_type(node) == :dynamic
+          return unless style == :prefer_alias && alias_keyword_possible?(node)
 
-          msg = format(MSG_ALIAS_METHOD, lexical_scope_type(node))
-          add_offense(node, :selector, msg)
+          msg = format(MSG_ALIAS_METHOD, current: lexical_scope_type(node))
+          add_offense(node, location: :selector, message: msg)
         end
 
         def on_alias(node)
-          # alias_method can't be used with global variables
-          return if node.each_child_node(:gvar).any?
-          # alias_method can't be used in instance_eval blocks
-          scope_type = scope_type(node)
-          return if scope_type == :instance_eval
-
-          if scope_type == :dynamic || style == :prefer_alias_method
-            add_offense(node, :keyword, MSG_ALIAS)
+          return unless alias_method_possible?(node)
+
+          if scope_type(node) == :dynamic || style == :prefer_alias_method
+            add_offense(node, location: :keyword, message: MSG_ALIAS)
           elsif node.children.none? { |arg| bareword?(arg) }
             add_offense_for_args(node)
           end
         end
 
-        def add_offense_for_args(node)
-          existing_args  = node.children.map(&:source).join(' ')
-          preferred_args = node.children.map { |a| a.source[1..-1] }.join(' ')
-          arg_ranges     = node.children.map(&:source_range)
-          msg            = format(MSG_SYMBOL_ARGS, preferred_args,
-                                  existing_args)
-          add_offense(node, arg_ranges.reduce(&:join), msg)
-        end
-
         def autocorrect(node)
           if node.send_type?
             correct_alias_method_to_alias(node)
@@ -58,6 +61,25 @@ module RuboCop
 
         private
 
+        def alias_keyword_possible?(node)
+          scope_type(node) != :dynamic && node.arguments.all?(&:sym_type?)
+        end
+
+        def alias_method_possible?(node)
+          scope_type(node) != :instance_eval &&
+            node.children.none?(&:gvar_type?)
+        end
+
+        def add_offense_for_args(node)
+          existing_args  = node.children.map(&:source).join(' ')
+          preferred_args = node.children.map { |a| a.source[1..-1] }.join(' ')
+          arg_ranges     = node.children.map(&:source_range)
+          msg            = format(MSG_SYMBOL_ARGS,
+                                  prefer: preferred_args,
+                                  current: existing_args)
+          add_offense(node, location: arg_ranges.reduce(&:join), message: msg)
+        end
+
         # In this expression, will `self` be the same as the innermost enclosing
         # class or module block (:lexical)? Or will it be something else
         # (:dynamic)? If we're in an instance_eval block, return that.

data/lib/rubocop/cop/style/and_or.rb

@@ -3,85 +3,105 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of *and* and *or*.
+      # This cop checks for uses of `and` and `or`, and suggests using `&&` and
+      # `|| instead`. It can be configured to check only in conditions, or in
+      # all contexts.
+      #
+      # @example EnforcedStyle: always (default)
+      #   # bad
+      #   foo.save and return
+      #
+      #   # bad
+      #   if foo and bar
+      #   end
+      #
+      #   # good
+      #   foo.save && return
+      #
+      #   # good
+      #   if foo && bar
+      #   end
+      #
+      # @example EnforcedStyle: conditionals
+      #   # bad
+      #   if foo and bar
+      #   end
+      #
+      #   # good
+      #   foo.save && return
+      #
+      #   # good
+      #   foo.save and return
+      #
+      #   # good
+      #   if foo && bar
+      #   end
       class AndOr < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Use `%s` instead of `%s`.'.freeze
-
-        OPS = { 'and' => '&&', 'or' => '||' }.freeze
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
 
         def on_and(node)
-          process_logical_op(node) if style == :always
-        end
-
-        def on_or(node)
-          process_logical_op(node) if style == :always
+          process_logical_operator(node) if style == :always
         end
+        alias on_or on_and
 
         def on_if(node)
           on_conditionals(node) if style == :conditionals
         end
+        alias on_while      on_if
+        alias on_while_post on_if
+        alias on_until      on_if
+        alias on_until_post on_if
 
-        def on_while(node)
-          on_conditionals(node) if style == :conditionals
-        end
-
-        def on_while_post(node)
-          on_conditionals(node) if style == :conditionals
-        end
-
-        def on_until(node)
-          on_conditionals(node) if style == :conditionals
-        end
+        def autocorrect(node)
+          lambda do |corrector|
+            node.each_child_node do |expr|
+              if expr.send_type?
+                correct_send(expr, corrector)
+              elsif expr.return_type?
+                correct_other(expr, corrector)
+              elsif expr.assignment?
+                correct_other(expr, corrector)
+              end
+            end
 
-        def on_until_post(node)
-          on_conditionals(node) if style == :conditionals
+            corrector.replace(node.loc.operator, node.alternate_operator)
+          end
         end
 
         private
 
         def on_conditionals(node)
           node.condition.each_node(*LOGICAL_OPERATOR_NODES) do |logical_node|
-            process_logical_op(logical_node)
+            process_logical_operator(logical_node)
           end
         end
 
-        def process_logical_op(node)
+        def process_logical_operator(node)
           return if node.logical_operator?
 
-          add_offense(node, :operator,
-                      format(MSG, node.alternate_operator, node.operator))
+          add_offense(node, location: :operator)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            [*node].each do |expr|
-              if expr.send_type?
-                correct_send(expr, corrector)
-              elsif expr.return_type?
-                correct_other(expr, corrector)
-              elsif expr.assignment?
-                correct_other(expr, corrector)
-              end
-            end
-
-            corrector.replace(node.loc.operator, node.alternate_operator)
-          end
+        def message(node)
+          format(MSG, prefer: node.alternate_operator, current: node.operator)
         end
 
         def correct_send(node, corrector)
           return correct_not(node, node.receiver, corrector) if node.method?(:!)
           return correct_setter(node, corrector) if node.setter_method?
+          return correct_other(node, corrector) if node.comparison_method?
+
           return unless correctable_send?(node)
 
-          corrector.replace(whitespace_before_arg(node), '('.freeze)
-          corrector.insert_after(node.last_argument.source_range, ')'.freeze)
+          corrector.replace(whitespace_before_arg(node), '(')
+          corrector.insert_after(node.last_argument.source_range, ')')
         end
 
         def correct_setter(node, corrector)
-          corrector.insert_before(node.receiver.source_range, '('.freeze)
-          corrector.insert_after(node.last_argument.source_range, ')'.freeze)
+          corrector.insert_before(node.receiver.source_range, '(')
+          corrector.insert_after(node.last_argument.source_range, ')')
         end
 
         # ! is a special case:
@@ -108,7 +128,7 @@ module RuboCop
         end
 
         def correctable_send?(node)
-          !node.parenthesized? && !node.method?(:[]) && node.arguments?
+          !node.parenthesized? && node.arguments? && !node.method?(:[])
         end
 
         def whitespace_before_arg(node)