def test_empty_string():
"""
Make sure that an empty string is handled properly
"""
# Arrange
input_string = ""
expected_output = (0, "")
# Act
actual_output = ParserHelper.extract_whitespace_from_end(input_string)
# Assert
assert expected_output == actual_output
def test_string_with_some_trailing_spaces():
"""
Make sure that a string with some trailing spaces is handled properly
"""
# Arrange
input_string = "some trailing spaces "
expected_output = (len(input_string) - 2, " ")
# Act
actual_output = ParserHelper.extract_whitespace_from_end(input_string)
# Assert
assert expected_output == actual_output
def next_line(self, context: PluginScanContext, line: str) -> None:
"""
Event that a new line is being processed.
"""
if (self.__leaf_token_index + 1 < len(self.__leaf_tokens)
and self.__line_index
== self.__leaf_tokens[self.__leaf_token_index + 1].line_number
and self.__leaf_tokens[self.__leaf_token_index + 1].is_leaf):
self.__leaf_token_index = self.__inline_token_index + 1
self.__inline_token_index = self.__leaf_token_index
if (self.__inline_token_index + 1 < len(self.__leaf_tokens)
and self.__line_index
== self.__leaf_tokens[self.__inline_token_index +
1].line_number):
self.__inline_token_index += 1
if (not self.__leaf_tokens[self.__leaf_token_index].is_code_block
and line and line[-1] == " "):
(
first_non_whitespace_index,
extracted_whitespace,
) = ParserHelper.extract_whitespace_from_end(line)
extracted_whitespace_length = len(extracted_whitespace)
is_list_empty_line = False
leaf_token = self.__leaf_owner_tokens[self.__leaf_token_index]
if leaf_token is not None:
is_list_empty_line = (self.__list_item_empty_lines_mode
and leaf_token.is_list_start
and first_non_whitespace_index == 0)
if extracted_whitespace_length != self.__break_spaces or (
self.__strict_mode and not is_list_empty_line):
self.__report_error(context, extracted_whitespace_length,
first_non_whitespace_index)
self.__line_index += 1
def __adjust_for_list_start(
original_line_to_parse,
last_list_start_index,
last_block_quote_index,
):
did_process = False
LOGGER.debug("last_list_start_index>>%s>>", str(last_list_start_index))
LOGGER.debug("original_line_to_parse>>%s>>",
original_line_to_parse.replace("\t", "\\t"))
offset_index = 0
if last_list_start_index:
new_index, extracted_whitespace = ParserHelper.extract_whitespace_from_end(
original_line_to_parse, last_list_start_index)
LOGGER.debug("new_index>>%s>>", str(new_index))
LOGGER.debug(
"extracted_whitespace>>%s>>",
str(extracted_whitespace).replace("\t", "\\t"),
)
if "\t" in extracted_whitespace:
last_block_quote_index = new_index
offset_index = 1
did_process = True
return did_process, offset_index, last_block_quote_index
def __prepare_for_create_atx_heading(
parser_state: ParserState,
position_marker: PositionMarker,
new_tokens: List[MarkdownToken],
non_whitespace_index: int,
) -> Tuple[StackToken, str, int, str, str, List[MarkdownToken]]:
(
old_top_of_stack,
remaining_line,
remove_trailing_count,
extracted_whitespace_before_end,
) = (
parser_state.token_stack[-1],
position_marker.text_to_parse[non_whitespace_index:],
0,
"",
)
new_tokens, _ = parser_state.close_open_blocks_fn(parser_state)
(
end_index,
extracted_whitespace_at_end,
) = ParserHelper.extract_whitespace_from_end(remaining_line)
while (
end_index > 0
and remaining_line[end_index - 1] == LeafBlockProcessor.__atx_character
):
end_index -= 1
remove_trailing_count += 1
if remove_trailing_count:
if end_index > 0:
if ParserHelper.is_character_at_index(
remaining_line, end_index - 1, " "
):
remaining_line = remaining_line[:end_index]
(
_,
new_non_whitespace_index,
) = ParserHelper.collect_backwards_while_character(
remaining_line, len(remaining_line) - 1, " "
)
assert new_non_whitespace_index is not None
end_index = new_non_whitespace_index
extracted_whitespace_before_end = remaining_line[end_index:]
remaining_line = remaining_line[:end_index]
else:
extracted_whitespace_at_end, remove_trailing_count = "", 0
else:
remaining_line = ""
else:
extracted_whitespace_at_end = remaining_line[end_index:]
remaining_line = remaining_line[:end_index]
return (
old_top_of_stack,
remaining_line,
remove_trailing_count,
extracted_whitespace_before_end,
extracted_whitespace_at_end,
new_tokens,
)
def parse_atx_headings(parser_state, position_marker,
extracted_whitespace):
"""
Handle the parsing of an atx heading.
"""
new_tokens = []
if ParserHelper.is_length_less_than_or_equal_to(
extracted_whitespace,
3) and ParserHelper.is_character_at_index(
position_marker.text_to_parse,
position_marker.index_number,
LeafBlockProcessor.__atx_character,
):
hash_count, new_index = ParserHelper.collect_while_character(
position_marker.text_to_parse,
position_marker.index_number,
LeafBlockProcessor.__atx_character,
)
(
non_whitespace_index,
extracted_whitespace_at_start,
) = ParserHelper.extract_whitespace(position_marker.text_to_parse,
new_index)
if hash_count <= 6 and (extracted_whitespace_at_start
or non_whitespace_index == len(
position_marker.text_to_parse)):
new_tokens, _, _ = parser_state.close_open_blocks_fn(
parser_state, new_tokens)
remaining_line = position_marker.text_to_parse[
non_whitespace_index:]
(
end_index,
extracted_whitespace_at_end,
) = ParserHelper.extract_whitespace_from_end(remaining_line)
remove_trailing_count = 0
while (end_index > 0 and remaining_line[end_index - 1]
== LeafBlockProcessor.__atx_character):
end_index -= 1
remove_trailing_count += 1
extracted_whitespace_before_end = ""
if remove_trailing_count:
if end_index > 0:
if ParserHelper.is_character_at_index_whitespace(
remaining_line, end_index - 1):
remaining_line = remaining_line[:end_index]
(
end_index,
extracted_whitespace_before_end,
) = ParserHelper.extract_whitespace_from_end(
remaining_line)
remaining_line = remaining_line[:end_index]
else:
extracted_whitespace_at_end = ""
remove_trailing_count = 0
else:
remaining_line = ""
else:
extracted_whitespace_at_end = remaining_line[end_index:]
remaining_line = remaining_line[0:end_index]
start_token = AtxHeadingMarkdownToken(
hash_count,
remove_trailing_count,
extracted_whitespace,
position_marker,
)
new_tokens.append(start_token)
new_tokens.append(
TextMarkdownToken(remaining_line,
extracted_whitespace_at_start))
end_token = EndMarkdownToken(
"atx",
extracted_whitespace_at_end,
extracted_whitespace_before_end,
None,
)
end_token.start_markdown_token = start_token
new_tokens.append(end_token)
return new_tokens
