rubocop 0.75.1

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

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks the indentation of the first key in a hash literal
+      # where the opening brace and the first key are on separate lines. The
+      # other keys' indentations are handled by the AlignHash cop.
+      #
+      # By default, Hash literals that are arguments in a method call with
+      # parentheses, and where the opening curly brace of the hash is on the
+      # same line as the opening parenthesis of the method call, shall have
+      # their first key indented one step (two spaces) more than the position
+      # inside the opening parenthesis.
+      #
+      # Other hash literals shall have their first key indented one step more
+      # than the start of the line where the opening curly brace is.
+      #
+      # This default style is called 'special_inside_parentheses'. Alternative
+      # styles are 'consistent' and 'align_braces'. Here are examples:
+      #
+      # @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
+      #   # separate 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 IndentFirstHashElement < Cop
+        include Alignment
+        include ConfigurableEnforcedStyle
+        include MultilineElementIndentation
+
+        MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
+              'in a hash, relative to %<base_description>s.'
+
+        def on_hash(node)
+          check(node, nil) if node.loc.begin
+        end
+
+        def on_send(node)
+          each_argument_node(node, :hash) do |hash_node, left_parenthesis|
+            check(hash_node, left_parenthesis)
+          end
+        end
+        alias on_csend on_send
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, @column_delta)
+        end
+
+        private
+
+        def brace_alignment_style
+          :align_braces
+        end
+
+        def check(hash_node, left_parenthesis)
+          return if ignored_node?(hash_node)
+
+          left_brace = hash_node.loc.begin
+          first_pair = hash_node.pairs.first
+
+          if first_pair
+            return if first_pair.source_range.line == left_brace.line
+
+            if separator_style?(first_pair)
+              check_based_on_longest_key(hash_node, left_brace,
+                                         left_parenthesis)
+            else
+              check_first(first_pair, left_brace, left_parenthesis, 0)
+            end
+          end
+
+          check_right_brace(hash_node.loc.end, left_brace, left_parenthesis)
+        end
+
+        def check_right_brace(right_brace, left_brace, left_parenthesis)
+          # if the right brace is on the same line as the last value, accept
+          return if right_brace.source_line[0...right_brace.column] =~ /\S/
+
+          expected_column = base_column(left_brace, left_parenthesis)
+          @column_delta = expected_column - right_brace.column
+          return if @column_delta.zero?
+
+          msg = if style == :align_braces
+                  'Indent the right brace the same as the left brace.'
+                elsif style == :special_inside_parentheses && left_parenthesis
+                  'Indent the right brace the same as the first position ' \
+                  'after the preceding left parenthesis.'
+                else
+                  'Indent the right brace the same as the start of the line ' \
+                  'where the left brace is.'
+                end
+          add_offense(right_brace, location: right_brace, message: msg)
+        end
+
+        def separator_style?(first_pair)
+          separator = first_pair.loc.operator
+          key = "Enforced#{separator.is?(':') ? 'Colon' : 'HashRocket'}Style"
+          config.for_cop('Layout/AlignHash')[key] == 'separator'
+        end
+
+        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(hash_node.pairs.first, left_brace, left_parenthesis,
+                      key_lengths.max - key_lengths.first)
+        end
+
+        # Returns the description of what the correct indentation is based on.
+        def base_description(left_parenthesis)
+          if style == :align_braces
+            'the position of the opening brace'
+          elsif left_parenthesis && style == :special_inside_parentheses
+            'the first position after the preceding left parenthesis'
+          else
+            'the start of the line where the left curly brace is'
+          end
+        end
+
+        def message(base_description)
+          format(
+            MSG,
+            configured_indentation_width: configured_indentation_width,
+            base_description: base_description
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks the indentation of the first parameter in a method
+      # definition. Parameters after the first one are checked by
+      # Layout/AlignParameters, not by this cop.
+      #
+      # For indenting the first argument of method *calls*, check out
+      # Layout/IndentFirstArgument, which supports options related to
+      # nesting that are irrelevant for method *definitions*.
+      #
+      # @example
+      #
+      #   # bad
+      #   def some_method(
+      #   first_param,
+      #   second_param)
+      #     123
+      #   end
+      #
+      # @example EnforcedStyle: consistent (default)
+      #   # The first parameter should always be indented one step more than the
+      #   # preceding line.
+      #
+      #   # good
+      #   def some_method(
+      #     first_param,
+      #   second_param)
+      #     123
+      #   end
+      #
+      # @example EnforcedStyle: align_parentheses
+      #   # The first parameter should always be indented one step more than the
+      #   # opening parenthesis.
+      #
+      #   # good
+      #   def some_method(
+      #                    first_param,
+      #   second_param)
+      #     123
+      #   end
+      class IndentFirstParameter < Cop
+        include Alignment
+        include ConfigurableEnforcedStyle
+        include MultilineElementIndentation
+
+        MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
+             'in method args, relative to %<base_description>s.'
+
+        def on_def(node)
+          return if node.arguments.empty?
+          return if node.arguments.loc.begin.nil?
+
+          check(node)
+        end
+        alias on_defs on_def
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, @column_delta)
+        end
+
+        private
+
+        def brace_alignment_style
+          :align_parentheses
+        end
+
+        def check(def_node)
+          return if ignored_node?(def_node)
+
+          left_parenthesis = def_node.arguments.loc.begin
+          first_elem = def_node.arguments.first
+          return unless first_elem
+          return if first_elem.source_range.line == left_parenthesis.line
+
+          check_first(first_elem, left_parenthesis, nil, 0)
+        end
+
+        # Returns the description of what the correct indentation is based on.
+        def base_description(_)
+          if style == brace_alignment_style
+            'the position of the opening parenthesis'
+          else
+            'the start of the line where the left parenthesis is'
+          end
+        end
+
+        def message(base_description)
+          format(
+            MSG,
+            configured_indentation_width: configured_indentation_width,
+            base_description: base_description
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks the indentation of the here document bodies. The bodies
+      # are indented one step.
+      # 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 EnforcedStyle: squiggly (default)
+      #   # bad
+      #   <<-RUBY
+      #   something
+      #   RUBY
+      #
+      #   # good
+      #   # When EnforcedStyle is squiggly, bad code is auto-corrected to the
+      #   # following code.
+      #   <<~RUBY
+      #     something
+      #   RUBY
+      #
+      # @example EnforcedStyle: active_support
+      #   # good
+      #   # When EnforcedStyle is active_support, bad code is auto-corrected to
+      #   # the following code.
+      #   <<-RUBY.strip_heredoc
+      #     something
+      #   RUBY
+      #
+      # @example EnforcedStyle: powerpack
+      #   # good
+      #   # When EnforcedStyle is powerpack, bad code is auto-corrected to
+      #   # the following code.
+      #   <<-RUBY.strip_indent
+      #     something
+      #   RUBY
+      #
+      # @example EnforcedStyle: unindent
+      #   # good
+      #   # When EnforcedStyle is unindent, bad code is auto-corrected to
+      #   # the following code.
+      #   <<-RUBY.unindent
+      #     something
+      #   RUBY
+      #
+      class IndentHeredoc < Cop
+        include Heredoc
+        include ConfigurableEnforcedStyle
+
+        RUBY23_TYPE_MSG = 'Use %<indentation_width>d spaces for indentation ' \
+                          'in a heredoc by using `<<~` instead of ' \
+                          '`%<current_indent_type>s`.'
+        RUBY23_WIDTH_MSG = 'Use %<indentation_width>d spaces for '\
+                           'indentation in a heredoc.'
+        LIBRARY_MSG = 'Use %<indentation_width>d spaces for indentation in a ' \
+                      'heredoc by using %<method>s.'
+        STRIP_METHODS = {
+          unindent: 'unindent',
+          active_support: 'strip_heredoc',
+          powerpack: 'strip_indent'
+        }.freeze
+
+        def on_heredoc(node)
+          body = heredoc_body(node)
+          return if body.strip.empty?
+
+          body_indent_level = indent_level(body)
+
+          if heredoc_indent_type(node) == '~'
+            expected_indent_level = base_indent_level(node) + indentation_width
+            return if expected_indent_level == body_indent_level
+          else
+            return unless body_indent_level.zero?
+          end
+
+          return if line_too_long?(node)
+
+          add_offense(node, location: :heredoc_body)
+        end
+
+        def autocorrect(node)
+          check_style!
+
+          case style
+          when :squiggly
+            correct_by_squiggly(node)
+          else
+            correct_by_library(node)
+          end
+        end
+
+        private
+
+        def message(node)
+          case style
+          when :squiggly
+            current_indent_type = "<<#{heredoc_indent_type(node)}"
+            ruby23_message(indentation_width, current_indent_type)
+          when nil
+            method = "some library(e.g. ActiveSupport's `String#strip_heredoc`)"
+            library_message(indentation_width, method)
+          else
+            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)
+          if current_indent_type == '<<~'
+            ruby23_width_message(indentation_width)
+          else
+            ruby23_type_message(indentation_width, current_indent_type)
+          end
+        end
+
+        def ruby23_type_message(indentation_width, current_indent_type)
+          format(
+            RUBY23_TYPE_MSG,
+            indentation_width: indentation_width,
+            current_indent_type: current_indent_type
+          )
+        end
+
+        def ruby23_width_message(indentation_width)
+          format(
+            RUBY23_WIDTH_MSG,
+            indentation_width: indentation_width
+          )
+        end
+
+        def line_too_long?(node)
+          return false if unlimited_heredoc_length?
+
+          body = heredoc_body(node)
+
+          expected_indent = base_indent_level(node) + indentation_width
+          actual_indent = indent_level(body)
+          increase_indent_level = expected_indent - actual_indent
+
+          longest_line(body).size + increase_indent_level >= max_line_length
+        end
+
+        def longest_line(lines)
+          lines.each_line.max_by { |line| line.chomp.size }.chomp
+        end
+
+        def unlimited_heredoc_length?
+          config.for_cop('Metrics/LineLength')['AllowHeredoc']
+        end
+
+        def max_line_length
+          config.for_cop('Metrics/LineLength')['Max']
+        end
+
+        def correct_by_squiggly(node)
+          lambda do |corrector|
+            if heredoc_indent_type(node) == '~'
+              adjust_squiggly(corrector, node)
+            else
+              adjust_minus(corrector, node)
+            end
+          end
+        end
+
+        def adjust_squiggly(corrector, node)
+          corrector.replace(node.loc.heredoc_body, indented_body(node))
+          corrector.replace(node.loc.heredoc_end, indented_end(node))
+        end
+
+        def adjust_minus(corrector, node)
+          heredoc_beginning = node.loc.expression.source
+          corrected = heredoc_beginning.sub(/<<-?/, '<<~')
+          corrector.replace(node.loc.expression, corrected)
+        end
+
+        def correct_by_library(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.heredoc_body, indented_body(node))
+            corrected = ".#{STRIP_METHODS[style]}"
+            corrector.insert_after(node.loc.expression, corrected)
+          end
+        end
+
+        def check_style!
+          return if style
+
+          raise Warning, "Auto-correction does not work for #{cop_name}. " \
+                         'Please configure EnforcedStyle.'
+        end
+
+        def indented_body(node)
+          body = heredoc_body(node)
+          body_indent_level = indent_level(body)
+          correct_indent_level = base_indent_level(node) + indentation_width
+          body.gsub(/^[^\S\r\n]{#{body_indent_level}}/,
+                    ' ' * correct_indent_level)
+        end
+
+        def indented_end(node)
+          end_ = heredoc_end(node)
+          end_indent_level = indent_level(end_)
+          correct_indent_level = base_indent_level(node)
+          if end_indent_level < correct_indent_level
+            end_.gsub(/^\s{#{end_indent_level}}/, ' ' * correct_indent_level)
+          else
+            end_
+          end
+        end
+
+        def base_indent_level(node)
+          base_line_num = node.loc.expression.line
+          base_line = processed_source.lines[base_line_num - 1]
+          indent_level(base_line)
+        end
+
+        def indent_level(str)
+          indentations = str.lines
+                            .map { |line| line[/^\s*/] }
+                            .reject { |line| line == "\n" }
+          indentations.empty? ? 0 : indentations.min_by(&:size).size
+        end
+
+        # Returns '~', '-' or nil
+        def heredoc_indent_type(node)
+          node.source[/^<<([~-])/, 1]
+        end
+
+        def indentation_width
+          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
+        end
+
+        def heredoc_body(node)
+          node.loc.heredoc_body.source.scrub
+        end
+
+        def heredoc_end(node)
+          node.loc.heredoc_end.source.scrub
+        end
+      end
+    end
+  end
+end