rbhint 0.8.5.rc1

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+# The Lint/RedundantCopEnableDirective and Lint/RedundantCopDisableDirective
+# cops need to be disabled so as to be able to provide a (bad) example of an
+# unneeded enable.
+
+# rubocop:disable Lint/RedundantCopEnableDirective
+# rubocop:disable Lint/RedundantCopDisableDirective
+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 Layout/LineLength
+      #
+      #   # good
+      #   foo = 1
+      # @example
+      #   # bad
+      #   # rubocop:disable Style/StringLiterals
+      #   foo = "1"
+      #   # rubocop:enable Style/StringLiterals
+      #   baz
+      #   # rubocop:enable all
+      #
+      #   # good
+      #   # rubocop:disable Style/StringLiterals
+      #   foo = "1"
+      #   # rubocop:enable all
+      #   baz
+      class RedundantCopEnableDirective < 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)
+
+          case comma_pos
+          when :before
+            range_between(start + begin_pos - 1, start + end_pos)
+          when :after
+            range_between(start + begin_pos, start + end_pos + 1)
+          else
+            range_between(start, comment.loc.expression.end_pos)
+          end
+        end
+
+        def all_or_name(name)
+          name == 'all' ? 'all cops' : name
+        end
+      end
+    end
+  end
+end
+
+# rubocop:enable Lint/RedundantCopDisableDirective
+# rubocop:enable Lint/RedundantCopEnableDirective

data/lib/rubocop/cop/lint/redundant_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 RedundantRequireStatement < 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/redundant_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 RedundantSplatExpansion < 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)
+          redundant_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 redundant_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 redundant_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 redundant_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/redundant_string_coercion.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for string conversion in string interpolation,
+      # which is redundant.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   "result is #{something.to_s}"
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   "result is #{something}"
+      class RedundantStringCoercion < Cop
+        include Interpolation
+
+        MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'
+        MSG_SELF = 'Use `self` instead of `Object#to_s` in ' \
+                   'interpolation.'
+
+        def_node_matcher :to_s_without_args?, '(send _ :to_s)'
+
+        def on_interpolation(begin_node)
+          final_node = begin_node.children.last
+
+          return unless to_s_without_args?(final_node)
+
+          add_offense(final_node, location: :selector)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            receiver = node.receiver
+            corrector.replace(
+              node,
+              if receiver
+                receiver.source
+              else
+                'self'
+              end
+            )
+          end
+        end
+
+        private
+
+        def message(node)
+          node.receiver ? MSG_DEFAULT : MSG_SELF
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# 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
+        include RangeHelp
+
+        MSG_EACH_WITH_INDEX = 'Use `each` instead of `each_with_index`.'
+        MSG_WITH_INDEX = 'Remove redundant `with_index`.'
+
+        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, location: with_index_range(send))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            redundant_with_index?(node) do |send|
+              if send.method?(:each_with_index)
+                corrector.replace(send.loc.selector, 'each')
+              else
+                corrector.remove(with_index_range(send))
+                corrector.remove(send.loc.dot)
+              end
+            end
+          end
+        end
+
+        private
+
+        def message(node)
+          if node.method?(: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.expression.end_pos
+          )
+        end
+      end
+    end
+  end
+end