def represent_mapping(self, tag, mapping, flow_style=None): value = [] node = MappingNode(tag, value, flow_style=flow_style) if self.alias_key is not None: self.represented_objects[self.alias_key] = node best_style = True if hasattr(mapping, 'items'): # if it's a syaml_dict, preserve OrderedDict order. # Otherwise do the default thing. sort = not isinstance(mapping, syaml_dict) mapping = list(mapping.items()) if sort: mapping.sort() for item_key, item_value in mapping: node_key = self.represent_data(item_key) node_value = self.represent_data(item_value) if not (isinstance(node_key, ScalarNode) and not node_key.style): best_style = False if not (isinstance(node_value, ScalarNode) and not node_value.style): best_style = False value.append((node_key, node_value)) if flow_style is None: if self.default_flow_style is not None: node.flow_style = self.default_flow_style else: node.flow_style = best_style return node
def test_set_comparison(self): null = ScalarNode(YAML_NULL_TAG, "") n1 = MappingNode(YAML_SET_TAG, [(ystr("a"), null), (ystr("b"), null)]) n2 = MappingNode(YAML_SET_TAG, [(ystr("b"), null), (ystr("a"), null)]) n3 = MappingNode(YAML_SET_TAG, [(ystr("b"), null), (ystr("a"), null), (ystr("c"), null)]) n4 = MappingNode(YAML_SET_TAG, [(ystr("b"), null), (ystr("a"), null), (ystr("d"), null)]) self.assertTrue(nodes_equal(n1, n2)) self.assertFalse(nodes_equal(n1, n3)) self.assertFalse(nodes_equal(n3, n1)) self.assertFalse(nodes_equal(n3, n4)) self.assertFalse(nodes_equal(n4, n3))
def _accept_mapping(self, anchor, sink_node): start_event = self._event_next() tag = self._resolve_tag(start_event.tag, MappingNode, None, start_event.implicit) start_event.tag = tag yield start_event node = MappingNode(tag, [], start_event.start_mark, None, flow_style=start_event.flow_style) self._set_anchor(anchor, node) while not self._event_peek_isa(MappingEndEvent): sink_key = _Sink() sink_value = _Sink() if self._settings.with_extra_events: mark = self._event_peek().start_mark yield PairStartEvent(mark) yield PairKeyStartEvent(mark) for ee in self._accept_any_value(node, None, sink_key): yield ee if self._settings.with_extra_events: mark = self._event_peek().start_mark yield PairKeyEndEvent(mark) yield PairValueStartEvent(mark) for ee in self._accept_any_value(node, sink_key.value, sink_value): yield ee if self._settings.with_extra_events: mark = self._event_peek().start_mark yield PairValueEndEvent(mark) yield PairEndEvent(mark) if self._settings.composing_fully: node.value.append((sink_key.value, sink_value.value)) end_event = self._event_next() yield end_event node.end_mark = end_event.end_mark _put(sink_node, node)
def test_unknown_tag_comparison(self): n1 = ScalarNode(YAML_NS + "xyz", "foo") n2 = ScalarNode(YAML_NS + "xyz", "foo") n3 = ScalarNode(YAML_NS + "xyz", "bar") self.assertTrue(nodes_equal(n1, n2)) self.assertFalse(nodes_equal(n1, n3)) n1 = SequenceNode(YAML_NS + "xyz", [ystr("foo")]) n2 = SequenceNode(YAML_NS + "xyz", [ystr("foo")]) n3 = SequenceNode(YAML_NS + "xyz", [ystr("bar")]) self.assertTrue(nodes_equal(n1, n2)) self.assertFalse(nodes_equal(n1, n3)) n1 = MappingNode(YAML_NS + "xyz", [(ystr("foo"), ystr("bar"))]) n2 = MappingNode(YAML_NS + "xyz", [(ystr("foo"), ystr("bar"))]) n3 = MappingNode(YAML_NS + "xyz", [(ystr("foo"), ystr("baz"))]) self.assertTrue(nodes_equal(n1, n2)) self.assertFalse(nodes_equal(n1, n3))
def test_map_misordered_comparison(self): n1 = MappingNode(YAML_MAP_TAG, [(ystr("a"), ystr("foo")), (ystr("b"), ystr("bar"))]) n2 = MappingNode(YAML_MAP_TAG, [(ystr("b"), ystr("bar")), (ystr("a"), ystr("foo"))]) n3 = MappingNode(YAML_MAP_TAG, [(ystr("a"), ystr("bar")), (ystr("b"), ystr("foo")), (ystr("c"), ystr("baz"))]) n4 = MappingNode(YAML_MAP_TAG, [(ystr("a"), ystr("bar")), (ystr("b"), ystr("foo")), (ystr("c"), ystr("xxx"))]) n5 = MappingNode(YAML_MAP_TAG, [(ystr("a"), ystr("bar")), (ystr("b"), ystr("foo")), (ystr("d"), ystr("xxx"))]) self.assertTrue(nodes_equal(n1, n2)) self.assertTrue(nodes_equal(n2, n1)) self.assertFalse(nodes_equal(n1, n3)) self.assertFalse(nodes_equal(n3, n4)) self.assertFalse(nodes_equal(n4, n5))
def represent_map(self, mapping): value = [] node = MappingNode('tag:yaml.org,2002:map', value) if self.alias_key is not None: self.represented_objects[self.alias_key] = node best_style = True if hasattr(mapping, 'items'): mapping = mapping.items() for item_key, item_value in mapping: node_key = self.represent_data(item_key) node_value = self.represent_data(item_value) if not (isinstance(node_key, ScalarNode) and not node_key.style): best_style = False if not (isinstance(node_value, ScalarNode) and not node_value.style): best_style = False value.append((node_key, node_value)) if self.default_flow_style is not None: node.flow_style = self.default_flow_style else: node.flow_style = best_style return node
def represent_ordered_mapping(dumper, tag, mapping, flow_style=None): value = [] node = MappingNode(tag, value, flow_style=flow_style) if dumper.alias_key is not None: dumper.represented_objects[dumper.alias_key] = node best_style = True if hasattr(mapping, 'items'): mapping = list(mapping.items()) for item_key, item_value in mapping: node_key = dumper.represent_data(item_key) node_value = dumper.represent_data(item_value) if not (isinstance(node_key, ScalarNode) and not node_key.style): best_style = False if not (isinstance(node_value, ScalarNode) and not node_value.style): best_style = False value.append((node_key, node_value)) if flow_style is None: if dumper.default_flow_style is not None: node.flow_style = dumper.default_flow_style else: node.flow_style = best_style return node
def _represent_ordered_dict(self, mapping, flow_style=None): value = [] node = MappingNode(_YAML_MAP_TAG, value, flow_style=flow_style) if self.alias_key is not None: self.represented_objects[self.alias_key] = node best_style = True if hasattr(mapping, 'items'): mapping = mapping.items() for item_key, item_value in mapping: node_key = self.represent_data(item_key) node_value = self.represent_data(item_value) if not (isinstance(node_key, ScalarNode) and not node_key.style): best_style = False if not (isinstance(node_value, ScalarNode) and not node_value.style): best_style = False value.append((node_key, node_value)) if flow_style is None: if self.default_flow_style is not None: node.flow_style = self.default_flow_style else: node.flow_style = best_style return node
def merge_nodes(a, b): """ merge_nodes(a, b) -> node Merge the values of the two nodes together to produce a new node. """ if a.tag == YAML_NULL_TAG: node = b elif b.tag == YAML_NULL_TAG: node = a elif isinstance(a, ScalarNode): raise AssemblyError("Cannot merge %s value at" % simplify_tag(b.tag), b.start_mark, "into %s value at" % simplify_tag(a.tag), a.start_mark) elif isinstance(a, SequenceNode): if not isinstance(b, SequenceNode) or b.tag != a.tag: raise AssemblyError( "Cannot merge %s value at" % simplify_tag(b.tag), b.start_mark, "into %s value at" % simplify_tag(a.tag), a.start_mark) node = SequenceNode(a.tag, a.value + b.value) elif isinstance(a, MappingNode): if not isinstance(b, MappingNode) or b.tag != a.tag: raise AssemblyError( "Cannot merge %s value at" % simplify_tag(b.tag), b.start_mark, "into %s value at" % simplify_tag(a.tag), a.start_mark) # If the existing value is a regular map (not an omap), we need to # look for duplicate keys and raise an exception if one # is found. Since YAML allows for complex keys (sequences, etc.), # PyYAML stores mappings as an unordered list of (key, value) tuples. if a.tag == YAML_MAP_TAG: for bkey, _ in b.value: pos = mapping_find(a, bkey) if pos is not None: akey = pos[1] raise AssemblyError( "Cannot merge duplicate mapping key '%s' at" % bkey.value, bkey.start_mark, "into existing mapping at", akey.start_mark) # Extend the existing mapping node = MappingNode(a.tag, a.value + b.value) else: raise RuntimeError("Unable to handle node of type %s" % type(a).__name__) return node
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 represent_omap(dumper, mapping, flow_style=None): value = [] tag = 'tag:yaml.org,2002:omap' node = SequenceNode(tag, value, flow_style=flow_style) if dumper.alias_key is not None: dumper.represented_objects[dumper.alias_key] = node best_style = True for item_key, item_value in mapping.items(): node_key = dumper.represent_data(item_key) node_value = dumper.represent_data(item_value) subnode = MappingNode('tag:yaml.org,2002:map', [ ( node_key,node_value ) ]) value.append(subnode) node.flow_style = True return node
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 filector(basector, node): if len(node.value) > 1 and len( node.value[1]) and node.value[1][0].value == 'addresses': games = defaultctor( basector, SequenceNode(yaml.resolver.BaseResolver.DEFAULT_SEQUENCE_TAG, [node.value[0][1]])) d = dict() for value in MappingNode( yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, node.value[1][1].value).value: result = AliasData(defaultctor(basector, value[0])) nextnode = value[1] if isinstance(nextnode, ScalarNode): result.setvalue('*', nextnode.value) else: for v in nextnode.value: result.setvalue(defaultctor(basector, v[0]), defaultctor(basector, v[1])) d[result.alias] = result return AliasList(games[0], d) return defaultctor(basector, node)