rubocop 1.11.0 → 1.12.0

data/lib/rubocop/cop/style/class_equality_comparison.rb

@@ -50,6 +50,8 @@ module RuboCop
 
         def class_name(class_node, node)
           if node.children.first.method?(:name)
+            return class_node.receiver.source if class_node.receiver
+
             class_node.source.delete('"').delete("'")
           else
             class_node.source

data/lib/rubocop/cop/style/command_literal.rb

@@ -165,7 +165,7 @@ module RuboCop
         end
 
         def preferred_delimiter
-          (command_delimiter || default_delimiter).split('')
+          (command_delimiter || default_delimiter).chars
         end
 
         def command_delimiter

data/lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb

@@ -70,8 +70,8 @@ module RuboCop
         end
 
         def directive_cops(comment)
-          match = CommentConfig::COMMENT_DIRECTIVE_REGEXP.match(comment.text)
-          match && match[2] ? match[2].split(',').map(&:strip) : []
+          match_captures = DirectiveComment.new(comment).match_captures
+          match_captures && match_captures[1] ? match_captures[1].split(',').map(&:strip) : []
         end
 
         def allowed_cops

data/lib/rubocop/cop/style/documentation.rb

@@ -60,6 +60,15 @@ module RuboCop
       #       extend Foo
       #     end
       #
+      # @example AllowedConstants: ['ClassMethods']
+      #
+      #    # good
+      #    module A
+      #      module ClassMethods
+      #        # ...
+      #      end
+      #     end
+      #
       class Documentation < Base
         include DocumentationComment
 
@@ -90,14 +99,19 @@ module RuboCop
 
         def check(node, body, type)
           return if namespace?(body)
-          return if documentation_comment?(node) || nodoc_comment?(node)
-          return if compact_namespace?(node) &&
-                    nodoc_comment?(outer_module(node).first)
+          return if documentation_comment?(node)
+          return if constant_allowed?(node)
+          return if nodoc_self_or_outer_module?(node)
           return if macro_only?(body)
 
           add_offense(node.loc.keyword, message: format(MSG, type: type))
         end
 
+        def nodoc_self_or_outer_module?(node)
+          nodoc_comment?(node) ||
+            compact_namespace?(node) && nodoc_comment?(outer_module(node).first)
+        end
+
         def macro_only?(body)
           body.respond_to?(:macro?) && body.macro? ||
             body.respond_to?(:children) && body.children&.all? { |child| macro_only?(child) }
@@ -117,6 +131,10 @@ module RuboCop
           constant_definition?(node) || constant_visibility_declaration?(node)
         end
 
+        def constant_allowed?(node)
+          allowed_constants.include?(node.identifier.short_name)
+        end
+
         def compact_namespace?(node)
           /::/.match?(node.loc.name.source)
         end
@@ -143,6 +161,10 @@ module RuboCop
         def nodoc(node)
           processed_source.ast_with_comments[node.children.first].first
         end
+
+        def allowed_constants
+          @allowed_constants ||= cop_config.fetch('AllowedConstants', []).map(&:intern)
+        end
       end
     end
   end

data/lib/rubocop/cop/style/eval_with_location.rb

@@ -224,7 +224,7 @@ module RuboCop
 
           register_offense(node) do |corrector|
             line_str = missing_line(node, code)
-            corrector.insert_after(node.loc.expression.end, ", __FILE__, #{line_str}")
+            corrector.insert_after(node.last_argument.source_range.end, ", __FILE__, #{line_str}")
           end
         end
 

data/lib/rubocop/cop/style/hash_syntax.rb

@@ -54,9 +54,10 @@ module RuboCop
       #   # good
       #   {a: 1, b: 2}
       #   {:c => 3, 'd' => 4}
-      class HashSyntax < Cop
+      class HashSyntax < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG_19 = 'Use the new Ruby 1.9 hash syntax.'
         MSG_NO_MIXED_KEYS = "Don't mix styles in the same hash."
@@ -104,18 +105,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if style == :hash_rockets || force_hash_rockets?(node.parent.pairs)
-              autocorrect_hash_rockets(corrector, node)
-            elsif style == :ruby19_no_mixed_keys || style == :no_mixed_keys
-              autocorrect_no_mixed_keys(corrector, node)
-            else
-              autocorrect_ruby19(corrector, node)
-            end
-          end
-        end
-
         def alternative_style
           case style
           when :hash_rockets
@@ -127,6 +116,16 @@ module RuboCop
 
         private
 
+        def autocorrect(corrector, node)
+          if style == :hash_rockets || force_hash_rockets?(node.parent.pairs)
+            autocorrect_hash_rockets(corrector, node)
+          elsif style == :ruby19_no_mixed_keys || style == :no_mixed_keys
+            autocorrect_no_mixed_keys(corrector, node)
+          else
+            autocorrect_ruby19(corrector, node)
+          end
+        end
+
         def sym_indices?(pairs)
           pairs.all? { |p| word_symbol_pair?(p) }
         end
@@ -152,14 +151,16 @@ module RuboCop
           return true if /\A[_a-z]\w*[?!]?\z/i.match?(sym_name)
 
           # For more complicated hash keys, let the parser validate the syntax.
-          parse("{ #{sym_name}: :foo }").valid_syntax?
+          ProcessedSource.new("{ #{sym_name}: :foo }", target_ruby_version).valid_syntax?
         end
 
         def check(pairs, delim, msg)
           pairs.each do |pair|
             if pair.delimiter == delim
               location = pair.source_range.begin.join(pair.loc.operator)
-              add_offense(pair, location: location, message: msg) do
+              add_offense(location, message: msg) do |corrector|
+                autocorrect(corrector, pair)
+
                 opposite_style_detected
               end
             else

data/lib/rubocop/cop/style/method_call_with_args_parentheses.rb

@@ -79,6 +79,30 @@ module RuboCop
       #   # good
       #   foo.enforce strict: true
       #
+      #   # good
+      #   # Allows parens for calls that won't produce valid Ruby or be ambiguous.
+      #   model.validate strict(true)
+      #
+      #   # good
+      #   # Allows parens for calls that won't produce valid Ruby or be ambiguous.
+      #   yield path, File.basename(path)
+      #
+      #   # good
+      #   # Operators methods calls with parens
+      #   array&.[](index)
+      #
+      #   # good
+      #   # Operators methods without parens, if you prefer
+      #   array.[] index
+      #
+      #   # good
+      #   # Operators methods calls with parens
+      #   array&.[](index)
+      #
+      #   # good
+      #   # Operators methods without parens, if you prefer
+      #   array.[] index
+      #
       # @example IgnoreMacros: true (default)
       #
       #   # good
@@ -146,6 +170,22 @@ module RuboCop
       #
       #   # good
       #   Array 1
+      #
+      # @example AllowParenthesesInStringInterpolation: false (default)
+      #
+      #   # bad
+      #   "#{t('this.is.bad')}"
+      #
+      #   # good
+      #   "#{t 'this.is.better'}"
+      #
+      # @example AllowParenthesesInStringInterpolation: true
+      #
+      #   # good
+      #   "#{t('this.is.good')}"
+      #
+      #   # good
+      #   "#{t 'this.is.also.good'}"
       class MethodCallWithArgsParentheses < Base
         require_relative 'method_call_with_args_parentheses/omit_parentheses'
         require_relative 'method_call_with_args_parentheses/require_parentheses'

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -5,6 +5,7 @@ module RuboCop
     module Style
       class MethodCallWithArgsParentheses
         # Style omit_parentheses
+        # rubocop:disable Metrics/ModuleLength
         module OmitParentheses
           TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
           OMIT_MSG = 'Omit parentheses for method calls with arguments.'
@@ -12,18 +13,21 @@ module RuboCop
 
           private
 
+          # rubocop:disable Metrics/CyclomaticComplexity
           def omit_parentheses(node)
             return unless node.parenthesized?
             return if inside_endless_method_def?(node)
-            return if node.implicit_call?
+            return if syntax_like_method_call?(node)
             return if super_call_without_arguments?(node)
             return if allowed_camel_case_method_call?(node)
             return if legitimate_call_with_parentheses?(node)
+            return if allowed_string_interpolation_method_call?(node)
 
             add_offense(offense_range(node), message: OMIT_MSG) do |corrector|
               auto_correct(corrector, node)
             end
           end
+          # rubocop:enable Metrics/CyclomaticComplexity
 
           def auto_correct(corrector, node)
             if parentheses_at_the_end_of_multiline_call?(node)
@@ -43,6 +47,10 @@ module RuboCop
             node.each_ancestor(:def).any?(&:endless?) && node.arguments.any?
           end
 
+          def syntax_like_method_call?(node)
+            node.implicit_call? || node.operator_method?
+          end
+
           def super_call_without_arguments?(node)
             node.super_type? && node.arguments.none?
           end
@@ -53,6 +61,11 @@ module RuboCop
               cop_config['AllowParenthesesInCamelCaseMethod'])
           end
 
+          def allowed_string_interpolation_method_call?(node)
+            cop_config['AllowParenthesesInStringInterpolation'] &&
+              inside_string_interpolation?(node)
+          end
+
           def parentheses_at_the_end_of_multiline_call?(node)
             node.multiline? &&
               node.loc.begin.source_line
@@ -114,7 +127,7 @@ module RuboCop
           def call_as_argument_or_chain?(node)
             node.parent &&
               (node.parent.send_type? && !assigned_before?(node.parent, node) ||
-              node.parent.csend_type? || node.parent.super_type?)
+              node.parent.csend_type? || node.parent.super_type? || node.parent.yield_type?)
           end
 
           def hash_literal_in_arguments?(node)
@@ -172,7 +185,12 @@ module RuboCop
             node.assignment? &&
               node.loc.operator.begin < target.loc.begin
           end
+
+          def inside_string_interpolation?(node)
+            node.ancestors.drop_while { |a| !a.begin_type? }.any?(&:dstr_type?)
+          end
         end
+        # rubocop:enable Metrics/ModuleLength
       end
     end
   end

data/lib/rubocop/cop/style/negated_if_else_condition.rb

@@ -29,6 +29,7 @@ module RuboCop
       #
       class NegatedIfElseCondition < Base
         include RangeHelp
+        include CommentsHelp
         extend AutoCorrector
 
         MSG = 'Invert the negated condition and swap the %<type>s branches.'
@@ -97,10 +98,22 @@ module RuboCop
           if node.if_branch.nil?
             corrector.remove(range_by_whole_lines(node.loc.else, include_final_newline: true))
           else
-            corrector.replace(node.if_branch, node.else_branch.source)
-            corrector.replace(node.else_branch, node.if_branch.source)
+            if_range = node_with_comments(node.if_branch)
+            else_range = node_with_comments(node.else_branch)
+
+            corrector.replace(if_range, else_range.source)
+            corrector.replace(else_range, if_range.source)
           end
         end
+
+        def node_with_comments(node)
+          first_statement = node.begin_type? ? node.children[0] : node
+          return node if processed_source.ast_with_comments[first_statement].empty?
+
+          begin_pos = source_range_with_comment(first_statement).begin_pos
+          end_pos = node.source_range.end_pos
+          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+        end
       end
     end
   end

data/lib/rubocop/cop/style/redundant_begin.rb

@@ -63,6 +63,7 @@ module RuboCop
       #     end
       #   end
       class RedundantBegin < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Redundant `begin` block detected.'
@@ -95,12 +96,26 @@ module RuboCop
         private
 
         def register_offense(node)
-          add_offense(node.loc.begin) do |corrector|
-            corrector.remove(node.loc.begin)
+          offense_range = node.loc.begin
+
+          add_offense(offense_range) do |corrector|
+            if any_ancestor_assignment_node?(node)
+              replace_begin_with_statement(corrector, offense_range, node)
+            else
+              corrector.remove(offense_range)
+            end
+
             corrector.remove(node.loc.end)
           end
         end
 
+        def replace_begin_with_statement(corrector, offense_range, node)
+          first_child = node.children.first
+
+          corrector.replace(offense_range, first_child.source)
+          corrector.remove(range_between(offense_range.end_pos, first_child.source_range.end_pos))
+        end
+
         def empty_begin?(node)
           node.children.empty?
         end
@@ -114,9 +129,17 @@ module RuboCop
         def valid_context_using_only_begin?(node)
           parent = node.parent
 
-          node.each_ancestor.any?(&:assignment?) || parent&.post_condition_loop? ||
+          valid_begin_assignment?(node) || parent&.post_condition_loop? ||
             parent&.send_type? || parent&.operator_keyword?
         end
+
+        def valid_begin_assignment?(node)
+          any_ancestor_assignment_node?(node) && !node.children.one?
+        end
+
+        def any_ancestor_assignment_node?(node)
+          node.each_ancestor.any?(&:assignment?)
+        end
       end
     end
   end

data/lib/rubocop/cop/style/redundant_return.rb

@@ -71,6 +71,10 @@ module RuboCop
           elsif hash_without_braces?(return_node.first_argument)
             add_braces(corrector, return_node.first_argument)
           end
+          if return_node.splat_argument?
+            first_argument = return_node.first_argument
+            corrector.replace(first_argument, first_argument.source.gsub(/\A\*/, ''))
+          end
 
           keyword = range_with_surrounding_space(range: return_node.loc.keyword,
                                                  side: :right)

data/lib/rubocop/cop/style/redundant_self.rb

@@ -11,7 +11,7 @@ module RuboCop
       #   presence of a method name clash with an argument or a local
       #   variable.
       #
-      # * Calling an attribute writer to prevent an local variable assignment.
+      # * Calling an attribute writer to prevent a local variable assignment.
       #
       # Note, with using explicit self you can only send messages with public or
       # protected scope, you cannot send private messages this way.
@@ -144,8 +144,12 @@ module RuboCop
         end
 
         def on_argument(node)
-          name, = *node
-          @local_variables_scopes[node] << name
+          if node.mlhs_type?
+            on_args(node)
+          else
+            name, = *node
+            @local_variables_scopes[node] << name
+          end
         end
 
         def allow_self(node)

data/lib/rubocop/cop/style/regexp_literal.rb

@@ -150,7 +150,7 @@ module RuboCop
 
         def preferred_delimiters
           config.for_cop('Style/PercentLiteralDelimiters') \
-            ['PreferredDelimiters']['%r'].split('')
+            ['PreferredDelimiters']['%r'].chars
         end
 
         def correct_delimiters(node, corrector)

data/lib/rubocop/cop/style/rescue_modifier.rb

@@ -39,23 +39,23 @@ module RuboCop
       #   rescue SomeException
       #     handle_error
       #   end
-      class RescueModifier < Cop
+      class RescueModifier < Base
         include Alignment
+        include RangeHelp
         include RescueNode
+        extend AutoCorrector
 
         MSG = 'Avoid using `rescue` in its modifier form.'
 
         def on_resbody(node)
           return unless rescue_modifier?(node)
 
-          add_offense(node.parent)
-        end
+          rescue_node = node.parent
+          add_offense(rescue_node) do |corrector|
+            parenthesized = parenthesized?(rescue_node)
 
-        def autocorrect(node)
-          parenthesized = parenthesized?(node)
-          lambda do |corrector|
-            corrector.replace(node, corrected_block(node, parenthesized))
-            ParenthesesCorrector.correct(corrector, node.parent) if parenthesized
+            correct_rescue_block(corrector, rescue_node, parenthesized)
+            ParenthesesCorrector.correct(corrector, rescue_node.parent) if parenthesized
           end
         end
 
@@ -65,17 +65,20 @@ module RuboCop
           node.parent && parentheses?(node.parent)
         end
 
-        def corrected_block(node, parenthesized)
+        def correct_rescue_block(corrector, node, parenthesized)
           operation, rescue_modifier, = *node
           *_, rescue_args = *rescue_modifier
 
           node_indentation, node_offset = indentation_and_offset(node, parenthesized)
 
-          "begin\n" \
-            "#{operation.source.gsub(/^/, node_indentation)}" \
-            "\n#{node_offset}rescue\n" \
-            "#{rescue_args.source.gsub(/^/, node_indentation)}" \
-            "\n#{node_offset}end"
+          corrector.remove(range_between(operation.source_range.end_pos, node.source_range.end_pos))
+          corrector.insert_before(operation, "begin\n#{node_indentation}")
+          corrector.insert_after(operation, <<~RESCUE_CLAUSE.chop)
+
+            #{node_offset}rescue
+            #{node_indentation}#{rescue_args.source}
+            #{node_offset}end
+          RESCUE_CLAUSE
         end
 
         def indentation_and_offset(node, parenthesized)