class RuboCop::Cop::Layout::EmptyComment


end
class Foo
#
# Description of ‘Foo` class.
#
# bad
@example AllowMarginComment: false
end
class Foo
#
# Description of `Foo` class.
#
# good
@example AllowMarginComment: true (default)
end
def bar
#################
end
def foo
# bad
@example AllowBorderComment: false
end
def bar
#################
end
def foo
# good
@example AllowBorderComment: true (default)
end
class Foo
#
# Description of `Foo` class.
#
# good
end
class Foo
#
# bad
@example
This cop checks empty comment.

def allow_border_comment? 

def allow_border_comment?
  cop_config['AllowBorderComment']
end

def allow_margin_comment? 

def allow_margin_comment?
  cop_config['AllowMarginComment']
end

def autocorrect(corrector, node) 

def autocorrect(corrector, node)
  previous_token = previous_token(node)
  range = if previous_token && same_line?(node, previous_token)
            range_with_surrounding_space(range: node.loc.expression, newlines: false)
          else
            range_by_whole_lines(node.loc.expression, include_final_newline: true)
          end
  corrector.remove(range)
end

def comment_text(comment) 

def comment_text(comment)
  "#{comment.text.strip}\n"
end

def concat_consecutive_comments(comments) 

def concat_consecutive_comments(comments)
  consecutive_comments = comments.chunk_while { |i, j| i.loc.line.succ == j.loc.line }
  consecutive_comments.map do |chunk|
    joined_text = chunk.map { |c| comment_text(c) }.join
    [joined_text, chunk]
  end
end

def current_token(comment) 

def current_token(comment)
  processed_source.find_token { |token| token.pos == comment.loc.expression }
end

def empty_comment_only?(comment_text) 

def empty_comment_only?(comment_text)
  empty_comment_pattern = if allow_border_comment?
                            /\A(#\n)+\z/
                          else
                            /\A(#+\n)+\z/
                          end
  empty_comment_pattern.match?(comment_text)
end

def investigate(comments) 

def investigate(comments)
  comments.each do |comment|
    next unless empty_comment_only?(comment[0])
    comment[1].each do |offense_comment|
      add_offense(offense_comment) do |corrector|
        autocorrect(corrector, offense_comment)
      end
    end
  end
end

def on_new_investigation 

def on_new_investigation
  if allow_margin_comment?
    comments = concat_consecutive_comments(processed_source.comments)
    investigate(comments)
  else
    processed_source.comments.each do |comment|
      next unless empty_comment_only?(comment_text(comment))
      add_offense(comment) { |corrector| autocorrect(corrector, comment) }
    end
  end
end

def previous_token(node) 

def previous_token(node)
  current_token = current_token(node)
  index = processed_source.tokens.index(current_token)
  index.zero? ? nil : processed_source.tokens[index - 1]
end