rubocop 0.50.0 → 0.51.0

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

@@ -45,7 +45,7 @@ module RuboCop
         MSG = 'Use safe navigation (`&.`) instead of `%s`.'.freeze
 
         def_node_matcher :try_call, <<-PATTERN
-          (send !nil ${:try :try!} $_ ...)
+          (send !nil? ${:try :try!} $_ ...)
         PATTERN
 
         minimum_target_ruby_version 2.3
@@ -56,7 +56,7 @@ module RuboCop
             return unless method_to_try.sym_type?
             method, = *method_to_try
             return unless method =~ /\w+[=!?]?/
-            add_offense(node, :expression, format(MSG, try_method))
+            add_offense(node, message: format(MSG, try_method))
           end
         end
 

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

@@ -70,11 +70,11 @@ module RuboCop
           return unless expected_signature?(node)
           return if persisted_referenced?(assignment)
 
-          add_offense(node, :selector,
-                      format(CREATE_MSG,
-                             "#{node.method_name}!",
-                             node.method_name.to_s,
-                             node.method_name.to_s))
+          add_offense(node, location: :selector,
+                            message: format(CREATE_MSG,
+                                            "#{node.method_name}!",
+                                            node.method_name.to_s,
+                                            node.method_name.to_s))
         end
 
         def on_send(node)
@@ -84,10 +84,10 @@ module RuboCop
           return if check_used_in_conditional(node)
           return if last_call_of_method?(node)
 
-          add_offense(node, :selector,
-                      format(MSG,
-                             "#{node.method_name}!",
-                             node.method_name.to_s))
+          add_offense(node, location: :selector,
+                            message: format(MSG,
+                                            "#{node.method_name}!",
+                                            node.method_name.to_s))
         end
 
         def autocorrect(node)
@@ -121,9 +121,9 @@ module RuboCop
           return false unless conditional?(node)
 
           unless MODIFY_PERSIST_METHODS.include?(node.method_name)
-            add_offense(node, :selector,
-                        format(CREATE_CONDITIONAL_MSG,
-                               node.method_name.to_s))
+            add_offense(node, location: :selector,
+                              message: format(CREATE_CONDITIONAL_MSG,
+                                              node.method_name.to_s))
           end
 
           true

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

@@ -16,7 +16,7 @@ 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|

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

@@ -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,7 @@ 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
 
         private

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

@@ -15,13 +15,13 @@ module RuboCop
         MSG = 'The use of `eval` is a serious security risk.'.freeze
 
         def_node_matcher :eval?, <<-PATTERN
-          (send {nil (send nil :binding)} :eval $!str ...)
+          (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

@@ -26,12 +26,12 @@ module RuboCop
         MSG = 'Prefer `JSON.parse` over `JSON.%s`.'.freeze
 
         def_node_matcher :json_load, <<-PATTERN
-          (send (const {nil cbase} :JSON) ${:load :restore} ...)
+          (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))
           end
         end
 

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

@@ -22,13 +22,13 @@ module RuboCop
         MSG = 'Avoid using `Marshal.%s`.'.freeze
 
         def_node_matcher :marshal_load, <<-PATTERN
-          (send (const {nil cbase} :Marshal) ${:load :restore}
-          !(send (const {nil cbase} :Marshal) :dump ...))
+          (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))
           end
         end
       end

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

@@ -19,12 +19,12 @@ module RuboCop
         MSG = 'Prefer using `YAML.safe_load` over `YAML.load`.'.freeze
 
         def_node_matcher :yaml_load, <<-PATTERN
-          (send (const {nil cbase} :YAML) :load ...)
+          (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

@@ -39,14 +39,14 @@ module RuboCop
           return unless style == :prefer_alias && alias_keyword_possible?(node)
 
           msg = format(MSG_ALIAS_METHOD, lexical_scope_type(node))
-          add_offense(node, :selector, msg)
+          add_offense(node, location: :selector, message: msg)
         end
 
         def on_alias(node)
           return unless alias_method_possible?(node)
 
           if scope_type(node) == :dynamic || style == :prefer_alias_method
-            add_offense(node, :keyword, MSG_ALIAS)
+            add_offense(node, location: :keyword, message: MSG_ALIAS)
           elsif node.children.none? { |arg| bareword?(arg) }
             add_offense_for_args(node)
           end
@@ -79,7 +79,7 @@ module RuboCop
           arg_ranges     = node.children.map(&:source_range)
           msg            = format(MSG_SYMBOL_ARGS, preferred_args,
                                   existing_args)
-          add_offense(node, arg_ranges.reduce(&:join), msg)
+          add_offense(node, location: arg_ranges.reduce(&:join), message: msg)
         end
 
         # In this expression, will `self` be the same as the innermost enclosing

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

@@ -59,7 +59,7 @@ module RuboCop
         def process_logical_operator(node)
           return if node.logical_operator?
 
-          add_offense(node, :operator)
+          add_offense(node, location: :operator)
         end
 
         def message(node)

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

@@ -14,7 +14,7 @@ module RuboCop
         def_node_matcher :join_candidate?, '(send $array :* $str)'
 
         def on_send(node)
-          join_candidate?(node) { add_offense(node, :selector) }
+          join_candidate?(node) { add_offense(node, location: :selector) }
         end
 
         def autocorrect(node)

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

@@ -11,7 +11,7 @@ module RuboCop
         def investigate(processed_source)
           processed_source.comments.each do |comment|
             unless comment.text.ascii_only?
-              add_offense(comment, first_offense_range(comment))
+              add_offense(comment, location: first_offense_range(comment))
             end
           end
         end

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

@@ -10,7 +10,7 @@ module RuboCop
         def on_send(node)
           return unless node.command?(:attr) && node.arguments?
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
 
         private

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

@@ -32,8 +32,8 @@ module RuboCop
             next if node.parent && node.parent.block_type?
             next if node.block_argument?
 
-            add_offense(node, :expression,
-                        format(MSG, target_class, target_method))
+            add_offense(node,
+                        message: format(MSG, target_class, target_method))
           end
         end
       end

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

@@ -41,7 +41,7 @@ module RuboCop
         end
 
         def add_offense_for_wrong_style(node, good, bad)
-          add_offense(node, :begin, format(MSG, good, bad))
+          add_offense(node, location: :begin, message: format(MSG, good, bad))
         end
 
         def autocorrect(node)

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

@@ -8,7 +8,7 @@ module RuboCop
         MSG = 'Avoid the use of `BEGIN` blocks.'.freeze
 
         def on_preexe(node)
-          add_offense(node, :keyword)
+          add_offense(node, location: :keyword)
         end
       end
     end

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

@@ -25,7 +25,7 @@ module RuboCop
         def on_block(node)
           return if ignored_node?(node)
 
-          add_offense(node, :begin) unless proper_block_style?(node)
+          add_offense(node, location: :begin) unless proper_block_style?(node)
         end
 
         private

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

@@ -10,35 +10,38 @@ module RuboCop
       # * The `braces` style enforces braces around all method
       # parameters that are hashes.
       #
-      # @example
-      #   # bad
-      #   some_method(x, y, a: 1, b: 2)
+      #     ```
+      #     # bad
+      #     some_method(x, y, a: 1, b: 2)
       #
-      #   # good
-      #   some_method(x, y, {a: 1, b: 2})
+      #     # good
+      #     some_method(x, y, {a: 1, b: 2})
+      #     ```
       #
       # * The `no_braces` style checks that the last parameter doesn't
       # have braces around it.
       #
-      # @example
-      #   # bad
-      #   some_method(x, y, {a: 1, b: 2})
+      #     ```
+      #     # bad
+      #     some_method(x, y, {a: 1, b: 2})
       #
-      #   # good
-      #   some_method(x, y, a: 1, b: 2)
+      #     # good
+      #     some_method(x, y, a: 1, b: 2)
+      #     ```
       #
       # * The `context_dependent` style checks that the last parameter
       # doesn't have braces around it, but requires braces if the
       # second to last parameter is also a hash literal.
       #
-      # @example
-      #   # bad
-      #   some_method(x, y, {a: 1, b: 2})
-      #   some_method(x, y, {a: 1, b: 2}, a: 1, b: 2)
+      #     ```
+      #     # bad
+      #     some_method(x, y, {a: 1, b: 2})
+      #     some_method(x, y, {a: 1, b: 2}, a: 1, b: 2)
       #
-      #   # good
-      #   some_method(x, y, a: 1, b: 2)
-      #   some_method(x, y, {a: 1, b: 2}, {a: 1, b: 2})
+      #     # good
+      #     some_method(x, y, a: 1, b: 2)
+      #     some_method(x, y, {a: 1, b: 2}, {a: 1, b: 2})
+      #     ```
       class BracesAroundHashParameters < Cop
         include ConfigurableEnforcedStyle
 
@@ -78,8 +81,8 @@ module RuboCop
         end
 
         def add_arg_offense(arg, type)
-          add_offense(arg.parent, arg.source_range,
-                      format(MSG, type.to_s.capitalize))
+          add_offense(arg.parent, location: arg.source_range,
+                                  message: format(MSG, type.to_s.capitalize))
         end
 
         # We let AutocorrectUnlessChangingAST#autocorrect work with the send