rubocop 0.49.1 → 0.50.0

data/lib/rubocop/cop/lint/percent_symbol_array.rb

@@ -33,7 +33,7 @@ module RuboCop
         def on_percent_literal(node)
           return unless contains_colons_or_commas?(node)
 
-          add_offense(node, :expression, MSG)
+          add_offense(node)
         end
 
         private

data/lib/rubocop/cop/lint/rand_one.rb

@@ -31,7 +31,13 @@ module RuboCop
         def on_send(node)
           return unless rand_one?(node)
 
-          add_offense(node, :expression, format(MSG, node.source))
+          add_offense(node)
+        end
+
+        private
+
+        def message(node)
+          format(MSG, node.source)
         end
       end
     end

data/lib/rubocop/cop/lint/redundant_with_index.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for redundant `with_index`.
+      #
+      # @example
+      #   # bad
+      #   ary.each_with_index do |v|
+      #     v
+      #   end
+      #
+      #   # good
+      #   ary.each do |v|
+      #     v
+      #   end
+      #
+      #   # bad
+      #   ary.each.with_index do |v|
+      #     v
+      #   end
+      #
+      #   # good
+      #   ary.each do |v|
+      #     v
+      #   end
+      #
+      class RedundantWithIndex < Cop
+        MSG_EACH_WITH_INDEX = 'Use `each` instead of `each_with_index`.'.freeze
+        MSG_WITH_INDEX = 'Remove redundant `with_index`.'.freeze
+
+        def_node_matcher :redundant_with_index?, <<-PATTERN
+          (block
+            $(send
+              _ {:each_with_index :with_index})
+            (args
+              (arg _))
+            ...)
+        PATTERN
+
+        def on_block(node)
+          redundant_with_index?(node) do |send|
+            add_offense(node, with_index_range(send))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            redundant_with_index?(node) do |send|
+              if send.method_name == :each_with_index
+                corrector.replace(send.loc.selector, 'each')
+              else
+                corrector.remove(send.loc.selector)
+                corrector.remove(send.loc.dot)
+              end
+            end
+          end
+        end
+
+        private
+
+        def message(node)
+          if node.method_name == :each_with_index
+            MSG_EACH_WITH_INDEX
+          else
+            MSG_WITH_INDEX
+          end
+        end
+
+        def with_index_range(send)
+          range_between(send.loc.selector.begin_pos, send.loc.selector.end_pos)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/require_parentheses.rb

@@ -53,7 +53,7 @@ module RuboCop
         def check_predicate(predicate, node)
           return unless predicate.operator_keyword?
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
       end
     end

data/lib/rubocop/cop/lint/rescue_exception.rb

@@ -33,7 +33,7 @@ module RuboCop
           rescue_args = node.children.first.children
           return unless rescue_args.any? { |a| targets_exception?(a) }
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def targets_exception?(rescue_arg_node)

data/lib/rubocop/cop/lint/rescue_type.rb

@@ -53,22 +53,29 @@ module RuboCop
                       format(MSG, invalid_exceptions.map(&:source).join(', ')))
         end
 
+        private
+
         def autocorrect(node)
           rescued, _, _body = *node
-          exceptions = *rescued
-          valid_exceptions = exceptions - invalid_exceptions(exceptions)
-          correction = valid_exceptions.map(&:source).join(', ')
-          correction = " #{correction}" unless correction.empty?
           range = Parser::Source::Range.new(node.loc.expression,
                                             node.loc.keyword.end_pos,
                                             rescued.loc.expression.end_pos)
 
           lambda do |corrector|
-            corrector.replace(range, correction)
+            corrector.replace(range, correction(*rescued))
           end
         end
 
-        private
+        def correction(*exceptions)
+          correction = valid_exceptions(exceptions).map(&:source).join(', ')
+          correction = " #{correction}" unless correction.empty?
+
+          correction
+        end
+
+        def valid_exceptions(exceptions)
+          exceptions - invalid_exceptions(exceptions)
+        end
 
         def invalid_exceptions(exceptions)
           exceptions.select do |exception|

data/lib/rubocop/cop/lint/rescue_without_error_class.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for uses of `rescue` with no error class specified.
+      #
+      # @example
+      #
+      #   # good
+      #   begin
+      #     foo
+      #   rescue BarError
+      #     bar
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     foo
+      #   rescue
+      #     bar
+      #   end
+      class RescueWithoutErrorClass < Cop
+        MSG = 'Avoid rescuing without specifying an error class.'.freeze
+
+        def_node_matcher :rescue_without_error_class?, <<-PATTERN
+          (resbody nil ...)
+        PATTERN
+
+        def on_resbody(node)
+          return unless rescue_without_error_class?(node)
+
+          add_offense(node, :keyword)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/return_in_void_context.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for the use of a return with a value in a context
+      # where the value will be ignored. (initialize and setter methods)
+      #
+      # @example
+      #
+      #   # bad
+      #   def initialize
+      #     foo
+      #     return :qux if bar?
+      #     baz
+      #   end
+      #
+      #   def foo=(bar)
+      #     return 42
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #   def initialize
+      #     foo
+      #     return if bar?
+      #     baz
+      #   end
+      #
+      #   def foo=(bar)
+      #     return
+      #   end
+      class ReturnInVoidContext < Cop
+        MSG = 'Do not return a value in `%s`.'.freeze
+        def on_return(return_node)
+          method_name = method_name(return_node)
+          return unless method_name && return_node.descendants.any? &&
+                        useless_return_method?(method_name)
+
+          add_offense(return_node, :keyword, format(message, method_name))
+        end
+
+        private
+
+        def method_name(return_node)
+          method_node = return_node.each_ancestor(:block, :def, :defs).first
+          return nil unless method_node.def_type?
+          method_node.children.first
+        end
+
+        def method_setter?(method_name)
+          method_name.to_s.end_with?('=') &&
+            !AST::Node::COMPARISON_OPERATORS.include?(method_name)
+        end
+
+        def useless_return_method?(method_name)
+          method_name == :initialize || method_setter?(method_name)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/script_permission.rb

@@ -18,6 +18,12 @@ module RuboCop
           add_offense(comment, :expression, message)
         end
 
+        def autocorrect(node)
+          lambda do |_corrector|
+            FileUtils.chmod('+x', node.loc.expression.source_buffer.name)
+          end
+        end
+
         private
 
         def start_with_shebang?(processed_source)

data/lib/rubocop/cop/lint/syntax.rb

@@ -5,50 +5,47 @@ module RuboCop
     module Lint
       # This is actually not a cop and inspects nothing. It just provides
       # methods to repack Parser's diagnostics/errors into RuboCop's offenses.
-      module Syntax
+      class Syntax < Cop
         PseudoSourceRange = Struct.new(:line, :column, :source_line, :begin_pos,
                                        :end_pos)
 
-        COP_NAME = 'Syntax'.freeze
         ERROR_SOURCE_RANGE = PseudoSourceRange.new(1, 0, '', 0, 1).freeze
 
-        def self.offenses_from_processed_source(processed_source)
-          offenses = []
+        def self.offenses_from_processed_source(processed_source,
+                                                config, options)
+          cop = new(config, options)
 
           if processed_source.parser_error
-            offenses << offense_from_error(processed_source.parser_error)
+            cop.add_offense_from_error(processed_source.parser_error)
           end
 
           processed_source.diagnostics.each do |diagnostic|
-            offenses << offense_from_diagnostic(diagnostic,
-                                                processed_source.ruby_version)
+            cop.add_offense_from_diagnostic(diagnostic,
+                                            processed_source.ruby_version)
           end
 
-          offenses
+          cop.offenses
         end
 
-        def self.offense_from_diagnostic(diagnostic, ruby_version)
-          Offense.new(
-            diagnostic.level,
-            diagnostic.location,
+        def add_offense_from_diagnostic(diagnostic, ruby_version)
+          message =
             "#{diagnostic.message}\n(Using Ruby #{ruby_version} parser; " \
-            'configure using `TargetRubyVersion` parameter, under `AllCops`)',
-            COP_NAME
-          )
+            'configure using `TargetRubyVersion` parameter, under `AllCops`)'
+          add_offense(nil, diagnostic.location, message, diagnostic.level)
         end
 
-        def self.offense_from_error(error)
+        def add_offense_from_error(error)
           message = beautify_message(error.message)
-          Offense.new(:fatal, ERROR_SOURCE_RANGE, message, COP_NAME)
+          add_offense(nil, ERROR_SOURCE_RANGE, message, :fatal)
         end
 
-        def self.beautify_message(message)
+        private
+
+        def beautify_message(message)
           message = message.capitalize
           message << '.' unless message.end_with?('.')
           message
         end
-
-        private_class_method :beautify_message
       end
     end
   end

data/lib/rubocop/cop/lint/unified_integer.rb

@@ -20,12 +20,13 @@ module RuboCop
       class UnifiedInteger < Cop
         MSG = 'Use `Integer` instead of `%s`.'.freeze
 
-        def_node_matcher :fixnum_or_bignum_const?, <<-PATTERN
+        def_node_matcher :fixnum_or_bignum_const, <<-PATTERN
           (:const {nil (:cbase)} ${:Fixnum :Bignum})
         PATTERN
 
         def on_const(node)
-          klass = fixnum_or_bignum_const?(node)
+          klass = fixnum_or_bignum_const(node)
+
           return unless klass
 
           add_offense(node, :expression, format(MSG, klass))

data/lib/rubocop/cop/lint/unneeded_disable.rb

@@ -137,7 +137,7 @@ module RuboCop
         end
 
         def all_disabled?(comment)
-          comment.text =~ /rubocop:disable\s+all\b/
+          comment.text =~ /rubocop\s*:\s*disable\s+all\b/
         end
 
         def ignore_offense?(disabled_ranges, line_range)

data/lib/rubocop/cop/lint/unneeded_splat_expansion.rb

@@ -73,7 +73,7 @@ module RuboCop
                (method_argument?(node) || part_of_an_array?(node))
               add_offense(node, :expression, ARRAY_PARAM_MSG)
             else
-              add_offense(node, :expression)
+              add_offense(node)
             end
           end
         end

data/lib/rubocop/cop/lint/unreachable_code.rb

@@ -16,6 +16,17 @@ module RuboCop
       #     do_something
       #   end
       #
+      #   # bad
+      #
+      #   def some_method
+      #     if cond
+      #       return
+      #     else
+      #       return
+      #     end
+      #     do_something
+      #   end
+      #
       # @example
       #
       #   # good
@@ -26,25 +37,59 @@ module RuboCop
       class UnreachableCode < Cop
         MSG = 'Unreachable code detected.'.freeze
 
-        NODE_TYPES = %i[return next break retry redo].freeze
-        FLOW_COMMANDS = %i[throw raise fail].freeze
-
         def on_begin(node)
           expressions = *node
 
           expressions.each_cons(2) do |e1, e2|
-            next unless NODE_TYPES.include?(e1.type) || flow_command?(e1)
+            next unless flow_expression?(e1)
 
-            add_offense(e2, :expression)
+            add_offense(e2)
           end
         end
 
+        alias on_kwbegin on_begin
+
         private
 
-        def flow_command?(node)
-          return false unless node.send_type?
+        def_node_matcher :flow_command?, <<-PATTERN
+          {
+            return next break retry redo
+            (send
+             {nil (const {nil cbase} :Kernel)}
+             {:raise :fail :throw}
+             ...)
+          }
+        PATTERN
+
+        def flow_expression?(node)
+          return true if flow_command?(node)
+          case node.type
+          when :begin, :kwbegin
+            expressions = *node
+            expressions.any? { |expr| flow_expression?(expr) }
+          when :if
+            check_if(node)
+          when :case
+            check_case(node)
+          else
+            false
+          end
+        end
 
-          FLOW_COMMANDS.any? { |c| node.command?(c) }
+        def check_if(node)
+          if_branch = node.if_branch
+          else_branch = node.else_branch
+          if_branch && else_branch &&
+            flow_expression?(if_branch) && flow_expression?(else_branch)
+        end
+
+        def check_case(node)
+          else_branch = node.else_branch
+          return false unless else_branch
+          return false unless flow_expression?(else_branch)
+          node.when_branches.all? do |branch|
+            branch.body && flow_expression?(branch.body)
+          end
         end
       end
     end