def get_mark(self):
if self.stream is None:
return Mark(self.name, self.index, self.line, self.column,
self.buffer, self.pointer)
else:
return Mark(self.name, self.index, self.line, self.column,
None, None)
def _get_dummy_node() -> Node:
return Node(
"tag",
"value",
Mark("file_name", 0, 10, 42, None, 0),
Mark("file_name", 0, 12, 32, None, 0),
)
def internal(o, start, *args, **kwargs):
r, end = parser(o, start, *args, **kwargs)
start_line, start_col = linecol(o, start)
end_line, end_col = linecol(o, end)
start_mark = Mark(name, start, start_line, start_col, o, start)
end_mark = Mark(name, end, end_line, end_col, o, start)
return node_type(r, start_mark, end_mark), end
def shift_file_marks(self, line_offset, column_offset=0):
""" Shift the stored file marks by an offset value.
Args:
line_offset : The number of lines the file mark has moved by
column_offset: The number of columns the file mark has moved by
"""
self.__start_mark = Mark(self.__start_mark.name,
self.__start_mark.index,
self.__start_mark.line + line_offset,
self.__start_mark.column + column_offset,
self.__start_mark.buffer,
self.__start_mark.pointer)
self.__end_mark = Mark(self.__end_mark.name, self.__end_mark.index,
self.__end_mark.line + line_offset,
self.__end_mark.column + column_offset,
self.__end_mark.buffer, self.__end_mark.pointer)
def test_exception_format() -> None:
"""Test exception __str__ method gives usefull informations."""
node = Node(
"tag",
"value",
Mark("file_name", 0, 10, 42, None, 0),
Mark("file_name", 0, 12, 32, None, 0),
)
message = "Error message"
error = MarshPyError(node, message)
location_string = "file_name:10:42"
error_string = str(error)
assert location_string in error_string
assert message in error_string
def add_marks_to_node(obj, start_mark=None, end_mark=None):
if start_mark is not None:
obj.start_mark = start_mark
else:
obj.start_mark = Mark(None, None, 0, 0, None, None)
if end_mark is not None:
obj.end_mark = end_mark
else:
obj.end_mark = obj.start_mark
def test_construct_float_no_nan(self, value, parse):
mark = Mark(None, None, 2, 8, None, None)
node = ScalarNode(None, value, start_mark=mark)
res = Constructor("float").construct_yaml_float(node)
assert res.value == parse
assert res.loc.line == 3
assert res.loc.column == 9
assert res.loc.stream_name == "float"
def test_construct_int(self, value, parse):
mark = Mark(None, None, 3, 7, None, None)
node = ScalarNode(None, value, start_mark=mark)
res = Constructor("int").construct_yaml_int(node)
assert res.value == parse
assert res.loc.line == 4
assert res.loc.column == 8
assert res.loc.stream_name == "int"
def test_construct_bool_true(self, value, parse):
mark = Mark(None, None, 4, 5, None, None)
node = ScalarNode(None, value, start_mark=mark)
res = Constructor("bool").construct_yaml_bool(node)
assert res.value == parse
assert res.loc.line == 5
assert res.loc.column == 6
assert res.loc.stream_name == "bool"
def test_run_should_exit_with_error_when_target_yaml_parsing_fails(self):
problem_mark = Mark('name', 1, 2, 3, '', '')
mock_when(yadt_lint)._get_configuration(any_value()).thenRaise(ScannerError(problem_mark=problem_mark))
mock_when(yadt_lint.sys).exit(any_value()).thenReturn(None)
yadt_lint._validate_yaml_input(problem_mark)
verify(yadt_lint.sys).exit(1)
verify(yadt_lint.logger).error('Invalid YAML Format check position: (line:column) -> (2:4)')
def test_construct_str(self, value):
mark = Mark(None, None, 0, 0, None, None)
node = ScalarNode(None, value, start_mark=mark)
res = Constructor("str").construct_yaml_str(node)
assert res.value == value
assert res.loc.line == 1
assert res.loc.column == 1
assert res.loc.stream_name == "str"
def test_construct_null(self, value):
mark = Mark(None, None, 1, 2, None, None)
node = ScalarNode(None, value, start_mark=mark)
res = Constructor("null").construct_yaml_null(node)
assert res.value is None
assert res.loc.line == 2
assert res.loc.column == 3
assert res.loc.stream_name == "null"
def test_construct_float_nan_only(self, value):
mark = Mark(None, None, 7, 1, None, None)
node = ScalarNode(None, value, start_mark=mark)
res = Constructor("float").construct_yaml_float(node)
assert math.isnan(res.value)
assert res.loc.line == 8
assert res.loc.column == 2
assert res.loc.stream_name == "float"
def make_parse_error(e, stream):
if isinstance(e, MarkedYAMLOffsetError) and e.offset != 0:
start_mark, end_mark = e.problem_range
indent = _get_indent_at_mark(stream, start_mark)
data = _read_mark_range(stream, start_mark, end_mark)
mark = _get_offset_mark(data, e.offset, indent)
if mark.line == 0:
snippet = _read_line_for_mark(stream, start_mark)
mark = Mark(start_mark.name, start_mark.index + mark.index,
start_mark.line, start_mark.column + mark.column, None,
None)
else:
snippet = _get_line_for_index(data, mark.index)
mark = Mark(start_mark.name, start_mark.index + mark.index,
start_mark.line + mark.line, mark.column, None, None)
else:
mark = e.problem_mark
snippet = _read_line_for_mark(stream, mark)
return YamlParseError(e.problem, mark, snippet.rstrip())
def test_construct_map_duplicate(self):
mark = Mark(None, None, 8, 8, None, None)
children = [
(
ScalarNode("tag:yaml.org,2002:str", "node1", start_mark=mark),
ScalarNode("tag:yaml.org,2002:str", "node1", start_mark=mark),
),
(
ScalarNode("tag:yaml.org,2002:str", "node1", start_mark=mark),
ScalarNode("tag:yaml.org,2002:str", "node1", start_mark=mark),
)
]
node = MappingNode("tag:yaml.org,2002:map", children, start_mark=mark)
with pytest.raises(ConstructorError):
res, = Constructor("map").construct_yaml_map(node)
def test_construct_seq(self):
mark = Mark(None, None, 4, 3, None, None)
children = [
ScalarNode("tag:yaml.org,2002:int", str(i), start_mark=mark)
for i in range(4)
]
node = SequenceNode(None, children, start_mark=mark)
# Sequences are single-element generators (lazy parsing) that we need
# to exhaust. Simplest way of doing this is to assign to a single
# element tuple and let the python do all the iterator funky-ness.
res, = Constructor("seq").construct_yaml_seq(node)
assert [0, 1, 2, 3] == [child.value for child in res.value]
assert res.loc.line == 5
assert res.loc.column == 4
assert res.loc.stream_name == "seq"
def test_construct_map(self):
mark = Mark(None, None, 8, 8, None, None)
children = [(
ScalarNode("tag:yaml.org,2002:str", str(i), start_mark=mark),
ScalarNode("tag:yaml.org,2002:int", str(i), start_mark=mark),
) for i in range(2)]
node = MappingNode(None, children, start_mark=mark)
res, = Constructor("map").construct_yaml_map(node)
assert {
"0": 0,
"1": 1
} == {k.value: v.value
for k, v in res.value.items()}
assert res.loc.line == 9
assert res.loc.column == 9
assert res.loc.stream_name == "map"
def rebuild_mark(mark):
return Mark(
mark.name, mark.index,
pre_top.get_result()[mark.line-1].input_line,
mark.column, mark.buffer, mark.pointer
)
