rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,84 +5,181 @@ module RuboCop
     module Style
       # This cop checks for braces around the last parameter in a method call
       # if the last parameter is a hash.
+      # It supports `braces`, `no_braces` and `context_dependent` styles.
+      #
+      # @example EnforcedStyle: braces
+      #   # The `braces` style enforces braces around all method
+      #   # parameters that are hashes.
+      #
+      #   # bad
+      #   some_method(x, y, a: 1, b: 2)
+      #
+      #   # good
+      #   some_method(x, y, {a: 1, b: 2})
+      #
+      # @example EnforcedStyle: no_braces (default)
+      #   # The `no_braces` style checks that the last parameter doesn't
+      #   # have braces around it.
+      #
+      #   # bad
+      #   some_method(x, y, {a: 1, b: 2})
+      #
+      #   # good
+      #   some_method(x, y, a: 1, b: 2)
+      #
+      # @example EnforcedStyle: context_dependent
+      #   # The `context_dependent` style checks that the last parameter
+      #   # doesn't have braces around it, but requires braces if the
+      #   # second to last parameter is also a hash literal.
+      #
+      #   # bad
+      #   some_method(x, y, {a: 1, b: 2})
+      #   some_method(x, y, {a: 1, b: 2}, a: 1, b: 2)
+      #
+      #   # good
+      #   some_method(x, y, a: 1, b: 2)
+      #   some_method(x, y, {a: 1, b: 2}, {a: 1, b: 2})
       class BracesAroundHashParameters < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = '%s curly braces around a hash parameter.'.freeze
+        MSG = '%<type>s curly braces around a hash parameter.'.freeze
 
         def on_send(node)
-          _receiver, method_name, *args = *node
+          return if node.assignment_method? || node.operator_method?
 
-          # Discard attr writer methods.
-          return if node.asgn_method_call?
-          # Discard operator methods.
-          return if operator?(method_name)
+          return unless node.arguments? && node.last_argument.hash_type? &&
+                        !node.last_argument.empty?
 
-          # We care only for the last argument.
-          arg = args.last
+          check(node.last_argument, node.arguments)
+        end
 
-          check(arg, args) if non_empty_hash?(arg)
+        # We let AutocorrectUnlessChangingAST#autocorrect work with the send
+        # node, because that context is needed. When parsing the code to see if
+        # the AST has changed, a braceless hash would not be parsed as a hash
+        # otherwise.
+        def autocorrect(send_node)
+          hash_node = send_node.last_argument
+
+          lambda do |corrector|
+            if hash_node.braces?
+              remove_braces_with_whitespace(corrector,
+                                            hash_node,
+                                            extra_space(hash_node))
+            else
+              add_braces(corrector, hash_node)
+            end
+          end
         end
 
         private
 
         def check(arg, args)
-          if style == :braces && !braces?(arg)
-            add_offense(arg.parent, arg.source_range, format(MSG, 'Missing'))
-          elsif style == :no_braces && braces?(arg)
-            add_offense(arg.parent, arg.source_range,
-                        format(MSG, 'Redundant'))
+          if style == :braces && !arg.braces?
+            add_arg_offense(arg, :missing)
+          elsif style == :no_braces && arg.braces?
+            add_arg_offense(arg, :redundant)
           elsif style == :context_dependent
             check_context_dependent(arg, args)
           end
         end
 
         def check_context_dependent(arg, args)
-          braces_around_2nd_from_end = args.length > 1 && args[-2].type == :hash
-          if braces?(arg)
-            unless braces_around_2nd_from_end
-              add_offense(arg.parent, arg.source_range,
-                          format(MSG, 'Redundant'))
+          braces_around_second_from_end = args.size > 1 && args[-2].hash_type?
+
+          if arg.braces?
+            unless braces_around_second_from_end
+              add_arg_offense(arg, :redundant)
             end
-          elsif braces_around_2nd_from_end
-            add_offense(arg.parent, arg.source_range, format(MSG, 'Missing'))
+          elsif braces_around_second_from_end
+            add_arg_offense(arg, :missing)
           end
         end
 
-        # We let AutocorrectUnlessChangingAST#autocorrect work with the send
-        # node, because that context is needed. When parsing the code to see if
-        # the AST has changed, a braceless hash would not be parsed as a hash
-        # otherwise.
-        def autocorrect(send_node)
-          _receiver, _method_name, *args = *send_node
-          node = args.last
-          lambda do |corrector|
-            if braces?(node)
-              remove_braces_with_whitespace(corrector, node)
-            else
-              add_braces(corrector, node)
-            end
+        def add_arg_offense(arg, type)
+          add_offense(arg.parent, location: arg.source_range,
+                                  message: format(MSG,
+                                                  type: type.to_s.capitalize))
+        end
+
+        def extra_space(hash_node)
+          {
+            newlines: extra_left_space?(hash_node) &&
+              extra_right_space?(hash_node),
+            left: extra_left_space?(hash_node),
+            right: extra_right_space?(hash_node)
+          }
+        end
+
+        def extra_left_space?(hash_node)
+          @extra_left_space ||= begin
+            top_line = hash_node.source_range.source_line
+            top_line.delete(' ') == '{'
+          end
+        end
+
+        def extra_right_space?(hash_node)
+          @extra_right_space ||= begin
+            bottom_line_number = hash_node.source_range.last_line
+            bottom_line = processed_source.lines[bottom_line_number - 1]
+            bottom_line.delete(' ') == '}'
           end
         end
 
-        def remove_braces_with_whitespace(corrector, node)
-          right_brace_and_space = right_brace_and_space(node.loc.end)
+        # rubocop:disable Metrics/AbcSize
+        def remove_braces_with_whitespace(corrector, node, space)
+          right_brace_and_space = right_brace_and_space(node.loc.end, space)
 
           if comment_on_line?(right_brace_and_space.line)
-            # Removing a line break between a comment and the closing
-            # parenthesis would cause a syntax error, so we only remove the
-            # braces in that case.
             remove_braces(corrector, node)
+          elsif node.multiline?
+            remove_braces_with_range(corrector,
+                                     left_whole_line_range(node.loc.begin),
+                                     right_whole_line_range(node.loc.end))
+          else
+            left_brace_and_space = left_brace_and_space(node.loc.begin, space)
+            remove_braces_with_range(corrector,
+                                     left_brace_and_space,
+                                     right_brace_and_space)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def remove_braces_with_range(corrector, left_range, right_range)
+          corrector.remove(left_range)
+          corrector.remove(right_range)
+        end
+
+        def left_whole_line_range(loc_begin)
+          if range_by_whole_lines(loc_begin).source.strip == '{'
+            range_by_whole_lines(loc_begin, include_final_newline: true)
           else
-            left_brace_and_space = range_with_surrounding_space(node.loc.begin,
-                                                                :right)
-            corrector.remove(left_brace_and_space)
-            corrector.remove(right_brace_and_space)
+            loc_begin
           end
         end
 
-        def right_brace_and_space(loc_end)
-          brace_and_space = range_with_surrounding_space(loc_end, :left)
+        def right_whole_line_range(loc_end)
+          if range_by_whole_lines(loc_end).source.strip == '}'
+            range_by_whole_lines(loc_end, include_final_newline: true)
+          else
+            loc_end
+          end
+        end
+
+        def left_brace_and_space(loc_begin, space)
+          range_with_surrounding_space(range: loc_begin,
+                                       side: :right,
+                                       newlines: space[:newlines],
+                                       whitespace: space[:left])
+        end
+
+        def right_brace_and_space(loc_end, space)
+          brace_and_space =
+            range_with_surrounding_space(
+              range: loc_end,
+              side: :left,
+              newlines: space[:newlines],
+              whitespace: space[:right]
+            )
           range_with_surrounding_comma(brace_and_space, :left)
         end
 
@@ -100,14 +196,6 @@ module RuboCop
           corrector.insert_before(node.source_range, '{')
           corrector.insert_after(node.source_range, '}')
         end
-
-        def non_empty_hash?(arg)
-          arg && arg.type == :hash && arg.children.any?
-        end
-
-        def braces?(arg)
-          arg.loc.begin
-        end
       end
     end
   end

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

@@ -1,17 +1,28 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop checks for uses of the case equality operator(===).
+      #
+      # @example
+      #   # bad
+      #   Array === something
+      #   (1..100) === 7
+      #   /something/ === some_string
+      #
+      #   # good
+      #   something.is_a?(Array)
+      #   (1..100).include?(7)
+      #   some_string =~ /something/
+      #
       class CaseEquality < Cop
         MSG = 'Avoid the use of the case equality operator `===`.'.freeze
 
-        def on_send(node)
-          _receiver, method_name, *_args = *node
+        def_node_matcher :case_equality?, '(send _ :=== _)'
 
-          add_offense(node, :selector) if method_name == :===
+        def on_send(node)
+          case_equality?(node) { add_offense(node, location: :selector) }
         end
       end
     end

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

@@ -1,10 +1,19 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # Checks for uses of the character literal ?x.
+      #
+      # @example
+      #   # bad
+      #   ?x
+      #
+      #   # good
+      #   'x'
+      #
+      #   # good
+      #   ?\C-\M-d
       class CharacterLiteral < Cop
         include StringHelp
 
@@ -33,13 +42,11 @@ module RuboCop
 
         # Dummy implementation of method in ConfigurableEnforcedStyle that is
         # called from StringHelp.
-        def opposite_style_detected
-        end
+        def opposite_style_detected; end
 
         # Dummy implementation of method in ConfigurableEnforcedStyle that is
         # called from StringHelp.
-        def correct_style_detected
-        end
+        def correct_style_detected; end
       end
     end
   end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -7,13 +6,17 @@ module RuboCop
       # This cop checks the style of children definitions at classes and
       # modules. Basically there are two different styles:
       #
-      # nested - have each child on its own line
+      # @example EnforcedStyle: nested (default)
+      #   # good
+      #   # have each child on its own line
       #   class Foo
       #     class Bar
       #     end
       #   end
       #
-      # compact - combine definitions as much as possible
+      # @example EnforcedStyle: compact
+      #   # good
+      #   # combine definitions as much as possible
       #   class Foo::Bar
       #   end
       #
@@ -37,8 +40,84 @@ module RuboCop
           check_style(node, body)
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            if node.class_type?
+              name, superclass, body = *node
+              return if superclass && style != :nested
+            else
+              name, body = *node
+            end
+            nest_or_compact(corrector, node, name, body)
+          end
+        end
+
         private
 
+        def nest_or_compact(corrector, node, name, body)
+          if style == :nested
+            nest_definition(corrector, node)
+          else
+            compact_definition(corrector, node, name, body)
+          end
+        end
+
+        def nest_definition(corrector, node)
+          padding = ((' ' * indent_width) + leading_spaces(node)).to_s
+          padding_for_trailing_end = padding.sub(' ' * node.loc.end.column, '')
+
+          replace_keyword_with_module(corrector, node)
+          split_on_double_colon(corrector, node, padding)
+          add_trailing_end(corrector, node, padding_for_trailing_end)
+        end
+
+        def replace_keyword_with_module(corrector, node)
+          corrector.replace(node.loc.keyword, 'module'.freeze)
+        end
+
+        def split_on_double_colon(corrector, node, padding)
+          children_definition = node.children.first
+          range = range_between(children_definition.loc.double_colon.begin_pos,
+                                children_definition.loc.double_colon.end_pos)
+          replacement = "\n#{padding}#{node.loc.keyword.source} ".freeze
+
+          corrector.replace(range, replacement)
+        end
+
+        def add_trailing_end(corrector, node, padding)
+          replacement = "#{padding}end\n#{leading_spaces(node)}end".freeze
+          corrector.replace(node.loc.end, replacement)
+        end
+
+        def compact_definition(corrector, node, name, body)
+          compact_node(corrector, node, name, body)
+          remove_end(corrector, body)
+        end
+
+        def compact_node(corrector, node, name, body)
+          const_name = "#{name.const_name}::#{body.children.first.const_name}"
+          replacement = "#{body.type} #{const_name}"
+          range = range_between(node.loc.keyword.begin_pos,
+                                body.loc.name.end_pos)
+          corrector.replace(range, replacement)
+        end
+
+        def remove_end(corrector, body)
+          range = range_between(
+            body.loc.end.begin_pos - leading_spaces(body).size,
+            body.loc.end.end_pos + 1
+          )
+          corrector.remove(range)
+        end
+
+        def leading_spaces(node)
+          node.source_range.source_line[/\A\s*/]
+        end
+
+        def indent_width
+          @config.for_cop('IndentationWidth')['Width'] || 2
+        end
+
         def check_style(node, body)
           if style == :nested
             check_nested_style(node)
@@ -49,16 +128,16 @@ module RuboCop
 
         def check_nested_style(node)
           return unless compact_node_name?(node)
-          add_offense(node, :name, NESTED_MSG)
+          add_offense(node, location: :name, message: NESTED_MSG)
         end
 
         def check_compact_style(node, body)
           return unless one_child?(body) && !compact_node_name?(node)
-          add_offense(node, :name, COMPACT_MSG)
+          add_offense(node, location: :name, message: COMPACT_MSG)
         end
 
         def one_child?(body)
-          body && [:module, :class].include?(body.type)
+          body && %i[module class].include?(body.type)
         end
 
         def compact_node_name?(node)

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

@@ -1,40 +1,56 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop enforces consistent use of `Object#is_a?` or `Object#kind_of?`.
+      #
+      # @example EnforcedStyle: is_a? (default)
+      #   # bad
+      #   var.kind_of?(Date)
+      #   var.kind_of?(Integer)
+      #
+      #   # good
+      #   var.is_a?(Date)
+      #   var.is_a?(Integer)
+      #
+      # @example EnforcedStyle: kind_of?
+      #   # bad
+      #   var.is_a?(Time)
+      #   var.is_a?(String)
+      #
+      #   # good
+      #   var.kind_of?(Time)
+      #   var.kind_of?(String)
+      #
       class ClassCheck < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Prefer `Object#%s` over `Object#%s`.'.freeze
+        MSG = 'Prefer `Object#%<prefer>s` over `Object#%<current>s`.'.freeze
+
+        def_node_matcher :class_check?, '(send _ ${:is_a? :kind_of?} _)'
 
         def on_send(node)
-          _receiver, method_name, *_args = *node
-          return unless [:is_a?,
-                         :kind_of?].include?(method_name)
+          class_check?(node) do |method_name|
+            return if style == method_name
 
-          return if style == method_name
-          add_offense(node, :selector)
+            add_offense(node, location: :selector)
+          end
         end
 
-        def message(node)
-          _receiver, method_name, *_args = *node
+        def autocorrect(node)
+          lambda do |corrector|
+            replacement = node.method?(:is_a?) ? 'kind_of?' : 'is_a?'
 
-          if method_name == :is_a?
-            format(MSG, 'kind_of?', 'is_a?')
-          else
-            format(MSG, 'is_a?', 'kind_of?')
+            corrector.replace(node.loc.selector, replacement)
           end
         end
 
-        def autocorrect(node)
-          _receiver, method_name, *_args = *node
-
-          lambda do |corrector|
-            corrector.replace(node.loc.selector,
-                              method_name == :is_a? ? 'kind_of?' : 'is_a?')
+        def message(node)
+          if node.method?(:is_a?)
+            format(MSG, prefer: 'kind_of?', current: 'is_a?')
+          else
+            format(MSG, prefer: 'is_a?', current: 'kind_of?')
           end
         end
       end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -11,18 +10,18 @@ module RuboCop
       #   # bad
       #   class SomeClass
       #     def SomeClass.class_method
-      #       ...
+      #       # ...
       #     end
       #   end
       #
       #   # good
       #   class SomeClass
       #     def self.class_method
-      #       ...
+      #       # ...
       #     end
       #   end
       class ClassMethods < Cop
-        MSG = 'Use `self.%s` instead of `%s.%s`.'.freeze
+        MSG = 'Use `self.%<method>s` instead of `%<class>s.%<method>s`.'.freeze
 
         def on_class(node)
           name, _superclass, body = *node
@@ -34,16 +33,19 @@ module RuboCop
           check(name, body)
         end
 
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.loc.name, 'self') }
+        end
+
         private
 
         def check(name, node)
           return unless node
 
-          if node.type == :defs
+          if node.defs_type?
             check_defs(name, node)
-          elsif node.type == :begin
-            defs_nodes = node.children.compact.select { |n| n.type == :defs }
-            defs_nodes.each { |n| check_defs(name, n) }
+          elsif node.begin_type?
+            node.each_child_node(:defs) { |n| check_defs(name, n) }
           end
         end
 
@@ -53,15 +55,12 @@ module RuboCop
           return unless name == definee
 
           _, class_name = *definee
-          add_offense(definee, :name, message(class_name, method_name))
+          add_offense(definee, location: :name,
+                               message: message(class_name, method_name))
         end
 
         def message(class_name, method_name)
-          format(MSG, method_name, class_name, method_name)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.name, 'self') }
+          format(MSG, method: method_name, class: class_name)
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,17 +5,18 @@ module RuboCop
     module Style
       # This cop checks for uses of class variables. Offenses
       # are signaled only on assignment to class variables to
-      # reduced the number of offenses that would be reported.
+      # reduce the number of offenses that would be reported.
       class ClassVars < Cop
-        MSG = 'Replace class var %s with a class instance var.'.freeze
+        MSG = 'Replace class var %<class_var>s with a class ' \
+              'instance var.'.freeze
 
         def on_cvasgn(node)
-          add_offense(node, :name)
+          add_offense(node, location: :name)
         end
 
         def message(node)
           class_var, = *node
-          format(MSG, class_var)
+          format(MSG, class_var: class_var)
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -13,17 +12,15 @@ module RuboCop
       class CollectionMethods < Cop
         include MethodPreference
 
-        MSG = 'Prefer `%s` over `%s`.'.freeze
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'.freeze
 
         def on_block(node)
-          method, _args, _body = *node
-
-          check_method_node(method)
+          check_method_node(node.send_node)
         end
 
         def on_send(node)
-          _receiver, _method_name, *args = *node
-          return unless args.size == 1 && args.first.type == :block_pass
+          return unless node.arguments.one? &&
+                        node.first_argument.block_pass_type?
 
           check_method_node(node)
         end
@@ -37,14 +34,16 @@ module RuboCop
 
         private
 
+        def message(node)
+          format(MSG,
+                 prefer: preferred_method(node.method_name),
+                 current: node.method_name)
+        end
+
         def check_method_node(node)
-          _receiver, method_name, *_args = *node
+          return unless preferred_methods[node.method_name]
 
-          return unless preferred_methods[method_name]
-          add_offense(node, :selector,
-                      format(MSG,
-                             preferred_method(method_name),
-                             method_name))
+          add_offense(node, location: :selector)
         end
       end
     end