rubocop 0.78.0

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks for a line break before the first element in a
+      # multi-line array.
+      #
+      # @example
+      #
+      #     # bad
+      #     [ :a,
+      #       :b]
+      #
+      #     # good
+      #     [
+      #       :a,
+      #       :b]
+      #
+      class FirstArrayElementLineBreak < Cop
+        include FirstElementLineBreak
+
+        MSG = 'Add a line break before the first element of a ' \
+              'multi-line array.'
+
+        def on_array(node)
+          return if !node.loc.begin && !assignment_on_same_line?(node)
+
+          check_children_line_break(node, node.children)
+        end
+
+        def autocorrect(node)
+          EmptyLineCorrector.insert_before(node)
+        end
+
+        private
+
+        def assignment_on_same_line?(node)
+          source = node.source_range.source_line[0...node.loc.column]
+          source =~ /\s*\=\s*$/
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/first_hash_element_indentation.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 HashAlignment 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 FirstHashElementIndentation < 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.first_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/HashAlignment')[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/first_hash_element_line_break.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks for a line break before the first element in a
+      # multi-line hash.
+      #
+      # @example
+      #
+      #     # bad
+      #     { a: 1,
+      #       b: 2}
+      #
+      #     # good
+      #     {
+      #       a: 1,
+      #       b: 2 }
+      class FirstHashElementLineBreak < Cop
+        include FirstElementLineBreak
+
+        MSG = 'Add a line break before the first element of a ' \
+              'multi-line hash.'
+
+        def on_hash(node)
+          # node.loc.begin tells us whether the hash opens with a {
+          # If it doesn't, Style/FirstMethodArgumentLineBreak will handle it
+          check_children_line_break(node, node.children) if node.loc.begin
+        end
+
+        def autocorrect(node)
+          EmptyLineCorrector.insert_before(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks for a line break before the first argument in a
+      # multi-line method call.
+      #
+      # @example
+      #
+      #     # bad
+      #     method(foo, bar,
+      #       baz)
+      #
+      #     # good
+      #     method(
+      #       foo, bar,
+      #       baz)
+      #
+      #     # ignored
+      #     method foo, bar,
+      #       baz
+      class FirstMethodArgumentLineBreak < Cop
+        include FirstElementLineBreak
+
+        MSG = 'Add a line break before the first argument of a ' \
+              'multi-line method argument list.'
+
+        def on_send(node)
+          args = node.arguments
+
+          # If there is a trailing hash arg without explicit braces, like this:
+          #
+          #    method(1, 'key1' => value1, 'key2' => value2)
+          #
+          # ...then each key/value pair is treated as a method 'argument'
+          # when determining where line breaks should appear.
+          if (last_arg = args.last)
+            if last_arg.hash_type? && !last_arg.braces?
+              args = args.concat(args.pop.children)
+            end
+          end
+
+          check_method_line_break(node, args)
+        end
+        alias on_csend on_send
+        alias on_super on_send
+
+        def autocorrect(node)
+          EmptyLineCorrector.insert_before(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks for a line break before the first parameter in a
+      # multi-line method parameter definition.
+      #
+      # @example
+      #
+      #     # bad
+      #     def method(foo, bar,
+      #         baz)
+      #       do_something
+      #     end
+      #
+      #     # good
+      #     def method(
+      #         foo, bar,
+      #         baz)
+      #       do_something
+      #     end
+      #
+      #     # ignored
+      #     def method foo,
+      #         bar
+      #       do_something
+      #     end
+      class FirstMethodParameterLineBreak < Cop
+        include FirstElementLineBreak
+
+        MSG = 'Add a line break before the first parameter of a ' \
+              'multi-line method parameter list.'
+
+        def on_def(node)
+          check_method_line_break(node, node.arguments)
+        end
+        alias on_defs on_def
+
+        def autocorrect(node)
+          EmptyLineCorrector.insert_before(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/first_parameter_indentation.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/ParameterAlignment, not by this cop.
+      #
+      # For indenting the first argument of method *calls*, check out
+      # Layout/FirstArgumentIndentation, 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 FirstParameterIndentation < 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