rubocop 0.75.1

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for space between the name of a called method and a left
+      # parenthesis.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   puts (x + y)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   puts(x + y)
+      class ParenthesesAsGroupedExpression < Cop
+        include RangeHelp
+
+        MSG = '`(...)` interpreted as grouped expression.'
+
+        def on_send(node)
+          return unless node.arguments.one?
+          return if node.operator_method? || node.setter_method?
+
+          return unless node.first_argument.source.start_with?('(')
+
+          space_length = spaces_before_left_parenthesis(node)
+          return unless space_length.positive?
+
+          range = space_range(node.first_argument.source_range, space_length)
+
+          add_offense(nil, location: range)
+        end
+        alias on_csend on_send
+
+        private
+
+        def spaces_before_left_parenthesis(node)
+          receiver = node.receiver
+          receiver_length = if receiver
+                              receiver.source.length
+                            else
+                              0
+                            end
+          without_receiver = node.source[receiver_length..-1]
+
+          # Escape question mark if any.
+          method_regexp = Regexp.escape(node.method_name)
+
+          match = without_receiver.match(/^\s*&?\.?\s*#{method_regexp}(\s+)\(/)
+          match ? match.captures[0].length : 0
+        end
+
+        def space_range(expr, space_length)
+          range_between(expr.begin_pos - space_length, expr.begin_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for quotes and commas in %w, e.g. `%w('foo', "bar")`
+      #
+      # It is more likely that the additional characters are unintended (for
+      # example, mistranslating an array of literals to percent string notation)
+      # rather than meant to be part of the resulting strings.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   %w('foo', "bar")
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   %w(foo bar)
+      class PercentStringArray < Cop
+        include PercentLiteral
+
+        QUOTES_AND_COMMAS = [/,$/, /^'.*'$/, /^".*"$/].freeze
+        LEADING_QUOTE = /^['"]/.freeze
+        TRAILING_QUOTE = /['"]?,?$/.freeze
+
+        MSG = "Within `%w`/`%W`, quotes and ',' are unnecessary and may be " \
+          'unwanted in the resulting strings.'
+
+        def on_array(node)
+          process(node, '%w', '%W')
+        end
+
+        def on_percent_literal(node)
+          return unless contains_quotes_or_commas?(node)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            node.values.each do |value|
+              range = value.loc.expression
+
+              match = range.source.match(TRAILING_QUOTE)
+              corrector.remove_trailing(range, match[0].length) if match
+
+              if range.source =~ LEADING_QUOTE
+                corrector.remove_leading(range, 1)
+              end
+            end
+          end
+        end
+
+        private
+
+        def contains_quotes_or_commas?(node)
+          node.values.any? do |value|
+            literal = value.children.first.to_s.scrub
+
+            # To avoid likely false positives (e.g. a single ' or ")
+            next if literal.gsub(/[^[[:alnum:]]]/, '').empty?
+
+            QUOTES_AND_COMMAS.any? { |pat| literal =~ pat }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for colons and commas in %i, e.g. `%i(:foo, :bar)`
+      #
+      # It is more likely that the additional characters are unintended (for
+      # example, mistranslating an array of literals to percent string notation)
+      # rather than meant to be part of the resulting symbols.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   %i(:foo, :bar)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   %i(foo bar)
+      class PercentSymbolArray < Cop
+        include PercentLiteral
+
+        MSG = "Within `%i`/`%I`, ':' and ',' are unnecessary and may be " \
+          'unwanted in the resulting symbols.'
+
+        def on_array(node)
+          process(node, '%i', '%I')
+        end
+
+        def on_percent_literal(node)
+          return unless contains_colons_or_commas?(node)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            node.children.each do |child|
+              range = child.loc.expression
+
+              corrector.remove_trailing(range, 1) if range.source.end_with?(',')
+              corrector.remove_leading(range, 1) if
+                range.source.start_with?(':')
+            end
+          end
+        end
+
+        private
+
+        def contains_colons_or_commas?(node)
+          node.children.any? do |child|
+            literal = child.children.first.to_s
+
+            next if non_alphanumeric_literal?(literal)
+
+            literal.start_with?(':') || literal.end_with?(',')
+          end
+        end
+
+        def non_alphanumeric_literal?(literal)
+          literal !~ /[[:alnum:]]/
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for `rand(1)` calls.
+      # Such calls always return `0`.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   rand 1
+      #   Kernel.rand(-1)
+      #   rand 1.0
+      #   rand(-1.0)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   0 # just use 0 instead
+      class RandOne < Cop
+        MSG = '`%<method>s` always returns `0`. ' \
+              'Perhaps you meant `rand(2)` or `rand`?'
+
+        def_node_matcher :rand_one?, <<~PATTERN
+          (send {(const nil? :Kernel) nil?} :rand {(int {-1 1}) (float {-1.0 1.0})})
+        PATTERN
+
+        def on_send(node)
+          return unless rand_one?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def message(node)
+          format(MSG, method: node.source)
+        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_name == :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_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.expression.end_pos
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for redundant `with_object`.
+      #
+      # @example
+      #   # bad
+      #   ary.each_with_object([]) do |v|
+      #     v
+      #   end
+      #
+      #   # good
+      #   ary.each do |v|
+      #     v
+      #   end
+      #
+      #   # bad
+      #   ary.each.with_object([]) do |v|
+      #     v
+      #   end
+      #
+      #   # good
+      #   ary.each do |v|
+      #     v
+      #   end
+      #
+      class RedundantWithObject < Cop
+        include RangeHelp
+
+        MSG_EACH_WITH_OBJECT = 'Use `each` instead of `each_with_object`.'
+
+        MSG_WITH_OBJECT = 'Remove redundant `with_object`.'
+
+        def_node_matcher :redundant_with_object?, <<~PATTERN
+          (block
+            $(send _ {:each_with_object :with_object}
+              _)
+            (args
+              (arg _))
+            ...)
+        PATTERN
+
+        def on_block(node)
+          redundant_with_object?(node) do |send|
+            add_offense(node, location: with_object_range(send))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            redundant_with_object?(node) do |send|
+              if send.method_name == :each_with_object
+                corrector.replace(with_object_range(send), 'each')
+              else
+                corrector.remove(with_object_range(send))
+                corrector.remove(send.loc.dot)
+              end
+            end
+          end
+        end
+
+        private
+
+        def message(node)
+          if node.method_name == :each_with_object
+            MSG_EACH_WITH_OBJECT
+          else
+            MSG_WITH_OBJECT
+          end
+        end
+
+        def with_object_range(send)
+          range_between(
+            send.loc.selector.begin_pos,
+            send.loc.expression.end_pos
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for regexp literals used as `match-current-line`.
+      # If a regexp literal is in condition, the regexp matches `$_` implicitly.
+      #
+      # @example
+      #   # bad
+      #   if /foo/
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if /foo/ =~ $_
+      #     do_something
+      #   end
+      class RegexpAsCondition < Cop
+        MSG = 'Do not use regexp literal as a condition.' \
+              ' The regexp literal matches `$_` implicitly.'
+
+        def on_match_current_line(node)
+          add_offense(node)
+        end
+      end
+    end
+  end
+end