rubocop 0.51.0 → 0.52.0

data/lib/rubocop/cop/layout/empty_lines_around_method_body.rb

@@ -10,14 +10,14 @@ module RuboCop
       #   # good
       #
       #   def foo
-      #     ...
+      #     # ...
       #   end
       #
       #   # bad
       #
       #   def bar
       #
-      #     ...
+      #     # ...
       #
       #   end
       class EmptyLinesAroundMethodBody < Cop

data/lib/rubocop/cop/layout/empty_lines_around_module_body.rb

@@ -6,27 +6,42 @@ module RuboCop
       # This cops checks if empty lines around the bodies of modules match
       # the configuration.
       #
-      # @example
-      #
-      #   EnforcedStyle: empty_lines
-      #
+      # @example EnforcedStyle: empty_lines
       #   # good
       #
       #   module Foo
       #
       #     def bar
-      #       ...
+      #       # ...
       #     end
       #
       #   end
       #
-      #   EnforcedStyle: no_empty_lines
+      # @example EnforcedStyle: empty_lines_except_namespace
+      #   # good
+      #
+      #   module Foo
+      #     module Bar
+      #
+      #       # ...
+      #
+      #     end
+      #   end
+      #
+      # @example EnforcedStyle: empty_lines_special
+      #   # good
+      #   module Foo
+      #
+      #     def bar; end
+      #
+      #   end
       #
+      # @example EnforcedStyle: no_empty_lines (default)
       #   # good
       #
       #   module Foo
       #     def bar
-      #       ...
+      #       # ...
       #     end
       #   end
       class EmptyLinesAroundModuleBody < Cop

data/lib/rubocop/cop/layout/end_of_line.rb

@@ -13,7 +13,7 @@ module RuboCop
         def investigate(processed_source)
           last_token = processed_source.tokens.last
           last_line =
-            last_token ? last_token.pos.line : processed_source.lines.length
+            last_token ? last_token.line : processed_source.lines.length
 
           processed_source.raw_source.each_line.with_index do |line, index|
             break if index >= last_line

data/lib/rubocop/cop/layout/extra_spacing.rb

@@ -23,14 +23,15 @@ module RuboCop
         include PrecedingFollowingAlignment
 
         MSG_UNNECESSARY = 'Unnecessary spacing detected.'.freeze
-        MSG_UNALIGNED_ASGN = '`=` is not aligned with the %s assignment.'.freeze
+        MSG_UNALIGNED_ASGN = '`=` is not aligned with the %<location>s ' \
+                             'assignment.'.freeze
 
         def investigate(processed_source)
           return if processed_source.ast.nil?
 
           if force_equal_sign_alignment?
             @asgn_tokens = assignment_tokens
-            @asgn_lines  = @asgn_tokens.map { |t| t.pos.line }
+            @asgn_lines  = @asgn_tokens.map(&:line)
             # Don't attempt to correct the same = more than once
             @corrected   = Set.new
           end
@@ -53,14 +54,14 @@ module RuboCop
         private
 
         def assignment_tokens
-          tokens = processed_source.tokens.select { |t| equal_sign?(t) }
+          tokens = processed_source.tokens.select(&:equal_sign?)
           # we don't want to operate on equals signs which are part of an
           #   optarg in a method definition
           # e.g.: def method(optarg = default_val); end
           tokens = remove_optarg_equals(tokens, processed_source)
 
           # Only attempt to align the first = on each line
-          Set.new(tokens.uniq { |t| t.pos.line })
+          Set.new(tokens.uniq(&:line))
         end
 
         def check_tokens(ast, t1, t2)
@@ -68,8 +69,8 @@ module RuboCop
 
           if force_equal_sign_alignment? &&
              @asgn_tokens.include?(t2) &&
-             (@asgn_lines.include?(t2.pos.line - 1) ||
-              @asgn_lines.include?(t2.pos.line + 1))
+             (@asgn_lines.include?(t2.line - 1) ||
+              @asgn_lines.include?(t2.line + 1))
             check_assignment(t2)
           else
             check_other(t1, t2, ast)
@@ -81,25 +82,25 @@ module RuboCop
           message = ''
           if should_aligned_with_preceding_line?(token)
             assignment_line = preceding_line(token)
-            message = format(MSG_UNALIGNED_ASGN, 'preceding')
+            message = format(MSG_UNALIGNED_ASGN, location: 'preceding')
           else
             assignment_line = following_line(token)
-            message = format(MSG_UNALIGNED_ASGN, 'following')
+            message = format(MSG_UNALIGNED_ASGN, location: 'following')
           end
           return if aligned_assignment?(token.pos, assignment_line)
           add_offense(token.pos, location: token.pos, message: message)
         end
 
         def should_aligned_with_preceding_line?(token)
-          @asgn_lines.include?(token.pos.line - 1)
+          @asgn_lines.include?(token.line - 1)
         end
 
         def preceding_line(token)
-          processed_source.lines[token.pos.line - 2]
+          processed_source.lines[token.line - 2]
         end
 
         def following_line(token)
-          processed_source.lines[token.pos.line]
+          processed_source.lines[token.line]
         end
 
         def check_other(t1, t2, ast)
@@ -113,10 +114,10 @@ module RuboCop
         end
 
         def extra_space_range(t1, t2)
-          return if t1.pos.line != t2.pos.line
+          return if t1.line != t2.line
 
-          start_pos = t1.pos.end_pos
-          end_pos = t2.pos.begin_pos - 1
+          start_pos = t1.end_pos
+          end_pos = t2.begin_pos - 1
           return if end_pos <= start_pos
 
           return if allow_for_alignment? && aligned_tok?(t2)
@@ -125,7 +126,7 @@ module RuboCop
         end
 
         def aligned_tok?(token)
-          if token.type == :tCOMMENT
+          if token.comment?
             aligned_comments?(token)
           else
             aligned_with_something?(token.pos)
@@ -156,7 +157,7 @@ module RuboCop
 
         def aligned_comments?(token)
           ix = processed_source.comments.index do |c|
-            c.loc.expression.begin_pos == token.pos.begin_pos
+            c.loc.expression.begin_pos == token.begin_pos
           end
           aligned_with_previous_comment?(ix) || aligned_with_next_comment?(ix)
         end
@@ -178,13 +179,9 @@ module RuboCop
           cop_config['ForceEqualSignAlignment']
         end
 
-        def equal_sign?(token)
-          token.type == :tEQL || token.type == :tOP_ASGN
-        end
-
         def align_equal_signs(range, corrector)
           lines  = contiguous_assignment_lines(range)
-          tokens = @asgn_tokens.select { |t| lines.include?(t.pos.line) }
+          tokens = @asgn_tokens.select { |t| lines.include?(t.line) }
 
           columns  = tokens.map { |t| align_column(t) }
           align_to = columns.max
@@ -220,8 +217,8 @@ module RuboCop
         def align_column(asgn_token)
           # if we removed unneeded spaces from the beginning of this =,
           # what column would it end from?
-          line    = processed_source.lines[asgn_token.pos.line - 1]
-          leading = line[0...asgn_token.pos.column]
+          line    = processed_source.lines[asgn_token.line - 1]
+          leading = line[0...asgn_token.column]
           spaces  = leading.size - (leading =~ / *\Z/)
           asgn_token.pos.last_column - spaces + 1
         end
@@ -229,7 +226,7 @@ module RuboCop
         def remove_optarg_equals(asgn_tokens, processed_source)
           optargs    = processed_source.ast.each_node(:optarg)
           optarg_eql = optargs.map { |o| o.loc.operator.begin_pos }.to_set
-          asgn_tokens.reject { |t| optarg_eql.include?(t.pos.begin_pos) }
+          asgn_tokens.reject { |t| optarg_eql.include?(t.begin_pos) }
         end
       end
     end

data/lib/rubocop/cop/layout/first_parameter_indentation.rb

@@ -22,6 +22,8 @@ module RuboCop
         include AutocorrectAlignment
         include ConfigurableEnforcedStyle
 
+        MSG = 'Indent the first parameter one step more than %<base>s.'.freeze
+
         def on_send(node)
           return if !node.arguments? || node.operator_method?
 
@@ -44,7 +46,8 @@ module RuboCop
                  else
                    'the start of the previous line'
                  end
-          format('Indent the first parameter one step more than %s.', base)
+
+          format(MSG, base: base)
         end
 
         def base_indentation(node)

data/lib/rubocop/cop/layout/indent_array.rb

@@ -19,30 +19,74 @@ module RuboCop
       # This default style is called 'special_inside_parentheses'. Alternative
       # styles are 'consistent' and 'align_brackets'. Here are examples:
       #
-      #     # special_inside_parentheses
-      #     array = [
-      #       :value
-      #     ]
-      #     but_in_a_method_call([
-      #                            :its_like_this
-      #                          ])
-      #     # consistent
-      #     array = [
-      #       :value
-      #     ]
-      #     and_in_a_method_call([
-      #       :no_difference
-      #     ])
-      #     # align_brackets
-      #     and_now_for_something = [
-      #                               :completely_different
-      #                             ]
+      # @example EnforcedStyle: special_inside_parentheses
+      #   # The `special_inside_parentheses` style enforces that the first
+      #   # element in an array literal where the opening bracket and first
+      #   # element are on seprate lines is indented one step (two spaces) more
+      #   # than the position inside the opening parenthesis.
       #
+      #   #bad
+      #   array = [
+      #     :value
+      #   ]
+      #   and_in_a_method_call([
+      #     :no_difference
+      #                        ])
+      #
+      #   #good
+      #   array = [
+      #     :value
+      #   ]
+      #   but_in_a_method_call([
+      #                          :its_like_this
+      #                        ])
+      #
+      # @example EnforcedStyle: consistent
+      #   # The `consistent` style enforces that the first element in an array
+      #   # literal where the opening bracket and the first element are on
+      #   # seprate lines is indented the same as an array literal which is not
+      #   # defined inside a method call.
+      #
+      #   #bad
+      #   # consistent
+      #   array = [
+      #     :value
+      #   ]
+      #   but_in_a_method_call([
+      #                          :its_like_this
+      #   ])
+      #
+      #   #good
+      #   array = [
+      #     :value
+      #   ]
+      #   and_in_a_method_call([
+      #     :no_difference
+      #   ])
+      #
+      # @example EnforcedStyle: align_brackets
+      #   # The `align_brackets` style enforces that the opening and closing
+      #   # brackets are indented to the same position.
+      #
+      #   #bad
+      #   # align_brackets
+      #   and_now_for_something = [
+      #                             :completely_different
+      #   ]
+      #
+      #   #good
+      #   # align_brackets
+      #   and_now_for_something = [
+      #                             :completely_different
+      #                           ]
       class IndentArray < Cop
         include AutocorrectAlignment
         include ConfigurableEnforcedStyle
         include ArrayHashIndentation
 
+        MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
+              'in an array, relative to %<base_description>s.'.freeze
+
         def on_array(node)
           check(node, nil) if node.loc.begin
         end
@@ -105,8 +149,11 @@ module RuboCop
         end
 
         def message(base_description)
-          format('Use %d spaces for indentation in an array, relative to %s.',
-                 configured_indentation_width, base_description)
+          format(
+            MSG,
+            configured_indentation_width: configured_indentation_width,
+            base_description: base_description
+          )
         end
       end
     end

data/lib/rubocop/cop/layout/indent_hash.rb

@@ -19,30 +19,72 @@ module RuboCop
       # This default style is called 'special_inside_parentheses'. Alternative
       # styles are 'consistent' and 'align_braces'. Here are examples:
       #
-      #     # special_inside_parentheses
-      #     hash = {
-      #       key: :value
-      #     }
-      #     but_in_a_method_call({
-      #                            its_like: :this
-      #                          })
-      #     # consistent
-      #     hash = {
-      #       key: :value
-      #     }
-      #     and_in_a_method_call({
-      #       no: :difference
-      #     })
-      #     # align_braces
-      #     and_now_for_something = {
-      #                               completely: :different
-      #                             }
+      # @example EnforcedStyle: special_inside_parentheses (default)
+      #   # The `special_inside_parentheses` style enforces that the first key
+      #   # in a hash literal where the opening brace and the first key are on
+      #   # separate lines is indented one step (two spaces) more than the
+      #   # position inside the opening parentheses.
       #
+      #   # bad
+      #   hash = {
+      #     key: :value
+      #   }
+      #   and_in_a_method_call({
+      #     no: :difference
+      #                        })
+      #
+      #   # good
+      #   special_inside_parentheses
+      #   hash = {
+      #     key: :value
+      #   }
+      #   but_in_a_method_call({
+      #                          its_like: :this
+      #                        })
+      #
+      # @example EnforcedStyle: consistent
+      #   # The `consistent` style enforces that the first key in a hash
+      #   # literal where the opening brace and the first key are on
+      #   # seprate lines is indented the same as a hash literal which is not
+      #   # defined inside a method call.
+      #
+      #   # bad
+      #   hash = {
+      #     key: :value
+      #   }
+      #   but_in_a_method_call({
+      #                          its_like: :this
+      #                         })
+      #
+      #   # good
+      #   hash = {
+      #     key: :value
+      #   }
+      #   and_in_a_method_call({
+      #     no: :difference
+      #   })
+      #
+      # @example EnforcedStyle: align_braces
+      #   # The `align_brackets` style enforces that the opening and closing
+      #   # braces are indented to the same position.
+      #
+      #   # bad
+      #   and_now_for_something = {
+      #                             completely: :different
+      #   }
+      #
+      #   # good
+      #   and_now_for_something = {
+      #                             completely: :different
+      #                           }
       class IndentHash < Cop
         include AutocorrectAlignment
         include ConfigurableEnforcedStyle
         include ArrayHashIndentation
 
+        MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
+              'in a hash, relative to %<base_description>s.'.freeze
+
         def on_hash(node)
           check(node, nil) if node.loc.begin
         end
@@ -69,7 +111,7 @@ module RuboCop
             return if first_pair.source_range.line == left_brace.line
 
             if separator_style?(first_pair)
-              check_based_on_longest_key(hash_node.children, left_brace,
+              check_based_on_longest_key(hash_node, left_brace,
                                          left_parenthesis)
             else
               check_first(first_pair, left_brace, left_parenthesis, 0)
@@ -105,11 +147,11 @@ module RuboCop
           config.for_cop('Layout/AlignHash')[key] == 'separator'
         end
 
-        def check_based_on_longest_key(pairs, left_brace, left_parenthesis)
-          key_lengths = pairs.map do |pair|
-            pair.children.first.source_range.length
+        def check_based_on_longest_key(hash_node, left_brace, left_parenthesis)
+          key_lengths = hash_node.keys.map do |key|
+            key.source_range.length
           end
-          check_first(pairs.first, left_brace, left_parenthesis,
+          check_first(hash_node.pairs.first, left_brace, left_parenthesis,
                       key_lengths.max - key_lengths.first)
         end
 
@@ -125,8 +167,11 @@ module RuboCop
         end
 
         def message(base_description)
-          format('Use %d spaces for indentation in a hash, relative to %s.',
-                 configured_indentation_width, base_description)
+          format(
+            MSG,
+            configured_indentation_width: configured_indentation_width,
+            base_description: base_description
+          )
         end
       end
     end