rubocop 0.51.0 → 0.52.0

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

@@ -4,6 +4,18 @@ module RuboCop
   module Cop
     module Style
       # This cop looks for uses of block comments (=begin...=end).
+      #
+      # @example
+      #   # bad
+      #   =begin
+      #   Multiple lines
+      #   of comments...
+      #   =end
+      #
+      #   # good
+      #   # Multiple lines
+      #   # of comments...
+      #
       class BlockComments < Cop
         MSG = 'Do not use block comments.'.freeze
         BEGIN_LENGTH = "=begin\n".length
@@ -17,8 +29,6 @@ module RuboCop
           end
         end
 
-        private
-
         def autocorrect(comment)
           eq_begin, eq_end, contents = parts(comment)
 
@@ -35,6 +45,8 @@ module RuboCop
           end
         end
 
+        private
+
         def parts(comment)
           expr = comment.loc.expression
           eq_begin = expr.resize(BEGIN_LENGTH)

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

@@ -5,6 +5,72 @@ module RuboCop
     module Style
       # Check for uses of braces or do/end around single line or
       # multi-line blocks.
+      #
+      # @example EnforcedStyle: line_count_based (default)
+      #   # bad - single line block
+      #   items.each do |item| item / 5 end
+      #
+      #   # good - single line block
+      #   items.each { |item| item / 5 }
+      #
+      #   # bad - multi-line block
+      #   things.map { |thing|
+      #     something = thing.some_method
+      #     process(something)
+      #   }
+      #
+      #   # good - multi-line block
+      #   things.map do |thing|
+      #     something = thing.some_method
+      #     process(something)
+      #   end
+      #
+      # @example EnforcedStyle: semantic
+      #   # Prefer `do...end` over `{...}` for procedural blocks.
+      #
+      #   # return value is used/assigned
+      #   # bad
+      #   foo = map do |x|
+      #     x
+      #   end
+      #   puts (map do |x|
+      #     x
+      #   end)
+      #
+      #   # return value is not used out of scope
+      #   # good
+      #   map do |x|
+      #     x
+      #   end
+      #
+      #   # Prefer `{...}` over `do...end` for functional blocks.
+      #
+      #   # return value is not used out of scope
+      #   # bad
+      #   each { |x|
+      #     x
+      #   }
+      #
+      #   # return value is used/assigned
+      #   # good
+      #   foo = map { |x|
+      #     x
+      #   }
+      #   map { |x|
+      #     x
+      #   }.inspect
+      #
+      # @example EnforcedStyle: braces_for_chaining
+      #   # bad
+      #   words.each do |word|
+      #     word.flip.flop
+      #   end.join("-")
+      #
+      #   # good
+      #   words.each { |word|
+      #     word.flip.flop
+      #   }.join("-")
+      #
       class BlockDelimiters < Cop
         include ConfigurableEnforcedStyle
 
@@ -28,10 +94,20 @@ module RuboCop
           add_offense(node, location: :begin) unless proper_block_style?(node)
         end
 
+        def autocorrect(node)
+          return if correction_would_break_code?(node)
+
+          if node.braces?
+            replace_braces_with_do_end(node.loc)
+          else
+            replace_do_end_with_braces(node.loc)
+          end
+        end
+
         private
 
         def line_count_based_message(node)
-          if block_length(node) > 0
+          if node.multiline?
             'Avoid using `{...}` for multi-line blocks.'
           else
             'Prefer `{...}` over `do...end` for single-line blocks.'
@@ -49,7 +125,7 @@ module RuboCop
         end
 
         def braces_for_chaining_message(node)
-          if block_length(node) > 0
+          if node.multiline?
             if return_value_chaining?(node)
               'Prefer `{...}` over `do...end` for multi-line chained blocks.'
             else
@@ -68,16 +144,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          return if correction_would_break_code?(node)
-
-          if node.braces?
-            replace_braces_with_do_end(node.loc)
-          else
-            replace_do_end_with_braces(node.loc)
-          end
-        end
-
         def replace_braces_with_do_end(loc)
           b = loc.begin
           e = loc.end
@@ -128,7 +194,7 @@ module RuboCop
             node.each_child_node { |child| get_blocks(child, &block) }
           end
         end
-        # rubocop:enable Metrics/CyclimaticComplexity
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def proper_block_style?(node)
           return true if ignored_method?(node.method_name)
@@ -155,10 +221,9 @@ module RuboCop
         end
 
         def braces_for_chaining_style?(node)
-          block_length = block_length(node)
           block_begin = node.loc.begin.source
 
-          block_begin == if block_length > 0
+          block_begin == if node.multiline?
                            (return_value_chaining?(node) ? '{' : 'do')
                          else
                            '{'

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

@@ -5,47 +5,44 @@ 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 3 styles:
+      # It supports `braces`, `no_braces` and `context_dependent` styles.
       #
-      # * The `braces` style enforces braces around all method
-      # parameters that are hashes.
+      # @example EnforcedStyle: braces
+      #   # The `braces` style enforces braces around all method
+      #   # parameters that are hashes.
       #
-      #     ```
-      #     # bad
-      #     some_method(x, y, a: 1, b: 2)
+      #   # bad
+      #   some_method(x, y, a: 1, b: 2)
       #
-      #     # good
-      #     some_method(x, y, {a: 1, b: 2})
-      #     ```
+      #   # good
+      #   some_method(x, y, {a: 1, b: 2})
       #
-      # * The `no_braces` style checks that the last parameter doesn't
-      # have braces around it.
+      # @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})
+      #   # bad
+      #   some_method(x, y, {a: 1, b: 2})
       #
-      #     # good
-      #     some_method(x, y, a: 1, b: 2)
-      #     ```
+      #   # good
+      #   some_method(x, y, a: 1, b: 2)
       #
-      # * 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.
+      # @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)
+      #   # 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})
-      #     ```
+      #   # 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)
           return if node.assignment_method? || node.operator_method?
@@ -56,6 +53,24 @@ module RuboCop
           check(node.last_argument, node.arguments)
         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)
+          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)
@@ -82,27 +97,36 @@ module RuboCop
 
         def add_arg_offense(arg, type)
           add_offense(arg.parent, location: arg.source_range,
-                                  message: format(MSG, type.to_s.capitalize))
+                                  message: format(MSG,
+                                                  type: type.to_s.capitalize))
         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)
-          hash_node = send_node.last_argument
+        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
 
-          lambda do |corrector|
-            if hash_node.braces?
-              remove_braces_with_whitespace(corrector, hash_node)
-            else
-              add_braces(corrector, 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)
+        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
@@ -110,15 +134,24 @@ module RuboCop
             # braces in that case.
             remove_braces(corrector, node)
           else
-            left_brace_and_space = range_with_surrounding_space(node.loc.begin,
-                                                                :right)
+            left_brace_and_space =
+              range_with_surrounding_space(range: node.loc.begin,
+                                           side: :right,
+                                           newlines: space[:newlines],
+                                           whitespace: space[:left])
             corrector.remove(left_brace_and_space)
             corrector.remove(right_brace_and_space)
           end
         end
 
-        def right_brace_and_space(loc_end)
-          brace_and_space = range_with_surrounding_space(loc_end, :left)
+        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
 

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

@@ -4,6 +4,18 @@ 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
 

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

@@ -4,6 +4,16 @@ 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
 

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

@@ -6,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
       #

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

@@ -4,10 +4,29 @@ 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?} _)'
 
@@ -19,14 +38,6 @@ module RuboCop
           end
         end
 
-        def message(node)
-          if node.method?(:is_a?)
-            format(MSG, 'kind_of?', 'is_a?')
-          else
-            format(MSG, 'is_a?', 'kind_of?')
-          end
-        end
-
         def autocorrect(node)
           lambda do |corrector|
             replacement = node.method?(:is_a?) ? 'kind_of?' : 'is_a?'
@@ -34,6 +45,14 @@ module RuboCop
             corrector.replace(node.loc.selector, replacement)
           end
         end
+
+        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
     end
   end