rubocop 0.49.1 → 0.52.0

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)
@@ -96,7 +138,7 @@ module RuboCop
                   'Indent the right brace the same as the start of the line ' \
                   'where the left brace is.'
                 end
-          add_offense(right_brace, right_brace, msg)
+          add_offense(right_brace, location: right_brace, message: msg)
         end
 
         def separator_style?(first_pair)
@@ -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

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

@@ -8,45 +8,51 @@ module RuboCop
       # In Ruby 2.3 or newer, squiggly heredocs (`<<~`) should be used. If you
       # use the older rubies, you should introduce some library to your project
       # (e.g. ActiveSupport, Powerpack or Unindent).
+      # Note: When `Metrics/LineLength`'s `AllowHeredoc` is false(not default),
+      #       this cop does not add any offenses for long here documents to
+      #       avoid `Metrics/LineLength`'s offenses.
       #
       # @example
       #
       #   # bad
-      #   <<-END
+      #   <<-RUBY
       #   something
-      #   END
+      #   RUBY
       #
       #   # good
       #   # When EnforcedStyle is squiggly, bad code is auto-corrected to the
       #   # following code.
-      #   <<~END
+      #   <<~RUBY
       #     something
-      #   END
+      #   RUBY
       #
       #   # good
       #   # When EnforcedStyle is active_support, bad code is auto-corrected to
       #   # the following code.
-      #   <<-END.strip_heredoc
+      #   <<-RUBY.strip_heredoc
       #     something
-      #   END
+      #   RUBY
       class IndentHeredoc < Cop
+        include Heredoc
         include ConfigurableEnforcedStyle
         include SafeMode
 
-        RUBY23_MSG = 'Use %d spaces for indentation in a heredoc by using ' \
-                     '`<<~` instead of `%s`.'.freeze
-        LIBRARY_MSG = 'Use %d spaces for indentation in a heredoc by using %s.'
-                      .freeze
-        StripMethods = {
+        RUBY23_MSG = 'Use %<indentation_width>d spaces for indentation in a ' \
+                     'heredoc by using `<<~` instead of ' \
+                     '`%<current_indent_type>s`.'.freeze
+        LIBRARY_MSG = 'Use %<indentation_width>d spaces for indentation in a ' \
+                      'heredoc by using %<method>s.'.freeze
+        STRIP_METHODS = {
           unindent: 'unindent',
           active_support: 'strip_heredoc',
           powerpack: 'strip_indent'
         }.freeze
 
-        def on_str(node)
-          return unless heredoc?(node)
+        def on_heredoc(node)
+          body = heredoc_body(node)
+          return if body =~ /\A\s*\z/
 
-          body_indent_level = body_indent_level(node)
+          body_indent_level = indent_level(body)
 
           if heredoc_indent_type(node) == '~'
             expected_indent_level = base_indent_level(node) + indentation_width
@@ -55,12 +61,10 @@ module RuboCop
             return unless body_indent_level.zero?
           end
 
-          add_offense(node, :heredoc_body)
+          return if too_long_line?(node)
+          add_offense(node, location: :heredoc_body)
         end
 
-        alias on_dstr on_str
-        alias on_xstr on_str
-
         def autocorrect(node)
           check_style!
 
@@ -89,16 +93,49 @@ module RuboCop
           case style
           when :squiggly
             current_indent_type = "<<#{heredoc_indent_type(node)}"
-            format(RUBY23_MSG, indentation_width, current_indent_type)
+            ruby23_message(indentation_width, current_indent_type)
           when nil
             method = "some library(e.g. ActiveSupport's `String#strip_heredoc`)"
-            format(LIBRARY_MSG, indentation_width, method)
+            library_message(indentation_width, method)
           else
-            method = "`String##{StripMethods[style]}`"
-            format(LIBRARY_MSG, indentation_width, method)
+            method = "`String##{STRIP_METHODS[style]}`"
+            library_message(indentation_width, method)
           end
         end
 
+        def library_message(indentation_width, method)
+          format(
+            LIBRARY_MSG,
+            indentation_width: indentation_width,
+            method: method
+          )
+        end
+
+        def ruby23_message(indentation_width, current_indent_type)
+          format(
+            RUBY23_MSG,
+            indentation_width: indentation_width,
+            current_indent_type: current_indent_type
+          )
+        end
+
+        def too_long_line?(node)
+          return false if config.for_cop('Metrics/LineLength')['AllowHeredoc']
+          body = heredoc_body(node)
+
+          expected_indent = base_indent_level(node) + indentation_width
+          actual_indent = indent_level(body)
+          increase_indent_level = expected_indent - actual_indent
+
+          max_line = body.each_line.map { |line| line.chomp.size }.max
+
+          max_line + increase_indent_level >= max_line_length
+        end
+
+        def max_line_length
+          config.for_cop('Metrics/LineLength')['Max']
+        end
+
         def correct_by_squiggly(node)
           return if target_ruby_version < 2.3
           lambda do |corrector|
@@ -115,7 +152,7 @@ module RuboCop
         def correct_by_library(node)
           lambda do |corrector|
             corrector.replace(node.loc.heredoc_body, indented_body(node))
-            corrected = ".#{StripMethods[style]}"
+            corrected = ".#{STRIP_METHODS[style]}"
             corrector.insert_after(node.loc.expression, corrected)
           end
         end
@@ -133,22 +170,13 @@ module RuboCop
           end
         end
 
-        def heredoc?(node)
-          node.loc.is_a?(Parser::Source::Map::Heredoc)
-        end
-
         def indented_body(node)
-          body = node.loc.heredoc_body.source
-          body_indent_level = body_indent_level(node)
+          body = heredoc_body(node)
+          body_indent_level = indent_level(body)
           correct_indent_level = base_indent_level(node) + indentation_width
           body.gsub(/^\s{#{body_indent_level}}/, ' ' * correct_indent_level)
         end
 
-        def body_indent_level(node)
-          body = node.loc.heredoc_body.source
-          indent_level(body)
-        end
-
         def base_indent_level(node)
           base_line_num = node.loc.expression.line
           base_line = processed_source.lines[base_line_num - 1]
@@ -156,7 +184,10 @@ module RuboCop
         end
 
         def indent_level(str)
-          str.scan(/^\s*/).reject { |line| line == "\n" }.min_by(&:size).size
+          indentations = str.lines
+                            .map { |line| line[/^\s*/] }
+                            .reject { |line| line == "\n" }
+          indentations.empty? ? 0 : indentations.min_by(&:size).size
         end
 
         # Returns '~', '-' or nil
@@ -167,6 +198,10 @@ module RuboCop
         def indentation_width
           @config.for_cop('IndentationWidth')['Width'] || 2
         end
+
+        def heredoc_body(node)
+          node.loc.heredoc_body.source.scrub
+        end
       end
     end
   end

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

@@ -15,7 +15,6 @@ module RuboCop
       #   end
       class IndentationConsistency < Cop
         include AutocorrectAlignment
-        include AccessModifierNode
         include ConfigurableEnforcedStyle
 
         MSG = 'Inconsistent indentation detected.'.freeze
@@ -37,7 +36,7 @@ module RuboCop
             # the AccessModifierIndentation cop. This cop uses them as dividers
             # in rails mode. Then consistency is checked only within each
             # section delimited by a modifier node.
-            if modifier_node?(child)
+            if child.send_type? && child.access_modifier?
               children_to_check << [] if style == :rails
             else
               children_to_check.last << child

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

@@ -10,34 +10,31 @@ module RuboCop
       # one.
       #
       # @example
-      #   # bad, Width: 2
+      #   # bad
       #   class A
       #    def test
       #     puts 'hello'
       #    end
       #   end
       #
-      #   # bad, Width: 2,
-      #          IgnoredPatterns:
-      #            - '^\s*module'
-      #   module A
-      #   class B
+      #   # good
+      #   class A
       #     def test
-      #     puts 'hello'
+      #       puts 'hello'
       #     end
       #   end
-      #   end
       #
-      #   # good, Width: 2
-      #   class A
+      # @example IgnoredPatterns: ['^\s*module']
+      #   # bad
+      #   module A
+      #   class B
       #     def test
-      #       puts 'hello'
+      #     puts 'hello'
       #     end
       #   end
+      #   end
       #
-      #   # good, Width: 2,
-      #           IgnoredPatterns:
-      #             - '^\s*module'
+      #   # good
       #   module A
       #   class B
       #     def test
@@ -48,11 +45,12 @@ module RuboCop
       class IndentationWidth < Cop
         include EndKeywordAlignment
         include AutocorrectAlignment
-        include OnMethodDef
         include CheckAssignment
-        include AccessModifierNode
         include IgnoredPattern
 
+        MSG = 'Use %<configured_indentation_width>d (not %<indentation>d) ' \
+              'spaces for%<name>s indentation.'.freeze
+
         SPECIAL_MODIFIERS = %w[private protected].freeze
 
         def on_rescue(node)
@@ -98,7 +96,7 @@ module RuboCop
 
         def on_send(node)
           super
-          return unless modifier_and_def_on_same_line?(node)
+          return unless node.adjacent_def_modifier?
 
           *_, body = *node.first_argument
 
@@ -110,9 +108,12 @@ module RuboCop
           ignore_node(node.first_argument)
         end
 
-        def on_method_def(node, _method_name, _args, body)
-          check_indentation(node.loc.keyword, body) unless ignored_node?(node)
+        def on_def(node)
+          return if ignored_node?(node)
+
+          check_indentation(node.loc.keyword, node.body)
         end
+        alias on_defs on_def
 
         def on_while(node, base = node)
           return if ignored_node?(node)
@@ -157,7 +158,7 @@ module RuboCop
         def each_member(members)
           previous_modifier = nil
           members.first.children.each do |member|
-            if special_modifier?(member)
+            if member.send_type? && special_modifier?(member)
               previous_modifier = member
             elsif previous_modifier
               yield member, previous_modifier.source_range
@@ -167,7 +168,7 @@ module RuboCop
         end
 
         def special_modifier?(node)
-          modifier_node?(node) && SPECIAL_MODIFIERS.include?(node.source)
+          node.access_modifier? && SPECIAL_MODIFIERS.include?(node.source)
         end
 
         def indentation_consistency_style
@@ -235,11 +236,20 @@ module RuboCop
                    body_node
                  end
 
-          indentation_name = style == 'normal' ? '' : "#{style} "
-          add_offense(node, offending_range(body_node, indentation),
-                      format("Use #{configured_indentation_width} (not %d) " \
-                             "spaces for #{indentation_name}indentation.",
-                             indentation))
+          name = style == 'normal' ? '' : " #{style}"
+          message = message(configured_indentation_width, indentation, name)
+
+          add_offense(node, location: offending_range(body_node, indentation),
+                            message: message)
+        end
+
+        def message(configured_indentation_width, indentation, name)
+          format(
+            MSG,
+            configured_indentation_width: configured_indentation_width,
+            indentation: indentation,
+            name: name
+          )
         end
 
         # Returns true if the given node is within another node that has
@@ -289,7 +299,10 @@ module RuboCop
         end
 
         def starts_with_access_modifier?(body_node)
-          body_node.begin_type? && modifier_node?(body_node.children.first)
+          return unless body_node.begin_type?
+
+          starting_node = body_node.children.first
+          starting_node.send_type? && starting_node.access_modifier?
         end
 
         def configured_indentation_width