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 )