rubocop 0.75.1

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

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks whether the end keywords are aligned properly for do
+      # end blocks.
+      #
+      # Three modes are supported through the `EnforcedStyleAlignWith`
+      # configuration parameter:
+      #
+      # `start_of_block` : the `end` shall be aligned with the
+      # start of the line where the `do` appeared.
+      #
+      # `start_of_line` : the `end` shall be aligned with the
+      # start of the line where the expression started.
+      #
+      # `either` (which is the default) : the `end` is allowed to be in either
+      # location. The autofixer will default to `start_of_line`.
+      #
+      # @example EnforcedStyleAlignWith: either (default)
+      #   # bad
+      #
+      #   foo.bar
+      #      .each do
+      #        baz
+      #          end
+      #
+      #   # good
+      #
+      #   variable = lambda do |i|
+      #     i
+      #   end
+      #
+      # @example EnforcedStyleAlignWith: start_of_block
+      #   # bad
+      #
+      #   foo.bar
+      #      .each do
+      #        baz
+      #          end
+      #
+      #   # good
+      #
+      #   foo.bar
+      #     .each do
+      #       baz
+      #     end
+      #
+      # @example EnforcedStyleAlignWith: start_of_line
+      #   # bad
+      #
+      #   foo.bar
+      #      .each do
+      #        baz
+      #          end
+      #
+      #   # good
+      #
+      #   foo.bar
+      #     .each do
+      #        baz
+      #   end
+      class BlockAlignment < Cop
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG = '%<current>s is not aligned with %<prefer>s%<alt_prefer>s.'
+
+        def_node_matcher :block_end_align_target?, <<~PATTERN
+          {assignment?
+           splat
+           and
+           or
+           (send _ :<<  ...)
+           (send equal?(%1) !:[] ...)}
+        PATTERN
+
+        def on_block(node)
+          check_block_alignment(start_for_block_node(node), node)
+        end
+
+        def style_parameter_name
+          'EnforcedStyleAlignWith'
+        end
+
+        def autocorrect(node)
+          ancestor_node = start_for_block_node(node)
+          start_col = compute_start_col(ancestor_node, node)
+          loc_end = node.loc.end
+          delta = start_col - loc_end.column
+
+          if delta.positive?
+            add_space_before(loc_end, delta)
+          elsif delta.negative?
+            remove_space_before(loc_end.begin_pos, -delta)
+          end
+        end
+
+        private
+
+        def start_for_block_node(block_node)
+          # Which node should we align the 'end' with?
+          result = block_end_align_target(block_node)
+
+          # In offense message, we want to show the assignment LHS rather than
+          # the entire assignment
+          result, = *result while result.op_asgn_type? || result.masgn_type?
+          result
+        end
+
+        def block_end_align_target(node)
+          lineage = [node, *node.ancestors]
+
+          target = lineage.each_cons(2) do |current, parent|
+            break current if end_align_target?(current, parent)
+          end
+
+          target || lineage.last
+        end
+
+        def end_align_target?(node, parent)
+          disqualified_parent?(parent, node) ||
+            !block_end_align_target?(parent, node)
+        end
+
+        def disqualified_parent?(parent, node)
+          parent&.loc && parent.first_line != node.first_line &&
+            !parent.masgn_type?
+        end
+
+        def check_block_alignment(start_node, block_node)
+          end_loc = block_node.loc.end
+          return unless begins_its_line?(end_loc)
+
+          start_loc = start_node.source_range
+          return unless start_loc.column != end_loc.column ||
+                        style == :start_of_block
+
+          do_source_line_column =
+            compute_do_source_line_column(block_node, end_loc)
+          return unless do_source_line_column
+
+          register_offense(
+            block_node,
+            start_loc,
+            end_loc,
+            do_source_line_column
+          )
+        end
+
+        def register_offense(block_node,
+                             start_loc,
+                             end_loc,
+                             do_source_line_column)
+
+          error_source_line_column = if style == :start_of_block
+                                       do_source_line_column
+                                     else
+                                       loc_to_source_line_column(start_loc)
+                                     end
+
+          message = format_message(start_loc, end_loc, do_source_line_column,
+                                   error_source_line_column)
+
+          add_offense(block_node, location: end_loc, message: message)
+        end
+
+        def format_message(start_loc, end_loc, do_source_line_column,
+                           error_source_line_column)
+          format(
+            MSG,
+            current: format_source_line_column(
+              loc_to_source_line_column(end_loc)
+            ),
+            prefer: format_source_line_column(error_source_line_column),
+            alt_prefer: alt_start_msg(start_loc, do_source_line_column)
+          )
+        end
+
+        def compute_do_source_line_column(node, end_loc)
+          do_loc = node.loc.begin # Actually it's either do or {.
+
+          # We've found that "end" is not aligned with the start node (which
+          # can be a block, a variable assignment, etc). But we also allow
+          # the "end" to be aligned with the start of the line where the "do"
+          # is, which is a style some people use in multi-line chains of
+          # blocks.
+          match = /\S.*/.match(do_loc.source_line)
+          indentation_of_do_line = match.begin(0)
+          return unless end_loc.column != indentation_of_do_line ||
+                        style == :start_of_line
+
+          {
+            source: match[0],
+            line: do_loc.line,
+            column: indentation_of_do_line
+          }
+        end
+
+        def loc_to_source_line_column(loc)
+          {
+            source: loc.source.lines.to_a.first.chomp,
+            line: loc.line,
+            column: loc.column
+          }
+        end
+
+        def alt_start_msg(start_loc, source_line_column)
+          if style != :either
+            ''
+          elsif start_loc.line == source_line_column[:line] &&
+                start_loc.column == source_line_column[:column]
+            ''
+          else
+            ' or ' + format_source_line_column(source_line_column)
+          end
+        end
+
+        def format_source_line_column(source_line_column)
+          "`#{source_line_column[:source]}` at #{source_line_column[:line]}, " \
+          "#{source_line_column[:column]}"
+        end
+
+        def compute_start_col(ancestor_node, node)
+          if style == :start_of_block
+            do_loc = node.loc.begin
+            return do_loc.source_line =~ /\S/
+          end
+          (ancestor_node || node).source_range.column
+        end
+
+        def add_space_before(loc, delta)
+          ->(corrector) { corrector.insert_before(loc, ' ' * delta) }
+        end
+
+        def remove_space_before(end_pos, delta)
+          range = range_between(end_pos - delta, end_pos)
+          ->(corrector) { corrector.remove(range) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks whether the end statement of a do..end block
+      # is on its own line.
+      #
+      # @example
+      #   # bad
+      #   blah do |i|
+      #     foo(i) end
+      #
+      #   # good
+      #   blah do |i|
+      #     foo(i)
+      #   end
+      #
+      #   # bad
+      #   blah { |i|
+      #     foo(i) }
+      #
+      #   # good
+      #   blah { |i|
+      #     foo(i)
+      #   }
+      class BlockEndNewline < Cop
+        include Alignment
+
+        MSG = 'Expression at %<line>d, %<column>d should be on its own line.'
+
+        def on_block(node)
+          return if node.single_line?
+
+          # If the end is on its own line, there is no offense
+          return if begins_its_line?(node.loc.end)
+
+          add_offense(node, location: :end)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(delimiter_range(node),
+                              "\n#{node.loc.end.source}#{offset(node)}")
+          end
+        end
+
+        private
+
+        def message(node)
+          format(MSG, line: node.loc.end.line, column: node.loc.end.column + 1)
+        end
+
+        def delimiter_range(node)
+          Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                    node.children.last.loc.expression.end_pos,
+                                    node.loc.expression.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks how the *when*s of a *case* expression
+      # are indented in relation to its *case* or *end* keyword.
+      #
+      # It will register a separate offense for each misaligned *when*.
+      #
+      # @example
+      #   # If Layout/EndAlignment is set to keyword style (default)
+      #   # *case* and *end* should always be aligned to same depth,
+      #   # and therefore *when* should always be aligned to both -
+      #   # regardless of configuration.
+      #
+      #   # bad for all styles
+      #   case n
+      #     when 0
+      #       x * 2
+      #     else
+      #       y / 3
+      #   end
+      #
+      #   # good for all styles
+      #   case n
+      #   when 0
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
+      #
+      # @example EnforcedStyle: case (default)
+      #   # if EndAlignment is set to other style such as
+      #   # start_of_line (as shown below), then *when* alignment
+      #   # configuration does have an effect.
+      #
+      #   # bad
+      #   a = case n
+      #   when 0
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
+      #
+      #   # good
+      #   a = case n
+      #       when 0
+      #         x * 2
+      #       else
+      #         y / 3
+      #   end
+      #
+      # @example EnforcedStyle: end
+      #   # bad
+      #   a = case n
+      #       when 0
+      #         x * 2
+      #       else
+      #         y / 3
+      #   end
+      #
+      #   # good
+      #   a = case n
+      #   when 0
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
+      class CaseIndentation < Cop
+        include Alignment
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG = 'Indent `when` %<depth>s `%<base>s`.'
+
+        def on_case(case_node)
+          return if case_node.single_line?
+
+          case_node.each_when do |when_node|
+            check_when(when_node)
+          end
+        end
+
+        def autocorrect(node)
+          whitespace = whitespace_range(node)
+
+          return false unless whitespace.source.strip.empty?
+
+          lambda do |corrector|
+            corrector.replace(whitespace, replacement(node))
+          end
+        end
+
+        private
+
+        def check_when(when_node)
+          when_column = when_node.loc.keyword.column
+          base_column = base_column(when_node.parent, style)
+
+          if when_column == base_column + indentation_width
+            correct_style_detected
+          else
+            incorrect_style(when_node)
+          end
+        end
+
+        def indent_one_step?
+          cop_config['IndentOneStep']
+        end
+
+        def indentation_width
+          indent_one_step? ? configured_indentation_width : 0
+        end
+
+        def incorrect_style(when_node)
+          when_column = when_node.loc.keyword.column
+          base_column = base_column(when_node.parent, alternative_style)
+
+          add_offense(when_node, location: :keyword, message: message(style)) do
+            if when_column == base_column
+              opposite_style_detected
+            else
+              unrecognized_style_detected
+            end
+          end
+        end
+
+        def message(base)
+          depth = indent_one_step? ? 'one step more than' : 'as deep as'
+
+          format(MSG, depth: depth, base: base)
+        end
+
+        def base_column(case_node, base)
+          case base
+          when :case then case_node.location.keyword.column
+          when :end  then case_node.location.end.column
+          end
+        end
+
+        def whitespace_range(node)
+          when_column = node.location.keyword.column
+          begin_pos = node.loc.keyword.begin_pos
+
+          range_between(begin_pos - when_column, begin_pos)
+        end
+
+        def replacement(node)
+          case_node = node.each_ancestor(:case).first
+          base_type = cop_config[style_parameter_name] == 'end' ? :end : :case
+
+          column = base_column(case_node, base_type)
+          column += indentation_width
+
+          ' ' * column
+        end
+      end
+    end
+  end
+end