rubocop 0.51.0 → 0.87.0

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop warns the usage of unsafe number conversions. Unsafe
+      # number conversion can cause unexpected error if auto type conversion
+      # fails. Cop prefer parsing with number class instead.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   '10'.to_i
+      #   '10.2'.to_f
+      #   '10'.to_c
+      #
+      #   # good
+      #
+      #   Integer('10', 10)
+      #   Float('10.2')
+      #   Complex('10')
+      class NumberConversion < Cop
+        CONVERSION_METHOD_CLASS_MAPPING = {
+          to_i: "#{Integer.name}(%<number_object>s, 10)",
+          to_f: "#{Float.name}(%<number_object>s)",
+          to_c: "#{Complex.name}(%<number_object>s)"
+        }.freeze
+        MSG = 'Replace unsafe number conversion with number '\
+              'class parsing, instead of using '\
+              '%<number_object>s.%<to_method>s, use stricter '\
+              '%<corrected_method>s.'
+
+        def_node_matcher :to_method, <<~PATTERN
+          (send $_ ${:to_i :to_f :to_c})
+        PATTERN
+
+        def_node_matcher :datetime?, <<~PATTERN
+          (send (const {nil? (cbase)} {:Time :DateTime}) ...)
+        PATTERN
+
+        def on_send(node)
+          to_method(node) do |receiver, to_method|
+            next if receiver.nil? || date_time_object?(receiver)
+
+            message = format(
+              MSG,
+              number_object: receiver.source,
+              to_method: to_method,
+              corrected_method: correct_method(node, receiver)
+            )
+            add_offense(node, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node,
+                              correct_method(node, node.receiver))
+          end
+        end
+
+        private
+
+        def date_time_object?(node)
+          child = node
+          while child&.send_type?
+            return true if datetime? child
+
+            child = child.children[0]
+          end
+        end
+
+        def correct_method(node, receiver)
+          format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name],
+                 number_object: receiver.source)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      #
+      # Checks the proper ordering of magic comments and whether
+      # a magic comment is not placed before a shebang.
+      #
+      # @example
+      #   # bad
+      #
+      #   # frozen_string_literal: true
+      #   # encoding: ascii
+      #   p [''.frozen?, ''.encoding] #=> [true, #<Encoding:UTF-8>]
+      #
+      #   # good
+      #
+      #   # encoding: ascii
+      #   # frozen_string_literal: true
+      #   p [''.frozen?, ''.encoding] #=> [true, #<Encoding:US-ASCII>]
+      #
+      #   # good
+      #
+      #   #!/usr/bin/env ruby
+      #   # encoding: ascii
+      #   # frozen_string_literal: true
+      #   p [''.frozen?, ''.encoding] #=> [true, #<Encoding:US-ASCII>]
+      #
+      class OrderedMagicComments < Cop
+        include FrozenStringLiteral
+
+        MSG = 'The encoding magic comment should precede all other ' \
+              'magic comments.'
+
+        def investigate(processed_source)
+          return if processed_source.buffer.source.empty?
+
+          encoding_line, frozen_string_literal_line = magic_comment_lines
+
+          return unless encoding_line && frozen_string_literal_line
+          return if encoding_line < frozen_string_literal_line
+
+          range = processed_source.buffer.line_range(encoding_line + 1)
+
+          add_offense(range, location: range)
+        end
+
+        def autocorrect(_node)
+          encoding_line, frozen_string_literal_line = magic_comment_lines
+
+          range1 = processed_source.buffer.line_range(encoding_line + 1)
+          range2 =
+            processed_source.buffer.line_range(frozen_string_literal_line + 1)
+
+          lambda do |corrector|
+            corrector.replace(range1, range2.source)
+            corrector.replace(range2, range1.source)
+          end
+        end
+
+        private
+
+        def magic_comment_lines
+          lines = [nil, nil]
+
+          magic_comments.each.with_index do |comment, index|
+            if comment.encoding_specified?
+              lines[0] = index
+            elsif comment.frozen_string_literal_specified?
+              lines[1] = index
+            end
+
+            return lines if lines[0] && lines[1]
+          end
+
+          lines
+        end
+
+        def magic_comments
+          leading_comment_lines.map { |line| MagicComment.parse(line) }
+        end
+      end
+    end
+  end
+end

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

@@ -3,39 +3,69 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for space between a the name of a called method and a left
+      # Checks for space between the name of a called method and a left
       # parenthesis.
       #
       # @example
       #
       #   # bad
-      #
-      #   puts (x + y)
-      #
-      # @example
+      #   do_something (foo)
       #
       #   # good
-      #
-      #   puts(x + y)
+      #   do_something(foo)
+      #   do_something (2 + 3) * 4
+      #   do_something (foo * bar).baz
       class ParenthesesAsGroupedExpression < Cop
-        MSG = '`(...)` interpreted as grouped expression.'.freeze
+        include RangeHelp
 
-        def on_send(node)
-          return unless node.arguments.one?
-          return if node.operator_method? || node.setter_method?
+        MSG = '`(...)` interpreted as grouped expression.'
 
-          return unless node.first_argument.source.start_with?('(')
+        def on_send(node)
+          return if valid_context?(node)
 
           space_length = spaces_before_left_parenthesis(node)
-          return unless space_length > 0
+          return unless space_length.positive?
+
+          range = space_range(node.first_argument.source_range, space_length)
+
+          add_offense(node, location: range)
+        end
+        alias on_csend on_send
 
+        def autocorrect(node)
+          space_length = spaces_before_left_parenthesis(node)
           range = space_range(node.first_argument.source_range, space_length)
 
-          add_offense(nil, location: range)
+          lambda do |corrector|
+            corrector.remove(range)
+          end
         end
 
         private
 
+        def valid_context?(node)
+          unless node.arguments.one? && first_argument_starts_with_left_parenthesis?(node)
+            return true
+          end
+
+          node.operator_method? || node.setter_method? || chained_calls?(node) ||
+            operator_keyword?(node)
+        end
+
+        def first_argument_starts_with_left_parenthesis?(node)
+          node.first_argument.source.start_with?('(')
+        end
+
+        def chained_calls?(node)
+          first_argument = node.first_argument
+          first_argument.send_type? && (node.children.last&.children&.count || 0) > 1
+        end
+
+        def operator_keyword?(node)
+          first_argument = node.first_argument
+          first_argument.operator_keyword?
+        end
+
         def spaces_before_left_parenthesis(node)
           receiver = node.receiver
           receiver_length = if receiver
@@ -48,7 +78,7 @@ module RuboCop
           # Escape question mark if any.
           method_regexp = Regexp.escape(node.method_name)
 
-          match = without_receiver.match(/^\s*\.?\s*#{method_regexp}(\s+)\(/)
+          match = without_receiver.match(/^\s*&?\.?\s*#{method_regexp}(\s+)\(/)
           match ? match.captures[0].length : 0
         end
 

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

@@ -24,11 +24,11 @@ module RuboCop
         include PercentLiteral
 
         QUOTES_AND_COMMAS = [/,$/, /^'.*'$/, /^".*"$/].freeze
-        LEADING_QUOTE = /^['"]/
-        TRAILING_QUOTE = /['"]?,?$/
+        LEADING_QUOTE = /^['"]/.freeze
+        TRAILING_QUOTE = /['"]?,?$/.freeze
 
         MSG = "Within `%w`/`%W`, quotes and ',' are unnecessary and may be " \
-          'unwanted in the resulting strings.'.freeze
+          'unwanted in the resulting strings.'
 
         def on_array(node)
           process(node, '%w', '%W')
@@ -40,35 +40,31 @@ module RuboCop
           add_offense(node)
         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(/[^\p{Alnum}]/, '').empty?
-
-            QUOTES_AND_COMMAS.any? { |pat| literal =~ pat }
-          end
-        end
-
-        # rubocop:disable Performance/HashEachMethods
         def autocorrect(node)
           lambda do |corrector|
-            node.values.each do |value|
+            node.each_value 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
+              corrector.remove_leading(range, 1) if LEADING_QUOTE.match?(range.source)
             end
           end
         end
-        # rubocop:enable Performance/HashEachMethod
+
+        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.match?(pat) }
+          end
+        end
       end
     end
   end

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

@@ -24,7 +24,7 @@ module RuboCop
         include PercentLiteral
 
         MSG = "Within `%i`/`%I`, ':' and ',' are unnecessary and may be " \
-          'unwanted in the resulting symbols.'.freeze
+          'unwanted in the resulting symbols.'
 
         def on_array(node)
           process(node, '%i', '%I')
@@ -36,29 +36,32 @@ module RuboCop
           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)
-          patterns = [/^:/, /,$/]
           node.children.any? do |child|
-            literal = child.children.first
+            literal = child.children.first.to_s
 
-            # To avoid likely false positives (e.g. a single ' or ")
-            next if literal.to_s.gsub(/[^\p{Alnum}]/, '').empty?
+            next if non_alphanumeric_literal?(literal)
 
-            patterns.any? { |pat| literal =~ pat }
+            literal.start_with?(':') || literal.end_with?(',')
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            node.children.each do |child|
-              range = child.loc.expression
-
-              corrector.remove_trailing(range, 1) if /,$/ =~ range.source
-              corrector.remove_leading(range, 1) if /^:/ =~ range.source
-            end
-          end
+        def non_alphanumeric_literal?(literal)
+          !/[[:alnum:]]/.match?(literal)
         end
       end
     end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for `raise` or `fail` statements which are
+      # raising `Exception` class.
+      #
+      # You can specify a module name that will be an implicit namespace
+      # using `AllowedImplicitNamespaces` option. The cop cause a false positive
+      # for namespaced `Exception` when a namespace is omitted. This option can
+      # prevent the false positive by specifying a namespace to be omitted for
+      # `Exception`. Alternatively, make `Exception` a fully qualified class
+      # name with an explicit namespace.
+      #
+      # @example
+      #   # bad
+      #   raise Exception, 'Error message here'
+      #
+      #   # good
+      #   raise StandardError, 'Error message here'
+      #
+      # @example AllowedImplicitNamespaces: ['Gem']
+      #   # good
+      #   module Gem
+      #     def self.foo
+      #       raise Exception # This exception means `Gem::Exception`.
+      #     end
+      #   end
+      class RaiseException < Cop
+        MSG = 'Use `StandardError` over `Exception`.'
+
+        def_node_matcher :exception?, <<~PATTERN
+          (send nil? {:raise :fail} $(const ${cbase nil?} :Exception) ... )
+        PATTERN
+
+        def_node_matcher :exception_new_with_message?, <<~PATTERN
+          (send nil? {:raise :fail}
+            (send $(const ${cbase nil?} :Exception) :new ... ))
+        PATTERN
+
+        def on_send(node)
+          exception?(node, &check(node)) ||
+            exception_new_with_message?(node, &check(node))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            exception_class = node.children.first&.cbase_type? ? '::StandardError' : 'StandardError'
+
+            corrector.replace(node, exception_class)
+          end
+        end
+
+        private
+
+        def check(node)
+          lambda do |exception_class, cbase|
+            return if cbase.nil? && implicit_namespace?(node)
+
+            add_offense(exception_class)
+          end
+        end
+
+        def implicit_namespace?(node)
+          return false unless (parent = node.parent)
+
+          if parent.module_type?
+            namespace = parent.identifier.source
+
+            return allow_implicit_namespaces.include?(namespace)
+          end
+
+          implicit_namespace?(parent)
+        end
+
+        def allow_implicit_namespaces
+          cop_config['AllowedImplicitNamespaces'] || []
+        end
+      end
+    end
+  end
+end

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

@@ -21,11 +21,11 @@ module RuboCop
       #
       #   0 # just use 0 instead
       class RandOne < Cop
-        MSG = '`%s` always returns `0`. ' \
-              'Perhaps you meant `rand(2)` or `rand`?'.freeze
+        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})})
+        def_node_matcher :rand_one?, <<~PATTERN
+          (send {(const {nil? cbase} :Kernel) nil?} :rand {(int {-1 1}) (float {-1.0 1.0})})
         PATTERN
 
         def on_send(node)
@@ -37,7 +37,7 @@ module RuboCop
         private
 
         def message(node)
-          format(MSG, node.source)
+          format(MSG, method: node.source)
         end
       end
     end