rubbycop 0.49.0

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks the indentation of the first element in an array literal
+      # where the opening bracket and the first element are on separate lines.
+      # The other elements' indentations are handled by the AlignArray cop.
+      #
+      # By default, array literals that are arguments in a method call with
+      # parentheses, and where the opening square bracket of the array is on the
+      # same line as the opening parenthesis of the method call, shall have
+      # their first element indented one step (two spaces) more than the
+      # position inside the opening parenthesis.
+      #
+      # Other array literals shall have their first element indented one step
+      # more than the start of the line where the opening square bracket is.
+      #
+      # 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
+      #                             ]
+      #
+      class IndentArray < Cop
+        include AutocorrectAlignment
+        include ConfigurableEnforcedStyle
+        include ArrayHashIndentation
+
+        def on_array(node)
+          check(node, nil) if node.loc.begin
+        end
+
+        def on_send(node)
+          each_argument_node(node, :array) do |array_node, left_parenthesis|
+            check(array_node, left_parenthesis)
+          end
+        end
+
+        private
+
+        def brace_alignment_style
+          :align_brackets
+        end
+
+        def check(array_node, left_parenthesis)
+          return if ignored_node?(array_node)
+
+          left_bracket = array_node.loc.begin
+          first_elem = array_node.values.first
+          if first_elem
+            return if first_elem.source_range.line == left_bracket.line
+            check_first(first_elem, left_bracket, left_parenthesis, 0)
+          end
+
+          check_right_bracket(array_node.loc.end, left_bracket,
+                              left_parenthesis)
+        end
+
+        def check_right_bracket(right_bracket, left_bracket, left_parenthesis)
+          # if the right bracket is on the same line as the last value, accept
+          return if right_bracket.source_line[0...right_bracket.column] =~ /\S/
+
+          expected_column = base_column(left_bracket, left_parenthesis)
+          @column_delta = expected_column - right_bracket.column
+          return if @column_delta.zero?
+
+          msg = if style == :align_brackets
+                  'Indent the right bracket the same as the left bracket.'
+                elsif style == :special_inside_parentheses && left_parenthesis
+                  'Indent the right bracket the same as the first position ' \
+                  'after the preceding left parenthesis.'
+                else
+                  'Indent the right bracket the same as the start of the line' \
+                  ' where the left bracket is.'
+                end
+          add_offense(right_bracket, right_bracket, msg)
+        end
+
+        # Returns the description of what the correct indentation is based on.
+        def base_description(left_parenthesis)
+          if style == :align_brackets
+            'the position of the opening bracket'
+          elsif left_parenthesis && style == :special_inside_parentheses
+            'the first position after the preceding left parenthesis'
+          else
+            'the start of the line where the left square bracket is'
+          end
+        end
+
+        def message(base_description)
+          format('Use %d spaces for indentation in an array, relative to %s.',
+                 configured_indentation_width, base_description)
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/indent_assignment.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks the indentation of the first line of the
+      # right-hand-side of a multi-line assignment.
+      #
+      # @example
+      #   # bad
+      #   value =
+      #   if foo
+      #     'bar'
+      #   end
+      #
+      #   # good
+      #   value =
+      #     if foo
+      #       'bar'
+      #     end
+      #
+      # The indentation of the remaining lines can be corrected with
+      # other cops such as `IndentationConsistency` and `EndAlignment`.
+      class IndentAssignment < Cop
+        include CheckAssignment
+        include AutocorrectAlignment
+
+        MSG = 'Indent the first line of the right-hand-side of a ' \
+              'multi-line assignment.'.freeze
+
+        def check_assignment(node, rhs)
+          return unless rhs
+          return unless node.loc.operator
+          return if node.loc.operator.line == rhs.loc.line
+
+          base = display_column(node.source_range)
+          check_alignment([rhs], base + configured_indentation_width)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cops 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:
+      #
+      #     # 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
+      #                             }
+      #
+      class IndentHash < Cop
+        include AutocorrectAlignment
+        include ConfigurableEnforcedStyle
+        include ArrayHashIndentation
+
+        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
+
+        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.children, 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, right_brace, 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(pairs, left_brace, left_parenthesis)
+          key_lengths = pairs.map do |pair|
+            pair.children.first.source_range.length
+          end
+          check_first(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('Use %d spaces for indentation in a hash, relative to %s.',
+                 configured_indentation_width, base_description)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cops 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).
+      #
+      # @example
+      #
+      #   # bad
+      #   <<-END
+      #   something
+      #   END
+      #
+      #   # good
+      #   # When EnforcedStyle is squiggly, bad code is auto-corrected to the
+      #   # following code.
+      #   <<~END
+      #     something
+      #   END
+      #
+      #   # good
+      #   # When EnforcedStyle is active_support, bad code is auto-corrected to
+      #   # the following code.
+      #   <<-END.strip_heredoc
+      #     something
+      #   END
+      class IndentHeredoc < Cop
+        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 = {
+          unindent: 'unindent',
+          active_support: 'strip_heredoc',
+          powerpack: 'strip_indent'
+        }.freeze
+
+        def on_str(node)
+          return unless heredoc?(node)
+
+          body_indent_level = body_indent_level(node)
+
+          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
+
+          add_offense(node, :heredoc_body)
+        end
+
+        alias on_dstr on_str
+        alias on_xstr on_str
+
+        def autocorrect(node)
+          check_style!
+
+          case style
+          when :squiggly
+            correct_by_squiggly(node)
+          else
+            correct_by_library(node)
+          end
+        end
+
+        private
+
+        def style
+          style = super
+          return style unless style == :auto_detection
+
+          if target_ruby_version >= 2.3
+            :squiggly
+          elsif rails?
+            :active_support
+          end
+        end
+
+        def message(node)
+          case style
+          when :squiggly
+            current_indent_type = "<<#{heredoc_indent_type(node)}"
+            format(RUBY23_MSG, indentation_width, current_indent_type)
+          when nil
+            method = "some library(e.g. ActiveSupport's `String#strip_heredoc`)"
+            format(LIBRARY_MSG, indentation_width, method)
+          else
+            method = "`String##{StripMethods[style]}`"
+            format(LIBRARY_MSG, indentation_width, method)
+          end
+        end
+
+        def correct_by_squiggly(node)
+          return if target_ruby_version < 2.3
+          lambda do |corrector|
+            if heredoc_indent_type(node) == '~'
+              corrector.replace(node.loc.heredoc_body, indented_body(node))
+            else
+              heredoc_beginning = node.loc.expression.source
+              corrected = heredoc_beginning.sub(/<<-?/, '<<~')
+              corrector.replace(node.loc.expression, corrected)
+            end
+          end
+        end
+
+        def correct_by_library(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.heredoc_body, indented_body(node))
+            corrected = ".#{StripMethods[style]}"
+            corrector.insert_after(node.loc.expression, corrected)
+          end
+        end
+
+        def check_style!
+          case style
+          when nil
+            raise Warning, "Auto-correction does not work for #{cop_name}. " \
+                           'Please configure EnforcedStyle.'
+          when :squiggly
+            if target_ruby_version < 2.3
+              raise Warning, '`squiggly` style is selectable only on Ruby ' \
+                             "2.3 or higher for #{cop_name}."
+            end
+          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)
+          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]
+          indent_level(base_line)
+        end
+
+        def indent_level(str)
+          str.scan(/^\s*/).reject { |line| line == "\n" }.min_by(&:size).size
+        end
+
+        # Returns '~', '-' or nil
+        def heredoc_indent_type(node)
+          node.source[/^<<([~-])/, 1]
+        end
+
+        def indentation_width
+          @config.for_cop('IndentationWidth')['Width'] || 2
+        end
+      end
+    end
+  end
+end