def represent_unicode(self, object):
try:
return _syck.Scalar(object.encode('ascii'),
tag="tag:python.yaml.org,2002:unicode")
except UnicodeEncodeError:
return _syck.Scalar(object.encode('utf-8'),
tag="tag:yaml.org,2002:str")
def testMap(self):
self.assert_(issubclass(_syck.Map, _syck.Node))
map = _syck.Map()
self.assertEqual(map.kind, 'map')
self.assertEqual(map.value, {})
self.assertEqual(map.anchor, None)
self.assertEqual(map.tag, None)
self.assertEqual(map.inline, False)
self.assertRaises(TypeError, lambda: setattr(map, 'kind', 'map'))
self.assertRaises(TypeError, lambda: setattr(map, 'tag', []))
self.assertRaises(TypeError, lambda: setattr(map, 'inline', 'block'))
self.assertRaises(TypeError, lambda: setattr(map, 'inline', []))
value = dict([(_syck.Scalar(str(k)), _syck.Scalar(str(-k)))
for k in range(10)])
map = _syck.Map(value, tag='a_tag', inline=True)
self.assertEqual(map.value, value)
self.assertEqual(map.tag, 'a_tag')
self.assertEqual(map.inline, True)
value = [(_syck.Scalar(str(k)), _syck.Scalar(str(-k)))
for k in range(20)]
map.value = value
map.tag = 'another_tag'
map.inline = False
self.assertEqual(map.value, value)
self.assertEqual(map.tag, 'another_tag')
self.assertEqual(map.inline, False)
map.tag = None
self.assertEqual(map.tag, None)
def testSeq(self):
self.assert_(issubclass(_syck.Seq, _syck.Node))
seq = _syck.Seq()
self.assertEqual(seq.kind, 'seq')
self.assertEqual(seq.value, [])
self.assertEqual(seq.anchor, None)
self.assertEqual(seq.tag, None)
self.assertEqual(seq.inline, False)
self.assertRaises(TypeError, lambda: setattr(seq, 'kind', 'map'))
self.assertRaises(TypeError, lambda: setattr(seq, 'tag', []))
self.assertRaises(TypeError, lambda: setattr(seq, 'inline', 'block'))
self.assertRaises(TypeError, lambda: setattr(seq, 'inline', []))
value = [_syck.Scalar(str(k)) for k in range(10)]
seq = _syck.Seq(value, tag='a_tag', inline=True)
self.assertEqual(seq.value, value)
self.assertEqual(seq.tag, 'a_tag')
self.assertEqual(seq.inline, True)
value = [_syck.Scalar(str(k)) for k in range(20)]
seq.value = value
seq.tag = 'another_tag'
seq.inline = False
self.assertEqual(seq.value, value)
self.assertEqual(seq.tag, 'another_tag')
self.assertEqual(seq.inline, False)
seq.tag = None
self.assertEqual(seq.tag, None)
def represent_str(self, object):
try:
return _syck.Scalar(object.encode('ascii'),
tag="tag:yaml.org,2002:str")
except UnicodeDecodeError:
try:
return _syck.Scalar(unicode(object, 'utf-8').encode('utf-8'),
tag="tag:python.yaml.org,2002:str")
except UnicodeDecodeError:
return _syck.Scalar(object.encode('base64'),
tag="tag:yaml.org,2002:binary")
def testScalar(self):
self.assert_(issubclass(_syck.Scalar, _syck.Node))
scalar = _syck.Scalar()
self.assertEqual(scalar.kind, 'scalar')
self.assertEqual(scalar.value, '')
self.assertEqual(scalar.anchor, None)
self.assertEqual(scalar.tag, None)
self.assertEqual(scalar.style, None)
self.assertEqual(scalar.indent, 0)
self.assertEqual(scalar.width, 0)
self.assertEqual(scalar.chomp, None)
scalar = _syck.Scalar('a value',
tag='a_tag',
style='fold',
indent=4,
width=80,
chomp='+')
self.assertEqual(scalar.value, 'a value')
self.assertEqual(scalar.tag, 'a_tag')
self.assertEqual(scalar.style, 'fold')
self.assertEqual(scalar.indent, 4)
self.assertEqual(scalar.width, 80)
self.assertEqual(scalar.chomp, '+')
self.assertRaises(TypeError, lambda: setattr(scalar, 'kind', 'map'))
self.assertRaises(TypeError, lambda: setattr(scalar, 'value', None))
self.assertRaises(TypeError, lambda: setattr(scalar, 'value', []))
self.assertRaises(TypeError, lambda: setattr(scalar, 'tag', []))
self.assertRaises(ValueError,
lambda: setattr(scalar, 'style', 'block'))
self.assertRaises(TypeError, lambda: setattr(scalar, 'style', []))
self.assertRaises(TypeError, lambda: setattr(scalar, 'indent', '1'))
self.assertRaises(TypeError, lambda: setattr(scalar, 'width', '1'))
self.assertRaises(TypeError, lambda: setattr(scalar, 'chomp', []))
scalar.value = 'another value'
scalar.tag = 'another_tag'
scalar.style = 'literal'
scalar.indent = 2
scalar.width = 100
scalar.chomp = '-'
self.assertEqual(scalar.value, 'another value')
self.assertEqual(scalar.tag, 'another_tag')
self.assertEqual(scalar.style, 'literal')
self.assertEqual(scalar.indent, 2)
self.assertEqual(scalar.width, 100)
self.assertEqual(scalar.chomp, '-')
scalar.tag = None
scalar.style = None
self.assertEqual(scalar.tag, None)
self.assertEqual(scalar.style, None)
def represent(self, object):
"""Represents the given Python object as a 'Node'."""
if isinstance(object, dict):
return _syck.Map(object.copy(), tag="tag:yaml.org,2002:map")
elif isinstance(object, list):
return _syck.Seq(object[:], tag="tag:yaml.org,2002:seq")
else:
return _syck.Scalar(str(object), tag="tag:yaml.org,2002:str")
def represent_float(self, object):
value = repr(object)
if value == self.inf_value:
value = '.inf'
elif value == self.neginf_value:
value = '-.inf'
elif value == self.nan_value:
value = '.nan'
return _syck.Scalar(value, tag="tag:yaml.org,2002:float")
def testGarbage(self):
gc.collect()
seq = _syck.Seq()
seq.value = [seq]
del seq
self.assertEqual(gc.collect(), 2)
scalar1 = _syck.Scalar()
scalar2 = _syck.Scalar()
seq = _syck.Seq()
map1 = _syck.Map()
map2 = _syck.Map()
map1.value[scalar1] = seq
map1.value[scalar2] = map2
map2.value[scalar1] = map1
map2.value[scalar2] = seq
seq.value.append(map1)
seq.value.append(map2)
del scalar1, scalar2, seq, map1, map2
self.assertEqual(gc.collect(), 8)
def testTags(self):
document = _syck.Seq()
for tag in TAGS:
document.value.append(_syck.Scalar('foo', tag=tag))
emitter = _syck.Emitter(StringIO.StringIO())
emitter.emit(document)
parser = _syck.Parser(emitter.output.getvalue())
document = parser.parse()
self.assertEqual(len(document.value), len(TAGS))
for index in range(len(document.value)):
node = document.value[index]
self.assertEqual(node.tag, TAGS[index])
def testSyckBugWithTrailingSpace(self):
emitter = _syck.Emitter(StringIO.StringIO())
emitter.emit(_syck.Scalar('foo ', tag="tag:yaml.org,2002:str"))
parser = _syck.Parser(emitter.output.getvalue())
self.assertEqual(parser.parse().value, 'foo ')
def testFlowCollectionKeyBug(self):
tree = _syck.Map({
_syck.Seq([_syck.Scalar('foo')], inline=True):
_syck.Scalar('bar')
})
self._testTree(tree)
def testCollectionWithTagKeyBug(self):
tree = _syck.Map({
_syck.Seq([_syck.Scalar('foo')], tag='x-private:key'):
_syck.Scalar('bar')
})
self._testTree(tree)
def represent_type(self, object):
name = '%s.%s' % (object.__module__, object.__name__)
return _syck.Scalar('', tag="tag:python.yaml.org,2002:name:" + name)
def represent_module(self, object):
return _syck.Scalar('',
tag="tag:python.yaml.org,2002:module:" +
object.__name__)
def represent_datetime_datetime(self, object):
return _syck.Scalar(object.isoformat(),
tag="tag:yaml.org,2002:timestamp")
def represent_long(self, object):
return _syck.Scalar(repr(object), tag="tag:python.yaml.org,2002:long")
def represent_complex(self, object):
if object.real != 0.0:
value = '%s+%sj' % (repr(object.real), repr(object.imag))
else:
value = '%sj' % repr(object.imag)
return _syck.Scalar(value, tag="tag:python.yaml.org,2002:complex")
def testScalarWithAliasKeyBug(self):
node = _syck.Scalar('foo', tag='x-private:bug')
tree = _syck.Map({node: node})
self._testTree(tree)
def testEmptyCollectionKeyBug(self):
tree1 = _syck.Map({_syck.Map(): _syck.Scalar('foo')})
self._testTree(tree1)
tree2 = _syck.Map({_syck.Seq(): _syck.Scalar('foo')})
self._testTree(tree2)
def represent_NoneType(self, object):
return _syck.Scalar('~', tag="tag:yaml.org,2002:null")
def represent_bool(self, object):
return _syck.Scalar(repr(object), tag="tag:yaml.org,2002:bool")
def represent_int(self, object):
return _syck.Scalar(repr(object), tag="tag:yaml.org,2002:int")
import unittest
import _syck
import StringIO, gc
EXAMPLE = _syck.Seq([
_syck.Scalar('Mark McGwire'),
_syck.Scalar('Sammy Sosa'),
_syck.Scalar('Ken Griffey'),
])
COMPLEX_EXAMPLE = _syck.Map({
_syck.Scalar('scalars'):
_syck.Seq([
_syck.Scalar(),
_syck.Scalar('on'),
_syck.Scalar('12345', tag="tag:yaml.org,2002:int"),
# Syck bug with trailing spaces.
# _syck.Scalar('long '*100, width=20, indent=5),
_syck.Scalar('long long long long long\n' * 100, width=20, indent=5),
_syck.Scalar('"1quote"', style='1quote'),
_syck.Scalar("'2quote'", style='2quote'),
_syck.Scalar("folding\n" * 10, style='fold'),
_syck.Scalar("literal\n" * 10, style='literal'),
_syck.Scalar("plain text", style='plain'),
]),
_syck.Scalar('sequences'):
_syck.Seq([
_syck.Seq([
_syck.Seq(
