# frozen_string_literal: true module RuboCop module Cop module Lint # 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 # # # bad # # foo.bar # .each do # baz # end # # @example # # # EnforcedStyleAlignWith: either (default) # # # good # # variable = lambda do |i| # i # end # # @example # # # EnforcedStyleAlignWith: start_of_block # # # good # # foo.bar # .each do # baz # end # # @example # # # EnforcedStyleAlignWith: start_of_line # # # good # # foo.bar # .each do # baz # end class BlockAlignment < Cop include ConfigurableEnforcedStyle MSG = '%s is not aligned with %s%s.'.freeze 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 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) while (parent = node.parent) break if !parent || !parent.loc break if parent.loc.line != node.loc.line && !parent.masgn_type? break unless block_end_align_target?(parent, node) node = parent end node 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, end_loc, message) end def format_message(start_loc, end_loc, do_source_line_column, error_source_line_column) format( MSG, format_source_line_column(loc_to_source_line_column(end_loc)), format_source_line_column(error_source_line_column), 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 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 > 0 add_space_before(loc_end, delta) elsif delta < 0 remove_space_before(loc_end.begin_pos, -delta) end 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