rubocop 0.85.1 → 0.89.0

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

@@ -21,8 +21,8 @@ module RuboCop
               "file's directory."
 
         def_node_matcher :dir_replacement?, <<~PATTERN
-          {(send (const nil? :File) :expand_path (send (const nil? :File) :dirname  #file_keyword?))
-           (send (const nil? :File) :dirname     (send (const nil? :File) :realpath #file_keyword?))}
+          {(send (const {nil? cbase} :File) :expand_path (send (const {nil? cbase} :File) :dirname  #file_keyword?))
+           (send (const {nil? cbase} :File) :dirname     (send (const {nil? cbase} :File) :realpath #file_keyword?))}
         PATTERN
 
         def on_send(node)

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

@@ -41,7 +41,7 @@ module RuboCop
         private
 
         def rubocop_directive_comment?(comment)
-          comment.text =~ CommentConfig::COMMENT_DIRECTIVE_REGEXP
+          CommentConfig::COMMENT_DIRECTIVE_REGEXP.match?(comment.text)
         end
       end
     end

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

@@ -104,7 +104,7 @@ module RuboCop
         end
 
         def compact_namespace?(node)
-          node.loc.name.source =~ /::/
+          /::/.match?(node.loc.name.source)
         end
 
         # First checks if the :nodoc: comment is associated with the
@@ -112,18 +112,18 @@ module RuboCop
         # proceeds to check its ancestors for :nodoc: all.
         # Note: How end-of-line comments are associated with code changed in
         # parser-2.2.0.4.
-        def nodoc_comment?(node, require_all = false)
+        def nodoc_comment?(node, require_all: false)
           return false unless node&.children&.first
 
           nodoc = nodoc(node)
 
-          return true if same_line?(nodoc, node) && nodoc?(nodoc, require_all)
+          return true if same_line?(nodoc, node) && nodoc?(nodoc, require_all: require_all)
 
-          nodoc_comment?(node.parent, true)
+          nodoc_comment?(node.parent, require_all: true)
         end
 
-        def nodoc?(comment, require_all = false)
-          comment.text =~ /^#\s*:nodoc:#{"\s+all\s*$" if require_all}/
+        def nodoc?(comment, require_all: false)
+          /^#\s*:nodoc:#{"\s+all\s*$" if require_all}/.match?(comment.text)
         end
 
         def nodoc(node)

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

@@ -41,7 +41,6 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize
         def autocorrect(node)
           lambda do |corrector|
             corrector.replace(node.send_node.loc.selector, 'each_with_object')
@@ -60,7 +59,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 

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

@@ -43,13 +43,15 @@ module RuboCop
 
         def on_case(case_node)
           return if case_node.condition
-          return if case_node.when_branches.any? do |when_branch|
-            when_branch.each_descendant.any?(&:return_type?)
-          end
 
-          if (else_branch = case_node.else_branch)
-            return if else_branch.return_type? ||
-                      else_branch.each_descendant.any?(&:return_type?)
+          branch_bodies = [
+            *case_node.when_branches.map(&:body),
+            case_node.else_branch
+          ].compact
+
+          return if branch_bodies.any? do |body|
+            body.return_type? ||
+            body.each_descendant.any?(&:return_type?)
           end
 
           add_offense(case_node, location: :keyword)

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

@@ -25,13 +25,13 @@ module RuboCop
         STR_MSG = 'Use string literal `%<prefer>s` instead of ' \
                   '`String.new`.'
 
-        def_node_matcher :array_node, '(send (const nil? :Array) :new)'
-        def_node_matcher :hash_node, '(send (const nil? :Hash) :new)'
-        def_node_matcher :str_node, '(send (const nil? :String) :new)'
+        def_node_matcher :array_node, '(send (const {nil? cbase} :Array) :new)'
+        def_node_matcher :hash_node, '(send (const {nil? cbase} :Hash) :new)'
+        def_node_matcher :str_node, '(send (const {nil? cbase} :String) :new)'
         def_node_matcher :array_with_block,
-                         '(block (send (const nil? :Array) :new) args _)'
+                         '(block (send (const {nil? cbase} :Array) :new) args _)'
         def_node_matcher :hash_with_block,
-                         '(block (send (const nil? :Hash) :new) args _)'
+                         '(block (send (const {nil? cbase} :Hash) :new) args _)'
 
         def on_send(node)
           add_offense(node, message: ARR_MSG)  if offense_array_node?(node)

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

@@ -73,13 +73,13 @@ module RuboCop
         end
 
         def corrected(node)
-          if node.arguments?
-            arguments   = node.arguments.source
-            extra_space = ' ' unless parentheses?(node.arguments)
-          end
           scope = node.receiver ? "#{node.receiver.source}." : ''
+          arguments = if node.arguments?
+                        args = node.arguments.map(&:source).join(', ')
 
-          signature = [scope, node.method_name, extra_space, arguments].join
+                        parentheses?(node.arguments) ? "(#{args})" : " #{args}"
+                      end
+          signature = [scope, node.method_name, arguments].join
 
           ["def #{signature}", 'end'].join(joint(node))
         end

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

@@ -42,7 +42,7 @@ module RuboCop
         end
 
         def encoding_omitable?(line)
-          line =~ ENCODING_PATTERN
+          ENCODING_PATTERN.match?(line)
         end
 
         def encoding_line_number(processed_source)

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

@@ -37,6 +37,8 @@ module RuboCop
         MSG_INCORRECT_LINE = 'Use `%<expected>s` instead of `%<actual>s`, ' \
                              'as they are used by backtraces.'
 
+        EVAL_METHODS = %i[eval class_eval module_eval instance_eval].to_set.freeze
+
         def_node_matcher :eval_without_location?, <<~PATTERN
           {
             (send nil? :eval ${str dstr})
@@ -61,6 +63,8 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return unless EVAL_METHODS.include?(node.method_name)
+
           eval_without_location?(node) do |code|
             if with_lineno?(node)
               on_with_lineno(node, code)

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

@@ -53,7 +53,7 @@ module RuboCop
 
         def_node_matcher :file_expand_path, <<~PATTERN
           (send
-            (const nil? :File) :expand_path
+            (const {nil? cbase} :File) :expand_path
             $_
             $_)
         PATTERN
@@ -69,11 +69,14 @@ module RuboCop
           (send
             (send
               (send
-                (const nil? :Pathname) :new
+                (const {nil? cbase} :Pathname) :new
                 $_) :parent) :expand_path)
         PATTERN
 
+        # rubocop:disable Metrics/PerceivedComplexity
         def on_send(node)
+          return unless node.method?(:expand_path)
+
           if (captured_values = file_expand_path(node))
             current_path, default_dir = captured_values
 
@@ -88,6 +91,7 @@ module RuboCop
             add_offense(node, message: PATHNAME_NEW_MSG)
           end
         end
+        # rubocop:enable Metrics/PerceivedComplexity
 
         def autocorrect(node)
           lambda do |corrector|

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of explicit block argument to avoid writing
+      # block literal that just passes its arguments to another block.
+      #
+      # @example
+      #   # bad
+      #   def with_tmp_dir
+      #     Dir.mktmpdir do |tmp_dir|
+      #       Dir.chdir(tmp_dir) { |dir| yield dir } # block just passes arguments
+      #     end
+      #   end
+      #
+      #   # bad
+      #   def nine_times
+      #     9.times { yield }
+      #   end
+      #
+      #   # good
+      #   def with_tmp_dir(&block)
+      #     Dir.mktmpdir do |tmp_dir|
+      #       Dir.chdir(tmp_dir, &block)
+      #     end
+      #   end
+      #
+      #   with_tmp_dir do |dir|
+      #     puts "dir is accessible as a parameter and pwd is set: #{dir}"
+      #   end
+      #
+      #   # good
+      #   def nine_times(&block)
+      #     9.times(&block)
+      #   end
+      #
+      class ExplicitBlockArgument < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Consider using explicit block argument in the '\
+              "surrounding method's signature over `yield`."
+
+        def_node_matcher :yielding_block?, <<~PATTERN
+          (block $_ (args $...) (yield $...))
+        PATTERN
+
+        def initialize(config = nil, options = nil)
+          super
+          @def_nodes = Set.new
+        end
+
+        def on_yield(node)
+          block_node = node.parent
+
+          yielding_block?(block_node) do |send_node, block_args, yield_args|
+            return unless yielding_arguments?(block_args, yield_args)
+
+            add_offense(block_node) do |corrector|
+              corrector.remove(block_body_range(block_node, send_node))
+
+              add_block_argument(send_node, corrector)
+
+              def_node = block_node.each_ancestor(:def, :defs).first
+              add_block_argument(def_node, corrector) if @def_nodes.add?(def_node)
+            end
+          end
+        end
+
+        private
+
+        def yielding_arguments?(block_args, yield_args)
+          yield_args.zip(block_args).all? do |yield_arg, block_arg|
+            block_arg && yield_arg.children.first == block_arg.children.first
+          end
+        end
+
+        def add_block_argument(node, corrector)
+          if node.arguments?
+            last_arg = node.arguments.last
+            arg_range = range_with_surrounding_comma(last_arg.source_range, :right)
+            replacement = ' &block'
+            replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
+            corrector.insert_after(arg_range, replacement) unless last_arg.blockarg_type?
+          elsif node.send_type?
+            corrector.insert_after(node, '(&block)')
+          else
+            corrector.insert_after(node.loc.name, '(&block)')
+          end
+        end
+
+        def block_body_range(block_node, send_node)
+          range_between(
+            send_node.loc.expression.end_pos,
+            block_node.loc.end.end_pos
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -60,6 +60,11 @@ module RuboCop
       #
       class ExponentialNotation < Cop
         include ConfigurableEnforcedStyle
+        MESSAGES = {
+          scientific: 'Use a mantissa in [1, 10[.',
+          engineering: 'Use an exponent divisible by 3 and a mantissa in [0.1, 1000[.',
+          integral: 'Use an integer as mantissa, without trailing zero.'
+        }.freeze
 
         def on_float(node)
           add_offense(node) if offense?(node)
@@ -69,7 +74,7 @@ module RuboCop
 
         def scientific?(node)
           mantissa, = node.source.split('e')
-          mantissa =~ /^-?[1-9](\.\d*[0-9])?$/
+          /^-?[1-9](\.\d*[0-9])?$/.match?(mantissa)
         end
 
         def engineering?(node)
@@ -85,7 +90,7 @@ module RuboCop
 
         def integral(node)
           mantissa, = node.source.split('e')
-          mantissa =~ /^-?[1-9](\d*[1-9])?$/
+          /^-?[1-9](\d*[1-9])?$/.match?(mantissa)
         end
 
         def offense?(node)
@@ -104,14 +109,7 @@ module RuboCop
         end
 
         def message(_node)
-          case style
-          when :scientific
-            'Use a mantissa in [1, 10[.'
-          when :engineering
-            'Use an exponent divisible by 3 and a mantissa in [0.1, 1000[.'
-          when :integral
-            'Use an integer as mantissa, without trailing zero.'
-          end
+          MESSAGES[style]
         end
       end
     end

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

@@ -41,6 +41,12 @@ module RuboCop
       #   a.fdiv(b)
       class FloatDivision < Cop
         include ConfigurableEnforcedStyle
+        MESSAGES = {
+          left_coerce: 'Prefer using `.to_f` on the left side.',
+          right_coerce: 'Prefer using `.to_f` on the right side.',
+          single_coerce: 'Prefer using `.to_f` on one side only.',
+          fdiv: 'Prefer using `fdiv` for float divisions.'
+        }.freeze
 
         def_node_matcher :right_coerce?, <<~PATTERN
           (send _ :/ (send _ :to_f))
@@ -77,16 +83,7 @@ module RuboCop
         end
 
         def message(_node)
-          case style
-          when :left_coerce
-            'Prefer using `.to_f` on the left side.'
-          when :right_coerce
-            'Prefer using `.to_f` on the right side.'
-          when :single_coerce
-            'Prefer using `.to_f` on one side only.'
-          when :fdiv
-            'Prefer using `fdiv` for float divisions.'
-          end
+          MESSAGES[style]
         end
       end
     end

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

@@ -40,6 +40,8 @@ module RuboCop
 
         MSG = 'Favor `%<prefer>s` over `%<current>s`.'
 
+        FORMAT_METHODS = %i[format sprintf %].freeze
+
         def_node_matcher :formatter, <<~PATTERN
           {
             (send nil? ${:sprintf :format} _ _ ...)
@@ -53,6 +55,8 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return unless FORMAT_METHODS.include?(node.method_name)
+
           formatter(node) do |selector|
             detected_style = selector == :% ? :percent : selector
 

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

@@ -41,6 +41,7 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         def on_str(node)
+          return unless node.value.include?('%')
           return if node.each_ancestor(:xstr, :regexp).any?
 
           tokens(node) do |detected_style, token_range|
@@ -75,11 +76,11 @@ module RuboCop
 
         # rubocop:disable Style/FormatStringToken
         def message_text(style)
-          case style
-          when :annotated then 'annotated tokens (like `%<foo>s`)'
-          when :template then 'template tokens (like `%{foo}`)'
-          when :unannotated then 'unannotated tokens (like `%s`)'
-          end
+          {
+            annotated: 'annotated tokens (like `%<foo>s`)',
+            template: 'template tokens (like `%{foo}`)',
+            unannotated: 'unannotated tokens (like `%s`)'
+          }[style]
         end
         # rubocop:enable Style/FormatStringToken
 

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

@@ -148,7 +148,7 @@ module RuboCop
           end
 
           next_token = processed_source.tokens[token_number]
-          token = next_token if next_token && next_token.text =~ Encoding::ENCODING_PATTERN
+          token = next_token if Encoding::ENCODING_PATTERN.match?(next_token&.text)
 
           token
         end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of `$stdout/$stderr/$stdin` instead of `STDOUT/STDERR/STDIN`.
+      # `STDOUT/STDERR/STDIN` are constants, and while you can actually
+      # reassign (possibly to redirect some stream) constants in Ruby, you'll get
+      # an interpreter warning if you do so.
+      #
+      # @example
+      #   # bad
+      #   STDOUT.puts('hello')
+      #
+      #   hash = { out: STDOUT, key: value }
+      #
+      #   def m(out = STDOUT)
+      #     out.puts('hello')
+      #   end
+      #
+      #   # good
+      #   $stdout.puts('hello')
+      #
+      #   hash = { out: $stdout, key: value }
+      #
+      #   def m(out = $stdout)
+      #     out.puts('hello')
+      #   end
+      #
+      class GlobalStdStream < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<gvar_name>s` instead of `%<const_name>s`.'
+
+        STD_STREAMS = %i[STDIN STDOUT STDERR].to_set.freeze
+
+        def_node_matcher :const_to_gvar_assignment?, <<~PATTERN
+          (gvasgn %1 (const nil? _))
+        PATTERN
+
+        def on_const(node)
+          const_name = node.children[1]
+          return unless STD_STREAMS.include?(const_name)
+
+          gvar_name = gvar_name(const_name).to_sym
+          return if const_to_gvar_assignment?(node.parent, gvar_name)
+
+          add_offense(node, message: message(const_name)) do |corrector|
+            corrector.replace(node, gvar_name)
+          end
+        end
+
+        private
+
+        def message(const_name)
+          format(MSG, gvar_name: gvar_name(const_name), const_name: const_name)
+        end
+
+        def gvar_name(const_name)
+          "$#{const_name.to_s.downcase}"
+        end
+      end
+    end
+  end
+end