rubocop 0.75.1

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+# The Lint/UnneededCopEnableDirective cop needs to be disabled so as
+# to be able to provide a (bad) example of an unneeded enable.
+
+# rubocop:disable Lint/UnneededCopEnableDirective
+module RuboCop
+  module Cop
+    module Lint
+      # This cop detects instances of rubocop:enable comments that can be
+      # removed.
+      #
+      # When comment enables all cops at once `rubocop:enable all`
+      # that cop checks whether any cop was actually enabled.
+      # @example
+      #   # bad
+      #   foo = 1
+      #   # rubocop:enable Metrics/LineLength
+      #
+      #   # good
+      #   foo = 1
+      # @example
+      #   # bad
+      #   # rubocop:disable Metrics/LineLength
+      #   baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrrrrr
+      #   # rubocop:enable Metrics/LineLength
+      #   baz
+      #   # rubocop:enable all
+      #
+      #   # good
+      #   # rubocop:disable Metrics/LineLength
+      #   baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrrrrr
+      #   # rubocop:enable all
+      #   baz
+      class UnneededCopEnableDirective < Cop
+        include RangeHelp
+        include SurroundingSpace
+
+        MSG = 'Unnecessary enabling of %<cop>s.'
+
+        def investigate(processed_source)
+          return if processed_source.blank?
+
+          offenses = processed_source.comment_config.extra_enabled_comments
+          offenses.each do |comment, name|
+            add_offense(
+              [comment, name],
+              location: range_of_offense(comment, name),
+              message: format(MSG, cop: all_or_name(name))
+            )
+          end
+        end
+
+        def autocorrect(comment_and_name)
+          lambda do |corrector|
+            corrector.remove(range_with_comma(*comment_and_name))
+          end
+        end
+
+        private
+
+        def range_of_offense(comment, name)
+          start_pos = comment_start(comment) + cop_name_indention(comment, name)
+          range_between(start_pos, start_pos + name.size)
+        end
+
+        def comment_start(comment)
+          comment.loc.expression.begin_pos
+        end
+
+        def cop_name_indention(comment, name)
+          comment.text.index(name)
+        end
+
+        def range_with_comma(comment, name)
+          source = comment.loc.expression.source
+
+          begin_pos = cop_name_indention(comment, name)
+          end_pos = begin_pos + name.size
+          begin_pos = reposition(source, begin_pos, -1)
+          end_pos = reposition(source, end_pos, 1)
+
+          comma_pos =
+            if source[begin_pos - 1] == ','
+              :before
+            elsif source[end_pos] == ','
+              :after
+            else
+              :none
+            end
+
+          range_to_remove(begin_pos, end_pos, comma_pos, comment)
+        end
+
+        def range_to_remove(begin_pos, end_pos, comma_pos, comment)
+          start = comment_start(comment)
+          buffer = processed_source.buffer
+          range_class = Parser::Source::Range
+
+          case comma_pos
+          when :before
+            range_class.new(buffer, start + begin_pos - 1, start + end_pos)
+          when :after
+            range_class.new(buffer, start + begin_pos, start + end_pos + 1)
+          else
+            range_class.new(buffer, start, comment.loc.expression.end_pos)
+          end
+        end
+
+        def all_or_name(name)
+          name == 'all' ? 'all cops' : name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for unnecessary `require` statement.
+      #
+      # The following features are unnecessary `require` statement because
+      # they are already loaded.
+      #
+      # ruby -ve 'p $LOADED_FEATURES.reject { |feature| %r|/| =~ feature }'
+      # ruby 2.2.8p477 (2017-09-14 revision 59906) [x86_64-darwin13]
+      # ["enumerator.so", "rational.so", "complex.so", "thread.rb"]
+      #
+      # This cop targets Ruby 2.2 or higher containing these 4 features.
+      #
+      # @example
+      #   # bad
+      #   require 'unloaded_feature'
+      #   require 'thread'
+      #
+      #   # good
+      #   require 'unloaded_feature'
+      class UnneededRequireStatement < Cop
+        include RangeHelp
+
+        MSG = 'Remove unnecessary `require` statement.'
+
+        def_node_matcher :unnecessary_require_statement?, <<~PATTERN
+          (send nil? :require
+            (str {"enumerator" "rational" "complex" "thread"}))
+        PATTERN
+
+        def on_send(node)
+          return unless unnecessary_require_statement?(node)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            range = range_with_surrounding_space(range: node.loc.expression,
+                                                 side: :right)
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for unneeded usages of splat expansion
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   a = *[1, 2, 3]
+      #   a = *'a'
+      #   a = *1
+      #
+      #   begin
+      #     foo
+      #   rescue *[StandardError, ApplicationError]
+      #     bar
+      #   end
+      #
+      #   case foo
+      #   when *[1, 2, 3]
+      #     bar
+      #   else
+      #     baz
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   c = [1, 2, 3]
+      #   a = *c
+      #   a, b = *c
+      #   a, *b = *c
+      #   a = *1..10
+      #   a = ['a']
+      #
+      #   begin
+      #     foo
+      #   rescue StandardError, ApplicationError
+      #     bar
+      #   end
+      #
+      #   case foo
+      #   when 1, 2, 3
+      #     bar
+      #   else
+      #     baz
+      #   end
+      class UnneededSplatExpansion < Cop
+        MSG = 'Replace splat expansion with comma separated values.'
+        ARRAY_PARAM_MSG = 'Pass array contents as separate arguments.'
+        PERCENT_W = '%w'
+        PERCENT_CAPITAL_W = '%W'
+        PERCENT_I = '%i'
+        PERCENT_CAPITAL_I = '%I'
+        ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
+
+        def_node_matcher :array_new?, <<~PATTERN
+          {
+            $(send (const nil? :Array) :new ...)
+            $(block (send (const nil? :Array) :new ...) ...)
+          }
+        PATTERN
+
+        def_node_matcher :literal_expansion, <<~PATTERN
+          (splat {$({str dstr int float array} ...) (block $#array_new? ...) $#array_new?} ...)
+        PATTERN
+
+        def on_splat(node)
+          unneeded_splat_expansion(node) do
+            if array_splat?(node) &&
+               (method_argument?(node) || part_of_an_array?(node))
+              add_offense(node, message: ARRAY_PARAM_MSG)
+            else
+              add_offense(node)
+            end
+          end
+        end
+
+        def autocorrect(node)
+          range, content = replacement_range_and_content(node)
+
+          lambda do |corrector|
+            corrector.replace(range, content)
+          end
+        end
+
+        private
+
+        def unneeded_splat_expansion(node)
+          literal_expansion(node) do |expanded_item|
+            if expanded_item.send_type?
+              return if array_new_inside_array_literal?(expanded_item)
+
+              grandparent = node.parent.parent
+              return if grandparent &&
+                        !ASSIGNMENT_TYPES.include?(grandparent.type)
+            end
+
+            yield
+          end
+        end
+
+        def array_new_inside_array_literal?(array_new_node)
+          return false unless array_new?(array_new_node)
+
+          grandparent = array_new_node.parent.parent
+          grandparent.array_type? && grandparent.children.size > 1
+        end
+
+        def replacement_range_and_content(node)
+          variable, = *node
+          loc = node.loc
+
+          if array_new?(variable)
+            [node.parent.loc.expression, variable.source]
+          elsif !variable.array_type?
+            [loc.expression, "[#{variable.source}]"]
+          elsif unneeded_brackets?(node)
+            [loc.expression, remove_brackets(variable)]
+          else
+            [loc.operator, '']
+          end
+        end
+
+        def array_splat?(node)
+          node.children.first.array_type?
+        end
+
+        def method_argument?(node)
+          node.parent.send_type?
+        end
+
+        def part_of_an_array?(node)
+          # The parent of a splat expansion is an array that does not have
+          # `begin` or `end`
+          parent = node.parent
+          parent.array_type? && parent.loc.begin && parent.loc.end
+        end
+
+        def unneeded_brackets?(node)
+          parent = node.parent
+          grandparent = node.parent.parent
+
+          parent.when_type? || parent.send_type? || part_of_an_array?(node) ||
+            (grandparent&.resbody_type?)
+        end
+
+        def remove_brackets(array)
+          array_start = array.loc.begin.source
+          elements = *array
+          elements = elements.map(&:source)
+
+          if array_start.start_with?(PERCENT_W)
+            "'#{elements.join("', '")}'"
+          elsif array_start.start_with?(PERCENT_CAPITAL_W)
+            %("#{elements.join('", "')}")
+          elsif array_start.start_with?(PERCENT_I)
+            ":#{elements.join(', :')}"
+          elsif array_start.start_with?(PERCENT_CAPITAL_I)
+            %(:"#{elements.join('", :"')}")
+          else
+            elements.join(', ')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for unreachable code.
+      # The check are based on the presence of flow of control
+      # statement in non-final position in *begin*(implicit) blocks.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     return
+      #     do_something
+      #   end
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     if cond
+      #       return
+      #     else
+      #       return
+      #     end
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     do_something
+      #   end
+      class UnreachableCode < Cop
+        MSG = 'Unreachable code detected.'
+
+        def on_begin(node)
+          expressions = *node
+
+          expressions.each_cons(2) do |expression1, expression2|
+            next unless flow_expression?(expression1)
+
+            add_offense(expression2)
+          end
+        end
+
+        alias on_kwbegin on_begin
+
+        private
+
+        def_node_matcher :flow_command?, <<~PATTERN
+          {
+            return next break retry redo
+            (send
+             {nil? (const {nil? cbase} :Kernel)}
+             {:raise :fail :throw :exit :exit! :abort}
+             ...)
+          }
+        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
+
+        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
+  end
+end

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for unused block arguments.
+      #
+      # @example
+      #   # bad
+      #   do_something do |used, unused|
+      #     puts used
+      #   end
+      #
+      #   do_something do |bar|
+      #     puts :foo
+      #   end
+      #
+      #   define_method(:foo) do |bar|
+      #     puts :baz
+      #   end
+      #
+      #   # good
+      #   do_something do |used, _unused|
+      #     puts used
+      #   end
+      #
+      #   do_something do
+      #     puts :foo
+      #   end
+      #
+      #   define_method(:foo) do |_bar|
+      #     puts :baz
+      #   end
+      #
+      # @example IgnoreEmptyBlocks: true (default)
+      #   # good
+      #   do_something { |unused| }
+      #
+      # @example IgnoreEmptyBlocks: false
+      #   # bad
+      #   do_something { |unused| }
+      #
+      # @example AllowUnusedKeywordArguments: false (default)
+      #   # bad
+      #   do_something do |unused: 42|
+      #     foo
+      #   end
+      #
+      # @example AllowUnusedKeywordArguments: true
+      #   # good
+      #   do_something do |unused: 42|
+      #     foo
+      #   end
+      #
+      class UnusedBlockArgument < Cop
+        include UnusedArgument
+
+        def autocorrect(node)
+          UnusedArgCorrector.correct(processed_source, node)
+        end
+
+        private
+
+        def check_argument(variable)
+          return if allowed_block?(variable) ||
+                    allowed_keyword_argument?(variable)
+
+          super
+        end
+
+        def allowed_block?(variable)
+          !variable.block_argument? ||
+            (ignore_empty_blocks? && empty_block?(variable))
+        end
+
+        def allowed_keyword_argument?(variable)
+          variable.keyword_argument? &&
+            allow_unused_keyword_arguments?
+        end
+
+        def message(variable)
+          message = "Unused #{variable_type(variable)} - `#{variable.name}`."
+
+          if variable.explicit_block_local_variable?
+            message
+          else
+            augment_message(message, variable)
+          end
+        end
+
+        def augment_message(message, variable)
+          scope = variable.scope
+          all_arguments = scope.variables.each_value.select(&:block_argument?)
+
+          augmentation = if scope.node.lambda?
+                           message_for_lambda(variable, all_arguments)
+                         else
+                           message_for_normal_block(variable, all_arguments)
+                         end
+
+          [message, augmentation].join(' ')
+        end
+
+        def variable_type(variable)
+          if variable.explicit_block_local_variable?
+            'block local variable'
+          else
+            'block argument'
+          end
+        end
+
+        def message_for_normal_block(variable, all_arguments)
+          if all_arguments.none?(&:referenced?) &&
+             !define_method_call?(variable)
+            if all_arguments.count > 1
+              "You can omit all the arguments if you don't care about them."
+            else
+              "You can omit the argument if you don't care about it."
+            end
+          else
+            message_for_underscore_prefix(variable)
+          end
+        end
+
+        def message_for_lambda(variable, all_arguments)
+          message = message_for_underscore_prefix(variable)
+
+          if all_arguments.none?(&:referenced?)
+            proc_message = 'Also consider using a proc without arguments ' \
+                           'instead of a lambda if you want it ' \
+                           "to accept any arguments but don't care about them."
+          end
+
+          [message, proc_message].compact.join(' ')
+        end
+
+        def message_for_underscore_prefix(variable)
+          "If it's necessary, use `_` or `_#{variable.name}` " \
+          "as an argument name to indicate that it won't be used."
+        end
+
+        def define_method_call?(variable)
+          call, = *variable.scope.node
+          _, method, = *call
+
+          method == :define_method
+        end
+
+        def empty_block?(variable)
+          _send, _args, body = *variable.scope.node
+
+          body.nil?
+        end
+
+        def allow_unused_keyword_arguments?
+          cop_config['AllowUnusedKeywordArguments']
+        end
+
+        def ignore_empty_blocks?
+          cop_config['IgnoreEmptyBlocks']
+        end
+      end
+    end
+  end
+end