Index: /pyyaml-legacy/tags/PyYaml_0.32/profileYaml.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/profileYaml.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/profileYaml.py (revision 75) @@ -0,0 +1,23 @@ +import profile +import pstats +import yaml +import glob + +def loadAllFiles(): + testFiles = glob.glob('TestingSuite/*.yml') + for file in testFiles: + docs = yaml.loadFile(file) + for doc in docs: + exercise(doc) + +def exercise(doc): + if 'python' in doc: + if 'yaml' in doc: + for subDoc in yaml.load(doc['yaml']): + pass +print dir(profile) +profile.run('loadAllFiles()', 'profileResults') + +p = pstats.Stats('profileResults') +file = open("profile.out", "w") +p.sort_stats('time').print_stats(25) Index: /pyyaml-legacy/tags/PyYaml_0.32/here.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/here.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/here.py (revision 75) @@ -0,0 +1,14 @@ +import re +from string import split, join + +def flushLeft(s): + lines = split(s,'\n') + lastLine = lines.pop() + if re.match(r"\S", lastLine): + raise "bad last line" + indent = len(lastLine) + ret = [] + for line in lines[1:]: + ret.append(line[indent:] + '\n') + return join(ret,'') + Index: /pyyaml-legacy/tags/PyYaml_0.32/demo.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/demo.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/demo.py (revision 75) @@ -0,0 +1,92 @@ +import yaml, string + +####### RUNNING YAML AGAINST THE README AND CHANGELOG + +readme = yaml.loadFile("README") +print "README" +for item in readme.next(): + print item +print "\n\nCONTRIBUTORS" +for person in readme.next()['contributors']: + print "===%s===" % person['who'] + print person['why?'] + print +print "\n\n" +print "CHANGELOG:\n" +print list(yaml.loadFile("CHANGELOG")) +print "\n\n" + +######## USING YAML INSIDE YOUR PROGRAM + +testData = \ +""" +program: PyYaml +author: Steve Howell +--- +shopping list: + - apple + - banana +todo: + - eat more fruit: + - especially bananas! + - good for you + - write a better demo +""" + +print "YAML INSIDE YOUR PROGRAM" +for x in yaml.load(testData): + print repr(x) +print "\n\n" + + +######### YPATH STUFF + +try: + print "YPATH EXPERIMENTATION" + data = yaml.load(testData) + print yaml.ypath("/author",data.next()).next() + print yaml.dump(yaml.ypath("/todo/0",data.next()).next()) +except NotImplementedError: + print "Experimental YPATH requires Python 2.2" + +######### YAML DUMPER + +class Person: + def __init__(self, fname, lname, salary, children): + self.fname = fname + self.lname = lname + self.salary = salary + self.children = children + # private variables + self._fullname = fname + ' ' + lname + if salary: + self._sal_per_month = salary / 12.0 + self._num_children = len(children) + def to_yaml(self): + return ({ + 'first name': self.fname, + 'last name': self.lname, + 'salary': self.salary + }, '!!Person') + +mrBarson = Person('Foo', 'Barson', 20, ['ex', 'theomatic']) +mrDoe = Person('John', 'Doe', None, []) +print yaml.dump([mrBarson, mrDoe]) + +print "\n\nANOTHER WAY TO STDOUT:\n" +import sys +yaml.dumpToFile(sys.stdout, [mrBarson, mrDoe]) + +print "\n\nDUMP MULTIPLE DOCS TO A FILE:\n" +file = open('DEMO_OUTPUT.TXT', 'w') +yaml.dumpToFile(file, + {'source': "Demo output from demo.py"}, + [ + 'apple', + 'banana', + ], + 'Third document' +) +file.close() + + Index: /pyyaml-legacy/tags/PyYaml_0.32/TestYpath.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TestYpath.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/TestYpath.py (revision 75) @@ -0,0 +1,20 @@ +import yaml +from test import assertEquals + +try: + for test in yaml.loadFile("./TestingSuite/ypath.yml"): + if not test.has_key('ignore'): + expr = test['ypath'] + pth = yaml.ypath(expr,cntx=1) + lst = [] + for x in pth.apply(test['data']): + lst.append(str(x)) + exp = test['expected'] + if test.has_key('unordered'): + lst.sort() + exp.sort() + assertEquals(lst,exp,expr + " => " + str(pth)) + + print "Experimental YPATH OK" +except NotImplementedError: + print "Experimental YPATH requires Python 2.2" Index: /pyyaml-legacy/tags/PyYaml_0.32/Makefile =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/Makefile (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/Makefile (revision 75) @@ -0,0 +1,23 @@ +test: + @for n in YamlTest TestYpath TestClasses TestFileNamesInErrors; do \ + echo $$n.py; \ + python2.1 $$n.py; \ + python2.2 $$n.py; done + python TestPluggableDictionary.py + +clean: + rm -f *.pyc + rm -f yaml/*.pyc + rm -rf build + rm -f DEMO*.TXT + rm -f profileResults + +profile: + python profileYaml.py > profile.out + +install: + python setup.py install + +build: + python setup.py build + Index: /pyyaml-legacy/tags/PyYaml_0.32/TESTING =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TESTING (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/TESTING (revision 75) @@ -0,0 +1,12 @@ +--- > +As of July 2002, PyYaml shares its YAML-based testing suite with +other YAML implementations, starting with YamlForRuby. Many +thanks to Why The Lucky Stuff, the author of YamlForRuby, for +setting this up. + +When you check code out of Perforce, please set up your client +to check out TestingSuite as a subfolder of PyYaml. + +Thanks, + +Steve Index: /pyyaml-legacy/tags/PyYaml_0.32/TestYamlBasics.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TestYamlBasics.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/TestYamlBasics.py (revision 75) @@ -0,0 +1,163 @@ +import YamlTest +from here import * +from test import assertEquals +from yaml.load import l +from yaml.dump import d + +class Test(YamlTest.YamlTest): + def setUp(self): + # print '>>>>>>>>>>>>>>>' + pass + + def testNoLineFeed(self): + from yaml.stream import noLineFeed + assertEquals("foo", noLineFeed("foo\n")) + assertEquals("bar", noLineFeed("bar\n")) + assertEquals("bar", noLineFeed("bar\r\n")) + assertEquals("", noLineFeed("\r\n")) + + def XXXtest9(self): + # XXX - not sure how this gets handled now + self.verify( + """ + - foo: 1 + bar: 2 + """, + [ {'foo': 1, ' bar': 2}]) + + def testOutlineSnippet(self): + self.verify( + """ + - YAML ToDo: + - y2outline + - support generic transfers + - work on YAML.py: + - work on Store + """, + [ {'YAML ToDo': [ + 'y2outline', + 'support generic transfers', + { 'work on YAML.py': ['work on Store'] } + ] + } + ]) + + def testQuotedString(self): + self.verify( + """ + --- + foo: 'key: value' + """, + {'foo': "key: value"} + ) + + def testFloatRedHerring(self): + self.verify( + """ + --- + - 'Version: 0.18.0' + """, + [ 'Version: 0.18.0' ] + ) + + def testDashInQuotes(self): + self.verify( + """ + --- + title: 'Perspective Broker - twisted.spread' + """, + {'title': 'Perspective Broker - twisted.spread'} + ) + + def testQuestionMarks(self): + self.verify( + """ + --- + hello: you there? + foo: + - ok? + - sure? + bar: + - for here or to go? + - more sugar? + """, + { + 'hello': 'you there?', + 'foo': ['ok?', 'sure?'], + 'bar': ['for here or to go?', 'more sugar?'] + } + ) + + def testDoubleQuoteEscapedKeys(self): + self.verify( + """ + --- + "I'm escaped!": simple + """, + { "I'm escaped!": 'simple' } + ) + + def testColonsInsideEscapedKeys(self): + self.verify( + """ + --- + 'aaa: bbbb': simple + """, + { 'aaa: bbbb': 'simple' } + ) + + def testControlChars(self): + self.verify( + r""" + control: "\b1998\t1999\t2000\n" + """, + { 'control': "\b1998\t1999\t2000\n" } + ) + + def testUnicode(self): + if YamlTest.hasUnicode: + self.verify( + r''' + unicode: "Sosa did fine.\u263A" + ''', + { 'unicode': u"Sosa did fine.\u263A"} + ) + + def testMultiLineScalar(self): + self.verify( + """ + plain: This unquoted + scalar spans + many lines. + """, + { 'plain': 'This unquoted scalar spans many lines.' } + ) + + def testDomainType(self): + class MyYamlConfig: + def resolveType(self, data, url): + if url == '!!name': + return 'Foo ' + data + elif url == '!!coords': + return { 'x': data[0], 'y': data[1]} + else: + raise 'url not passed in correctly' + data = YamlTest.loadFlushLeft(""" + name: !!name Barson + coords: !!coords + - 10 + - 20 + """, + MyYamlConfig()) + self.assertEquals(data[0], + {'name': 'Foo Barson', + 'coords': { 'x': 10, 'y': 20 } } + ) + + def testQuickInterfaces(self): + assertEquals(l("--- foo"), "foo") + assertEquals(d({'foo': 'bar'}), "---\nfoo: bar\n") + +if __name__ == '__main__': + import unittest + unittest.main() Index: /pyyaml-legacy/tags/PyYaml_0.32/TestPluggableDictionary.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TestPluggableDictionary.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/TestPluggableDictionary.py (revision 75) @@ -0,0 +1,25 @@ +import yaml +from yaml.ordered_dict import OrderedDict +from yaml.redump import redump +from test import assertEquals + +stream = """\ +--- +zzz: 0 +yyy: 1 +xxx: 2 +alpha: 3 +--- +- + foo: 1 + bar: 2 +- + z: 1 + y: 2 +""" + +my_dict = yaml.loadOrdered(stream).next() +assertEquals(my_dict.keys(), ['zzz', 'yyy', 'xxx', 'alpha']) + +assertEquals(redump(stream), stream) + Index: /pyyaml-legacy/tags/PyYaml_0.32/TestPullParser.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TestPullParser.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/TestPullParser.py (revision 75) @@ -0,0 +1,116 @@ +import YamlTest +from here import flushLeft +from test import assertEquals +from TestPushDumper import mockEvents +from yaml import load + +""" +This is experimental code. I am moving toward a rewrite of the YAML +parser so that it uses a pull interface. I am using a mock object +to emulate the parser, so that I can experiment with the interface a bit, +and also to sketch out some ideas for schema-driven parsing. +""" + +class MockParser: + def __init__(self, events): + self.events = events + self.index = 0 + + def __getattr__(self, name): + (nextName, value) = self.events[self.index] + if name != nextName: + raise "Improper mocking for event %d (%s vs. %s)" % \ + (self.index, name, nextName) + self.index += 1 + return lambda: value + +class Loader: + def __init__(self, parser): + self.parser = parser + + def load(self, data): + typ = self.parser.getType() + return self._load(typ) + + def _load(self, typ): + if typ == 'seq': + return self._loadSeq() + elif typ == 'map': + return self._loadMap() + else: + return self._loadScalar() + + def _loadSeq(self): + results = [] + def itemFunc(self, results, typ): + results.append(self._load(typ)) + return self.iterateItems(results, itemFunc) + + def _loadMap(self): + results = {} + def itemFunc(self, results, typ): + key = self._load(typ) + valTyp = self.parser.getType() + value = self._load(typ) + results[key] = value + return self.iterateItems(results, itemFunc) + + def iterateItems(self, results, func): + while 1: + typ = self.parser.getType() + if typ is None: + return results + else: + func(self, results, typ) + + def _loadScalar(self): + return self.parser.getScalar() + +def mockParser(data): + events = mockEvents(data) + return MockParser(events) + +def mockLoad(data): + loader = Loader(mockParser(data)) + return loader.load(None) # None for data cause events are all mocked + +def testRoundTrip(data): + obj = mockLoad(data) + assertEquals(obj, data) + +class Test(YamlTest.YamlTest): + + def testMock(self): + parser = MockParser( [ + ('getScalar', 'foo'), + ('getArray', [1,2,3]), + ('getScalar', None), + ]) + assertEquals(parser.getScalar(), 'foo') + assertEquals(parser.getArray(), [1,2,3]) + assertEquals(parser.getScalar(), None) + + def testList(self): + testRoundTrip([1,2,3]) + + def testDict(self): + testRoundTrip({'foo': 'bar'}) + + def testListDict(self): + testRoundTrip( [ [1,2,3], {'foo': 'bar'} ] ) + + def testComplexStructure(self): + data = load(flushLeft( + """ + list: + - {foo: bar} + - [1, 2, 3] + dict: + name: steve + games: [hoops, pool] + """)) + testRoundTrip(data) + +if __name__ == '__main__': + import unittest + unittest.main() Index: /pyyaml-legacy/tags/PyYaml_0.32/TestClasses.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TestClasses.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/TestClasses.py (revision 75) @@ -0,0 +1,140 @@ +import yaml +from test import assertEquals +from here import flushLeft +from math import sqrt + +""" +DUMPING OBJECTS: > + YAML has several ways of persisting objects. One view of an + object is that it's nothing more than it's dictionary. By + default, YAML emits self.__dict__ from objects. +""" + +class SimpleObject: + def __init__(self): + self.x = 100 + self.y = 20 + + def xyz(self): + return self.x + self.y + self.z + +def testDumpingDictionary(): + obj = SimpleObject() + obj.z = 3 + output = yaml.dump(obj) + expected = simpleObjectYaml() + assertEquals(output, expected) + +def simpleObjectYaml(): + return flushLeft(""" + --- !!__main__.SimpleObject + x: 100 + y: 20 + z: 3 + """) + + +testDumpingDictionary() + +""" +LOADING OBJECTS: > + Of course, we would expect to be able to load that + YAML right back into Python, and we can. You get + back an object of the intended class, with all of + the normal methods. Be aware, though, that if your + class creates methods on the fly, or if it does + other trickery, then you might get unexpected results. +""" + +def testLoadingDictionary(): + obj = yaml.load(simpleObjectYaml()).next() + assertEquals(obj.xyz(), 123) + +testLoadingDictionary() + +""" +CUSTOM DUMPING: > + Some times you want more control over how you dump + objects in YAML. You might not want to dump all + members of the object, for example. Also, you may + not want to export the module name. +""" + +class Triangle: + def __init__(self,x,y): + self.x = x + self.y = y + self._hypotneuse = sqrt(x*x + y*y) + + def to_yaml(self): + # hide the hypotneuse attribute, it's private; + # also use inches instead of feet + view = { + 'x_inches': self.x * 12, + 'y_inches': self.y * 12 + } + return (view, '!!triangle_in_inches') + +def testDumpTriangle(): + triangle = Triangle(3,4) + assertEquals(yaml.dump(triangle), triangleYaml()) + +def triangleYaml(): + return flushLeft(""" + --- !!triangle_in_inches + x_inches: 36 + y_inches: 48 + """) + +testDumpTriangle() + +""" +CUSTOM LOADING: > + You have control over the YAML load process too. Normally + YAML resolves private types for you automatically, but you + can override its behavior. +""" + +class MyResolver: + def resolveType(self, data, typestring): + if typestring == '!!triangle_in_inches': + x = data['x_inches'] / 12 + y = data['y_inches'] / 12 + return Triangle(x,y) + else: + raise 'Private type %s not supported' % typestring + +def testCustomLoad(): + obj = yaml.load(triangleYaml(),MyResolver()).next() + assertEquals(obj._hypotneuse, 5.0) + +testCustomLoad() + +""" +USING FROM_YAML(): > + Another way to customize the YAML loading process is to + supply a from_yaml() method. For example, you might want + the loading of an object to have some kind of a side effect. + Or, you may need to calculate some value that is not part of + the attribute. +""" + +class TestConfig: + lastTester = None + def from_yaml(self, args): + self.tester = args['tester'] + self.hitcount = args['hitcount'] + 1 + TestConfig.lastTester = self.tester + return self + +def testFromYaml(): + yamlData = flushLeft(""" + --- !!__main__.TestConfig + tester: showell + hitcount: 42 + """) + obj = yaml.load(yamlData).next() + assertEquals(obj.hitcount, 43) + assertEquals(TestConfig.lastTester, 'showell') + +testFromYaml() Index: /pyyaml-legacy/tags/PyYaml_0.32/__init__.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/__init__.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/__init__.py (revision 75) @@ -0,0 +1,1 @@ +# Index: /pyyaml-legacy/tags/PyYaml_0.32/setup.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/setup.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/setup.py (revision 75) @@ -0,0 +1,4 @@ +from distutils.core import setup +setup (name = "yaml", + version = "0.25", + packages = ["yaml"]) Index: /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/foldedScalar.yml =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/foldedScalar.yml (revision 71) +++ /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/foldedScalar.yml (revision 71) @@ -0,0 +1,216 @@ +--- #YAML:1.0 +test: Single ending newline +brief: > + A pipe character, followed by an indented + block of text is treated as a literal + block, in which newlines are preserved + throughout the block, including the final + newline. +yaml: | + --- + this: | + Foo + Bar + +ruby: | + { 'this' => "Foo\nBar\n" } +python: | + [ + { 'this': "Foo\nBar\n" } + ] +--- +test: The '+' indicator +brief: > + The '+' indicator says to keep newlines at the end of text + blocks. +yaml: | + normal: | + extra new lines not kept + + preserving: |+ + extra new lines are kept + + + dummy: value +ruby: | + { + 'normal' => "extra new lines not kept\n", + 'preserving' => "extra new lines are kept\n\n\n", + 'dummy' => 'value' + } +python: | + [ { + 'normal': "extra new lines not kept\n", + 'preserving': "extra new lines are kept\n\n\n", + 'dummy': 'value' + } ] +--- +test: Three trailing newlines in literals +brief: > + To give you more control over how space + is preserved in text blocks, YAML has + the keep '+' and chomp '-' indicators. + The keep indicator will preserve all + ending newlines, while the chomp indicator + will strip all ending newlines. +yaml: | + clipped: | + This has one newline. + + + + same as "clipped" above: "This has one newline.\n" + + stripped: |- + This has no newline. + + + + same as "stripped" above: "This has no newline." + + kept: |+ + This has four newlines. + + + + same as "kept" above: "This has four newlines.\n\n\n\n" +ruby: | + { + 'clipped' => "This has one newline.\n", + 'same as "clipped" above' => "This has one newline.\n", + 'stripped' => 'This has no newline.', + 'same as "stripped" above' => 'This has no newline.', + 'kept' => "This has four newlines.\n\n\n\n", + 'same as "kept" above' => "This has four newlines.\n\n\n\n" + } +not_yet_in_python: | + [ + { + 'clipped': "This has one newline.\n", + 'same as "clipped" above': "This has one newline.\n", + 'stripped': 'This has no newline.', + 'same as "stripped" above': 'This has no newline.', + 'kept': "This has four newlines.\n\n\n\n", + 'same as "kept" above': "This has four newlines.\n\n\n\n" + } + ] + +--- +test: Extra trailing newlines with spaces +brief: > + Normally, only a single newline is kept + from the end of a literal block, unless the + keep '+' character is used in combination + with the pipe. The following example + will preserve all ending whitespace + since the last line of both literal blocks + contains spaces which extend past the indentation + level. +yaml: | + --- + this: | + Foo + + + kept: |+ + Foo + + +ruby: | + { 'this' => "Foo\n\n \n", + 'kept' => "Foo\n\n \n" } + +--- +test: Folded Block in a Sequence +brief: > + A greater-then character, followed by an indented + block of text is treated as a folded block, in + which lines of text separated by a single newline + are concatenated as a single line. +yaml: | + --- + - apple + - banana + - > + can't you see + the beauty of yaml? + hmm + - dog +python: | + [ + [ + 'apple', + 'banana', + "can't you see the beauty of yaml? hmm\n", + 'dog' + ] + ] +ruby: | + [ + 'apple', + 'banana', + "can't you see the beauty of yaml? hmm\n", + 'dog' + ] +--- +test: Folded Block as a Mapping Value +brief: > + Both literal and folded blocks can be + used in collections, as values in a + sequence or a mapping. +yaml: | + --- + quote: > + Mark McGwire's + year was crippled + by a knee injury. + source: espn +python: | + [ + { + 'quote': "Mark McGwire's year was crippled by a knee injury.\n", + 'source': 'espn' + } + ] +ruby: | + { + 'quote' => "Mark McGwire's year was crippled by a knee injury.\n", + 'source' => 'espn' + } + +--- +test: Three trailing newlines in folded blocks +brief: > + The keep and chomp indicators can also + be applied to folded blocks. +yaml: | + clipped: > + This has one newline. + + + + same as "clipped" above: "This has one newline.\n" + + stripped: >- + This has no newline. + + + + same as "stripped" above: "This has no newline." + + kept: >+ + This has four newlines. + + + + same as "kept" above: "This has four newlines.\n\n\n\n" +ruby: | + { + 'clipped' => "This has one newline.\n", + 'same as "clipped" above' => "This has one newline.\n", + 'stripped' => 'This has no newline.', + 'same as "stripped" above' => 'This has no newline.', + 'kept' => "This has four newlines.\n\n\n\n", + 'same as "kept" above' => "This has four newlines.\n\n\n\n" + } + Index: /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/types.yml =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/types.yml (revision 71) +++ /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/types.yml (revision 71) @@ -0,0 +1,239 @@ +--- #YAML:1.0 +test: Strings +brief: > + Any group of characters beginning with an + alphabetic or numeric character is a string, + unless it belongs to one of the groups below + (such as an Integer or Time). +yaml: | + String +ruby: | + 'String' + +--- +test: String characters +brief: > + A string can contain any alphabetic or + numeric character, along with many + punctuation characters, including the + period, dash, space, quotes, exclamation, and + question mark. +yaml: | + - What's Yaml? + - It's for writing data structures in plain text. + - And? + - And what? That's not good enough for you? + - No, I mean, "And what about Yaml?" + - Oh, oh yeah. Uh.. Yaml for Ruby. +ruby: | + [ + "What's Yaml?", + "It's for writing data structures in plain text.", + "And?", + "And what? That's not good enough for you?", + "No, I mean, \"And what about Yaml?\"", + "Oh, oh yeah. Uh.. Yaml for Ruby." + ] + +--- +test: Indicators in Strings +brief: > + Be careful using indicators in strings. In particular, + the comma, colon, and pound sign must be used carefully. +yaml: | + the colon followed by space is an indicator: but is a string:right here + same for the pound sign: here we have it#in a string + the comma can, honestly, be used in most cases: [ but not in, inline collections ] +ruby: | + { + 'the colon followed by space is an indicator' => 'but is a string:right here', + 'same for the pound sign' => 'here we have it#in a string', + 'the comma can, honestly, be used in most cases' => [ 'but not in', 'inline collections' ] + } + +--- +test: Forcing Strings +brief: > + Any YAML type can be forced into a string using the + explicit !str method. +yaml: | + date string: !str 2001-08-01 + number string: !str 192 +ruby: | + { + 'date string' => '2001-08-01', + 'number string' => '192' + } + +--- +test: Single-quoted Strings +brief: > + You can also enclose your strings within single quotes, + which allows use of slashes, colons, and other indicators + freely. Inside single quotes, you can represent a single + quote in your string by using two single quotes next to + each other. +yaml: | + all my favorite symbols: '#:!/%.)' + a few i hate: '&(*' + why do i hate them?: 'it''s very hard to explain' +ruby: | + { + 'all my favorite symbols' => '#:!/%.)', + 'a few i hate' => '&(*', + 'why do i hate them?' => 'it\'s very hard to explain' + } + +--- +test: Double-quoted Strings +brief: > + Enclosing strings in double quotes allows you + to use escapings to represent ASCII and + Unicode characters. +yaml: | + i know where i want my line breaks: "one here\nand another here\n" +ruby: | + { + 'i know where i want my line breaks' => "one here\nand another here\n" + } + +--- +test: Multi-line Quoted Strings +brief: > + Both single- and double-quoted strings may be + carried on to new lines in your YAML document. + They must be indented a step and indentation + is interpreted as a single space. +yaml: | + i want a long string: "so i'm going to + let it go on and on to other lines + until i end it with a quote." +ruby: | + { 'i want a long string' => "so i'm going to " + + "let it go on and on to other lines " + + "until i end it with a quote." + } + +--- +test: Null +brief: > + You can use the tilde '~' character for a null value. +yaml: | + name: Mr. Show + hosted by: Bob and David + date of next season: ~ +ruby: | + { + 'name' => 'Mr. Show', + 'hosted by' => 'Bob and David', + 'date of next season' => nil + } + +--- +test: Boolean +brief: > + You can use the plus sign '+' and the negative + sign '-' for True and False. +yaml: | + Is Gus a Liar?: + + Do I rely on Gus for Sustenance?: - +ruby: | + { + 'Is Gus a Liar?' => true, + 'Do I rely on Gus for Sustenance?' => false + } + +--- +test: Integers +brief: > + An integer is a series of numbers, optionally + starting with a positive or negative sign. Integers + may also contain commas for readability. +yaml: | + zero: 0 + simple: 12 + one-thousand: 1,000 + negative one-thousand: -1,000 +ruby: | + { + 'zero' => 0, + 'simple' => 12, + 'one-thousand' => 1000, + 'negative one-thousand' => -1000 + } +python: | + [ + { + 'zero': 0, + 'simple': 12, + 'one-thousand': 1000, + 'negative one-thousand': -1000, + } + ] +--- +test: Integers as Map Keys +brief: > + An integer can be used a dictionary key. +yaml: | + 1: one + 2: two + 3: three +python: | + [ + { + 1: 'one', + 2: 'two', + 3: 'three', + } + ] +ruby: | + { + 1 => 'one', + 2 => 'two', + 3 => 'three' + } + +--- +test: Floats +brief: > + Floats are represented by numbers with decimals, + allowing for scientific notation, as well as + positive and negative infinity and "not a number." +yaml: | + a simple float: 2.00 + larger float: 1,000.09 + scientific notation: 1.00009e+3 +ruby: | + { + 'a simple float' => 2.0, + 'larger float' => 1000.09, + 'scientific notation' => 1000.09 + } + +--- +test: Time +brief: > + You can represent timestamps by using + ISO8601 format, or a variation which + allows spaces between the date, time and + time zone. +yaml: | + iso8601: 2001-12-14t21:59:43.10-05:00 + space seperated: 2001-12-14 21:59:43.10 -05:00 +ruby: | + { + 'iso8601' => YAML::mktime( 2001, 12, 14, 21, 59, 43, .10, "-05:00" ), + 'space seperated' => YAML::mktime( 2001, 12, 14, 21, 59, 43, .10, "-05:00" ) + } + +--- +test: Date +brief: > + A date can be represented by its year, + month and day in ISO8601 order. +yaml: | + 1976-07-31 +ruby: | + Date.new( 1976, 7, 31 ) + + Index: /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/ypath.yml =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/ypath.yml (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/ypath.yml (revision 75) @@ -0,0 +1,221 @@ +data: + apple: red +ypath: / +expected: + - / +--- +data: + apple: red +ypath: . +expected: + - / +--- +data: + apple: red +ypath: /* +expected: + - /apple +--- +data: + apple: red + lemon: yellow +ypath: /* +expected: + - /apple + - /lemon +unordered: 1 +--- +data: + fruit: + banana: yellow + vegetable: + carrot: orange +ypath: //. +expected: + - / + - /fruit + - /fruit/banana + - /vegetable + - /vegetable/carrot +unordered: 1 +--- +data: + one: + two: xxx +ypath: //two/.. +expected: + - /one +--- +data: + apple: red +ypath: /apple +expected: + - /apple +----- +data: + apple: red + lemon: yellow +ypath: /"lemon" +expected: + - /lemon +----- +data: + apple: red + lemon: yellow +ypath: /'lemon' +expected: + - /lemon +----- +data: + apple: red + lemon: yellow +ypath: /lemon +expected: + - /lemon +---- +data: + - apple + - lemon +ypath: /0 +expected: + - /0 +--- +data: + apple: red + lemon: yellow +ypath: /orange +expected: [] +---- +data: + apple: red +ypath: ./. +expected: + - / +--- +data: + fruit: + banana: yellow + vegetable: + carrot: orange +ypath: /fruit/banana +expected: + - /fruit/banana +--- +data: + fruit: + banana: yellow + vegetable: + carrot: orange +ypath: fruit/banana +expected: + - /fruit/banana +--- +data: + names: + - Steve Howell + - Clark Evans +ypath: /names/0 +expected: + - /names/0 +--- +data: + names: + - first: Clark + last: Evans + - first: Steve + last: Howell +ypath: /names/1/first +expected: + - /names/1/first +---- +data: + names: + - first: Clark + last: Evans + - first: Steve + last: Howell +ypath: /names/*/first +expected: + - /names/0/first + - /names/1/first +--- +data: + names: + python-heads: + - first: Clark + last: Evans + - first: Steve + last: Howell + perl-heads: + - first: Brian + last: Ingerson +ypath: names//first +expected: + - /names/python-heads/0/first + - /names/python-heads/1/first + - /names/perl-heads/0/first +--- +data: + task: + - name: wake + foo: bar + - name: eat + task: + - name: veggies + - name: meats + - name: sleep +ypath: //task +expected: + - /task + - /task/1/task +--- +data: + - one: + name: xxx + - two: + name: yyy + - three: + name: zzz +ypath: /*/one/name|//three/name +expected: + - /0/one/name + - /2/three/name +--- +data: + apple: red +ypath: .|/apple|apple|/|. +expected: + - / + - /apple +--- +data: + - one: + name: xxx + - two: + name: yyy + - three: + name: zzz +ypath: /*/(one|three)/name +expected: + - /0/one/name + - /2/three/name +--- +data: + - one: xxx + - two: yyy + - one: zzz +ypath: /*[one] +expected: + - /0 + - /2 +--- +data: + - food: Hamburger + calories: 900 + - food: Fries + calories: 650 + - food: Soft Drink + calories: 350 +ypath: //food[.=Fries] +expected: + - /1/food Index: /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/nullsAndEmpties.yml =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/nullsAndEmpties.yml (revision 71) +++ /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/nullsAndEmpties.yml (revision 71) @@ -0,0 +1,66 @@ +--- #YAML:1.0 +test: Empty Sequence +brief: > + You can represent the empty sequence + with an empty inline sequence. +yaml: | + empty: [] +python: | + [ + { 'empty': [] } + ] +ruby: | + { 'empty' => [] } + +--- +test: Empty Mapping +brief: > + You can represent the empty mapping + with an empty inline mapping. +yaml: | + empty: {} +python: | + [ + { 'empty': {} } + ] +ruby: | + { 'empty' => {} } + +--- +test: Empty Sequence as Entire Document +yaml: | + --- [] +python: | + [ [] ] +ruby: | + [] + +--- +test: Empty Mapping as Entire Document +yaml: | + --- {} +python: | + [ {} ] +ruby: | + {} + +--- +test: Null as Document +yaml: | + --- ~ +python: | + [ None ] +ruby: | + nil + +--- +test: Empty String +brief: > + You can represent an empty string + with a pair of quotes. +yaml: | + --- '' +python: | + [ '' ] +ruby: | + '' Index: /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/alias.yml =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/alias.yml (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/alias.yml (revision 75) @@ -0,0 +1,61 @@ +--- #YAML:1.0 +test: Simple Alias Example +brief: > + If you need to refer to the same item of data twice, + you can give that item an alias. The alias is a plain + string, starting with an ampersand. The item may then + be referred to by the alias throughout your document + by using an asterisk before the name of the alias. + This is called an anchor. +yaml: | + - &showell Steve + - Clark + - Brian + - Oren + - *showell +python: | + [ + [ 'Steve', 'Clark', 'Brian', 'Oren', 'Steve'] + ] +ruby-setup: | + showell = 'Steve' +ruby: | + [ showell, 'Clark', 'Brian', 'Oren', showell ] + +--- +test: Alias of a Mapping +brief: > + An alias can be used on any item of data, including + sequences, mappings, and other complex data types. +yaml: | + - &hello + Meat: pork + Starch: potato + - banana + - *hello +python: | + [ + [ + {'Meat': 'pork', 'Starch': 'potato'}, + 'banana', + {'Meat': 'pork', 'Starch': 'potato'}, + ] + ] +ruby-setup: | + hello = { 'Meat' => 'pork', 'Starch' => 'potato' } +ruby: | + [ + hello, + 'banana', + hello + ] +--- +test: Liberal Asterisk Handling +brief: > + We need to allow strings to begin with asterisks. +yaml: | + - * Bulleted item +python: | + [ + [ '* Bulleted item' ] + ] Index: /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/error.yml =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/error.yml (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/error.yml (revision 75) @@ -0,0 +1,67 @@ +--- #YAML:1.0 +test: Missing value for hash item +brief: > + Third item in this hash doesn't have a value +yaml: | + okay: value + also okay: ~ + causes error because no value specified + last key: value okay here too +error: + python: | + bad key for map: + near line 3: + causes error because no value specified +--- +test: Not indenting enough +brief: > + There was a bug in PyYaml where it was off by one + in the indentation check. It was allowing the YAML + below. +yaml: | + foo: + firstline: 1 + secondline: 2 +error: + python: | + Inadequate indentation: + near line 2: + firstline: 1 +--- +test: Duplicate keys +brief: > + YAML should complain when you have duplicate + dictionary keys, rather than silently overwriting them. +yaml: | + foo: 1 + foo: 2 +error: + python: | + Duplicate key foo: + near line 2: + foo: 2 +--- +test: Duplicate keys w/complex children +brief: > + same thing for complex keys +yaml: | + foo: + yo: 1 + foo: + bar: 1 +error: + python: | + Duplicate key foo: + near line 3: + foo: +--- +test: Complain about trailing spaces +brief: > + root of all evil +yaml: | + foo: bar +error: + python: | + Trailing spaces not allowed without quotes.: + near line 1: + foo: bar Index: /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/inlineCollection.yml =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/inlineCollection.yml (revision 71) +++ /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/inlineCollection.yml (revision 71) @@ -0,0 +1,74 @@ +--- +test: Simple Inline Array +brief: > + Sequences can be contained on a + single line, using the inline syntax. + Separate each entry with commas and + enclose in square brackets. +yaml: | + --- + seq: [ a, b, c ] +python: | + [ + { 'seq': [ 'a', 'b', 'c' ] } + ] +ruby: | + { 'seq' => [ 'a', 'b', 'c' ] } + +--- +test: Simple Inline Hash +brief: > + Mapping can also be contained on + a single line, using the inline + syntax. Each key-value pair is + separated by a colon, with a comma + between each entry in the mapping. + Enclose with curly braces. +yaml: | + --- + hash: { name: Steve, foo: bar } +python: | + [ + { 'hash': {'name': 'Steve', 'foo': 'bar'} } + ] +ruby: | + { 'hash' => { 'name' => 'Steve', 'foo' => 'bar' } } + +--- +test: Multi-line Inline Collections +brief: > + Both inline sequences and inline mappings + can span multiple lines, provided that you + indent the additional lines. +yaml: | + languages: [ Ruby, + Perl, + Python ] + websites: { YAML: yaml.org, + Ruby: ruby-lang.org, + Python: python.org, + Perl: use.perl.org } +ruby: | + { 'languages' => [ 'Ruby', 'Perl', 'Python' ], + 'websites' => { + 'YAML' => 'yaml.org', + 'Ruby' => 'ruby-lang.org', + 'Python' => 'python.org', + 'Perl' => 'use.perl.org' + } + } +--- +test: Commas in Values +brief: > + List items in collections are delimited by commas, but + there must be a space after each comma. This allows you + to add numbers without quoting. +yaml: | + attendances: [ 45,123, 70,000, 17,222 ] +python: | + [ + {'attendances': [ 45123, 70000, 17222 ]} + ] +ruby: | + { 'attendances' => [ 45123, 70000, 17222 ] } + Index: /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/spec.yml =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/spec.yml (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/spec.yml (revision 75) @@ -0,0 +1,1576 @@ +--- #YAML:1.0 +test: Sequence of scalars +spec: A1 +yaml: | + - Mark McGwire + - Sammy Sosa + - Ken Griffey +perl: | + [ 'Mark McGwire', 'Sammy Sosa', 'Ken Griffey' ] +python: | + [ ['Mark McGwire', 'Sammy Sosa', 'Ken Griffey'] ] +ruby: | + [ 'Mark McGwire', 'Sammy Sosa', 'Ken Griffey' ] + +--- +test: Mapping of scalars to scalars +spec: A2 +yaml: | + hr: 65 + avg: 0.278 + rbi: 147 +perl: | + { hr => 65, avg => 0.278, rbi => 147 } +python: | + [ {'hr': 65, 'avg': .278, 'rbi': 147} ] +ruby: | + { 'hr' => 65, 'avg' => 0.278, 'rbi' => 147 } + +--- +test: Mapping of scalars to sequences +spec: A3 +yaml: | + american: + - Boston Red Sox + - Detroit Tigers + - New York Yankees + - Texas Rangers + national: + - New York Mets + - Chicago Cubs + - Atlanta Braves + - Montreal Expos +perl: | + { american => + [ 'Boston Red Sox', 'Detroit Tigers', + 'New York Yankees', 'Texas Rangers' ], + national => + [ 'New York Mets', 'Chicago Cubs', + 'Atlanta Braves', 'Montreal Expos' ] + } +python: | + [ + { + 'american': + ['Boston Red Sox', 'Detroit Tigers', + 'New York Yankees', 'Texas Rangers'], + 'national': + ['New York Mets', 'Chicago Cubs', + 'Atlanta Braves', 'Montreal Expos'] + } + ] +ruby: | + { 'american' => + [ 'Boston Red Sox', 'Detroit Tigers', + 'New York Yankees', 'Texas Rangers' ], + 'national' => + [ 'New York Mets', 'Chicago Cubs', + 'Atlanta Braves', 'Montreal Expos' ] + } + +--- +test: Sequence of mappings +spec: A4 +yaml: | + - + name: Mark McGwire + hr: 65 + avg: 0.278 + rbi: 147 + - + name: Sammy Sosa + hr: 63 + avg: 0.288 + rbi: 141 +perl: | + [ + {name => 'Mark McGwire', hr => 65, avg => 0.278, rbi => 147}, + {name => 'Sammy Sosa', hr => 63, avg => 0.288, rbi => 141} + ] +python: | + [[ + { + 'name': 'Mark McGwire', + 'hr': 65, + 'avg': 0.278, + 'rbi': 147 + }, + { + 'name': 'Sammy Sosa', + 'hr': 63, + 'avg': 0.288, + 'rbi': 141 + } + ]] +ruby: | + [ + {'name' => 'Mark McGwire', 'hr' => 65, 'avg' => 0.278, 'rbi' => 147}, + {'name' => 'Sammy Sosa', 'hr' => 63, 'avg' => 0.288, 'rbi' => 141} + ] + +--- +test: Legacy A5 +spec: legacy_A5 +yaml: | + ? + - New York Yankees + - Atlanta Braves + : + - 2001-07-02 + - 2001-08-12 + - 2001-08-14 + ? + - Detroit Tigers + - Chicago Cubs + : + - 2001-07-23 +perl-busted: > + YAML.pm will be able to emulate this behavior soon. In this regard + it may be somewhat more correct than Python's native behaviour which + can only use tuples as mapping keys. PyYAML will also need to figure + out some clever way to roundtrip structured keys. Not sure how full + featured Ruby is in this regard. +python: | + [ + { + ('New York Yankees', 'Atlanta Braves'): + [yaml.timestamp('2001-07-02'), + yaml.timestamp('2001-08-12'), + yaml.timestamp('2001-08-14')], + ('Detroit Tigers', 'Chicago Cubs'): + [yaml.timestamp('2001-07-23')] + } + ] +ruby: | + { + [ 'New York Yankees', 'Atlanta Braves' ] => + [ Date.new( 2001, 7, 2 ), Date.new( 2001, 8, 12 ), Date.new( 2001, 8, 14 ) ], + [ 'Detroit Tigers', 'Chicago Cubs' ] => + [ Date.new( 2001, 7, 23 ) ] + } + + +--- +test: Sequence of sequences +spec: A5 +yaml: | + - [ name , hr , avg ] + - [ Mark McGwire , 65 , 0.278 ] + - [ Sammy Sosa , 63 , 0.288 ] +perl: | + [ + [ 'name', 'hr', 'avg' ], + [ 'Mark McGwire', 65, 0.278 ], + [ 'Sammy Sosa', 63, 0.288 ], + ] +python: | + [[ + [ 'name', 'hr', 'avg' ], + [ 'Mark McGwire', 65, 0.278 ], + [ 'Sammy Sosa', 63, 0.288 ] + ]] +ruby: | + [ + [ 'name', 'hr', 'avg' ], + [ 'Mark McGwire', 65, 0.278 ], + [ 'Sammy Sosa', 63, 0.288 ] + ] + +--- +test: Mapping of mappings +spec: A6 +yaml: | + Mark McGwire: {hr: 65, avg: 0.278} + Sammy Sosa: {hr: 63, + avg: 0.288} +perl: | + { + 'Mark McGwire' => { 'hr' => 65, 'avg' => 0.278 }, + 'Sammy Sosa' => { 'hr' => 63, 'avg' => 0.288 }, + } +not_yet_in_python: | + [{ + 'Mark McGwire': + { 'hr': 65, 'avg': 0.278 }, + 'Sammy Sosa': + { 'hr': 63, 'avg': 0.288 } + }] +ruby: | + { + 'Mark McGwire' => + { 'hr' => 65, 'avg' => 0.278 }, + 'Sammy Sosa' => + { 'hr' => 63, 'avg' => 0.288 } + } + +--- +test: Two documents, one stream +spec: B1 +yaml: | + --- + name: Mark McGwire + hr: 65 + avg: 0.278 + --- + name: Sammy Sosa + hr: 63 + avg: 0.288 +python: | + [ + { 'name': 'Mark McGwire', 'hr': 65, 'avg': 0.278 }, + { 'name': 'Sammy Sosa', 'hr': 63, 'avg': 0.288 } + ] +ruby: | + y = Stream.new + y.add( { 'name' => 'Mark McGwire', 'hr' => 65, 'avg' => 0.278 } ) + y.add( { 'name' => 'Sammy Sosa', 'hr' => 63, 'avg' => 0.288 } ) +documents: 2 + +--- +test: Document with leading comment +spec: B2 +yaml: | + # Ranking of players by + # 1998 season home runs. + --- + - Mark McGwire + - Sammy Sosa + - Ken Griffey +python: | + [[ 'Mark McGwire', 'Sammy Sosa', 'Ken Griffey' ]] +ruby: | + [ 'Mark McGwire', 'Sammy Sosa', 'Ken Griffey' ] + +--- +test: Single document with two comments +spec: B3 +yaml: | + hr: # 1998 hr ranking + - Mark McGwire + - Sammy Sosa + rbi: + # 1998 rbi ranking + - Sammy Sosa + - Ken Griffey +python: | + [{ + 'hr': [ 'Mark McGwire', 'Sammy Sosa' ], + 'rbi': [ 'Sammy Sosa', 'Ken Griffey' ] + }] +ruby: | + { + 'hr' => [ 'Mark McGwire', 'Sammy Sosa' ], + 'rbi' => [ 'Sammy Sosa', 'Ken Griffey' ] + } + +--- +test: Node for Sammy Sosa appears twice in this document +spec: B4 +yaml: | + hr: + - Mark McGwire + # Following node labeled SS + - &SS Sammy Sosa + rbi: + - *SS # Subsequent occurance + - Ken Griffey +python: | + [{ + 'hr': [ 'Mark McGwire', 'Sammy Sosa' ], + 'rbi': [ 'Sammy Sosa', 'Ken Griffey' ] + }] +ruby: | + { + 'hr' => + [ 'Mark McGwire', 'Sammy Sosa' ], + 'rbi' => + [ 'Sammy Sosa', 'Ken Griffey' ] + } + +--- +test: Mapping between sequences +spec: B5 +yaml: | + ? # PLAY SCHEDULE + - Detroit Tigers + - Chicago Cubs + : + - 2001-07-23 + + ? [ New York Yankees, + Atlanta Braves ] + : [ 2001-07-02, 2001-08-12, + 2001-08-14 ] +ruby: | + { + [ 'Detroit Tigers', 'Chicago Cubs' ] => [ Date.new( 2001, 7, 23 ) ], + [ 'New York Yankees', 'Atlanta Braves' ] => [ Date.new( 2001, 7, 2 ), Date.new( 2001, 8, 12 ), Date.new( 2001, 8, 14 ) ] + } + +--- +test: Sequence key shortcut +spec: B6 +yaml: | + invoice: 34843 + date : 2001-01-23 + bill-to: Chris Dumars + product: + - item : Super Hoop + quantity: 1 + - item : Basketball + quantity: 4 + - item : Big Shoes + quantity: 1 +ruby: | + { + 'invoice' => 34843, 'date' => Date.new( 2001, 1, 23 ), + 'bill-to' => 'Chris Dumars', 'product' => + [ + { 'item' => 'Super Hoop', 'quantity' => 1 }, + { 'item' => 'Basketball', 'quantity' => 4 }, + { 'item' => 'Big Shoes', 'quantity' => 1 } + ] + } +python: | + [{ + 'invoice': 34843, + 'date': yaml.timestamp('2001-01-23'), + 'bill-to': 'Chris Dumars', + 'product': [ + { 'item': 'Super Hoop', 'quantity': 1 }, + { 'item': 'Basketball', 'quantity': 4 }, + { 'item': 'Big Shoes', 'quantity': 1 } + ] + }] + +--- +test: Literal perserves newlines +spec: C1 +yaml: | + --- | + \/|\/| + / | |_ +ruby: | + "\\/|\\/|\n/ | |_\n" +python: | + [ + flushLeft( + """ + \/|\/| + / | |_ + """ + ) + ] + +--- +test: Folded treats newlines as a space +spec: C2 +yaml: | + --- > + Mark McGwire's + year was crippled + by a knee injury. +ruby: | + "Mark McGwire's year was crippled by a knee injury.\n" +python: | + [ "Mark McGwire's year was crippled by a knee injury.\n" ] + +--- +test: Newlines preserved for indented and blank lines +spec: C3 +yaml: | + --- > + Sammy Sosa completed another + fine season with great stats. + + 63 Home Runs + 0.288 Batting Average + + What a year! +ruby: | + "Sammy Sosa completed another fine season with great stats.\n\n 63 Home Runs\n 0.288 Batting Average\n\nWhat a year!\n" +python: | + [ + flushLeft( + """ + Sammy Sosa completed another fine season with great stats. + + 63 Home Runs + 0.288 Batting Average + + What a year! + """ + ) + ] + + +--- +test: Indentation determines scope +spec: C4 +yaml: | + name: Mark McGwire + accomplishment: > + Mark set a major league + home run record in 1998. + stats: | + 65 Home Runs + 0.278 Batting Average +ruby: | + { + 'name' => 'Mark McGwire', 'accomplishment' => "Mark set a major league home run record in 1998.\n", + 'stats' => "65 Home Runs\n0.278 Batting Average\n" + } +python: | + [ + { + 'name': 'Mark McGwire', + 'accomplishment': + 'Mark set a major league home run record in 1998.\n', + 'stats': "65 Home Runs\n0.278 Batting Average\n" + } + ] + +--- +test: Quoted scalars +spec: C5 +yaml: | + unicode: "Sosa did fine.\u263A" + control: "\b1998\t1999\t2000\n" + hexesc: "\x0D\x0A is \r\n" + + single: '"Howdy!" he cried.' + quoted: ' # not a ''comment''.' + tie-fighter: '|\-*-/|' +ruby: | + { + "tie-fighter" => "|\\-*-/|", + "control"=>"\0101998\t1999\t2000\n", + "unicode"=>"Sosa did fine." + ["263A".hex ].pack('U*'), + "quoted"=>" # not a 'comment'.", + "single"=>"\"Howdy!\" he cried.", + "hexesc"=>"\r\n is \r\n" + } +python: | + [ { + 'unicode': u"Sosa did fine.\u263A", + 'control': "\b1998\t1999\t2000\n", + 'hexesc': "\x0D\x0A is \r\n", + 'single': '"Howdy!" he cried.', + 'quoted': ' # not a \'comment\'.', + 'tie-fighter': '|\-*-/|', + } ] + + +--- +test: Multiline flow scalars +spec: C6 +yaml: | + plain: This unquoted + scalar spans + many lines. + quoted: "\ + So does this quoted + scalar.\n" +ruby: | + { + 'plain' => 'This unquoted scalar spans many lines.', + 'quoted' => "So does this quoted scalar.\n" + } +python: | + [ { + 'plain': 'This unquoted scalar spans many lines.', + 'quoted': 'So does this quoted scalar.\n' + } + ] + +--- +test: Integers +spec: D1 +yaml: | + canonical: 12345 + decimal: +12,345 + octal: 014 + hexadecimal: 0xC +ruby: | + { + 'canonical' => 12345, + 'decimal' => 12345, + 'octal' => '014'.oct, + 'hexadecimal' => '0xC'.hex + } +python: | + [ { + 'canonical': 12345, + 'decimal': 12345, + 'octal': 014, + 'hexadecimal': 0xC + } ] + +--- +test: Floating point +spec: D2 +yaml: | + canonical: 1.23015e+3 + exponential: 12.3015e+02 + fixed: 1,230.15 + negative infinity: (-inf) + not a number: (NaN) +ruby: | + { + 'canonical' => 1230.15, + 'exponential' => 1230.15, + 'fixed' => 1230.15, + 'negative infinity' => -1.0/0.0, + 'not a number' => 0.0/0.0 + } + if obj_y['not a number'].nan? # NaN comparison doesn't work right against 0.0/0.0 + obj_r['not a number'] = obj_y['not a number'] + end +python: | + [ { + 'canonical': 1.23015e+3, + 'exponential': 1.23015e+3, + 'fixed': 1230.15, + 'negative infinity': '(-inf)', + 'not a number': '(NaN)', + } ] + +--- +test: Miscellaneous +spec: D3 +yaml: | + null: ~ + true: + + false: - + string: '12345' +ruby: | + { + 'null' => nil, + 'true' => true, + 'false' => false, + 'string' => '12345' + } +python: | + [ { + 'null': None, + 'true': 1, + 'false': 0, + 'string': '12345', + } ] + +--- +test: Timestamps +spec: D4 +yaml: | + canonical: 2001-12-15T02:59:43.1Z + iso8601: 2001-12-14t21:59:43.10-05:00 + spaced: 2001-12-14 21:59:43.10 -05:00 + date: 2002-12-14 # Time is noon UTC +ruby: | + { + 'canonical' => YAML::mktime( 2001, 12, 15, 2, 59, 43, .10 ), + 'iso8601' => YAML::mktime( 2001, 12, 14, 21, 59, 43, .10, "-05:00" ), + 'spaced' => YAML::mktime( 2001, 12, 14, 21, 59, 43, .10, "-05:00" ), + 'date' => Date.new( 2002, 12, 14 ) + } +--- +test: legacy Timestamps test +spec: legacy D4 +yaml: | + canonical: 2001-12-15T02:59:43.00Z + iso8601: 2001-02-28t21:59:43.00-05:00 + spaced: 2001-12-14 21:59:43.00 -05:00 + date: 2002-12-14 +python: | + [ { + 'canonical': yaml.timestamp('2001-12-15T02:59:43.00Z'), + 'iso8601': yaml.timestamp('2001-03-01T02:59:43.00Z'), + 'spaced': yaml.timestamp('2001-12-15T02:59:43.00Z'), + 'date': yaml.timestamp('2002-12-14T00:00:00.00Z') + } ] +ruby: | + { + 'canonical' => Time::utc( 2001, 12, 15, 2, 59, 43, 0 ), + 'iso8601' => YAML::mktime( 2001, 2, 28, 21, 59, 43, 0, "-05:00" ), + 'spaced' => YAML::mktime( 2001, 12, 14, 21, 59, 43, 0, "-05:00" ), + 'date' => Date.new( 2002, 12, 14 ) + } + +--- +test: Various explicit families +spec: D5 +yaml: | + not-date: !str 2002-04-28 + picture: !binary|base64 | + R0lGODlhDAAMAIQAAP//9/X + 17unp5WZmZgAAAOfn515eXv + Pz7Y6OjuDg4J+fn5OTk6enp + 56enmleECcgggoBADs= + + hmm: !somewhere.com,2002/type | + family above is short for + tag:somewhere.com,2002:type + +ruby-setup: | + YAML.add_domain_type( "somewhere.com,2002", /^type$/ ) { |type, val| + return "SOMEWHERE: #{val}" + } +ruby: | + { + 'not-date' => '2002-04-28', + 'picture' => "GIF89a\f\000\f\000\204\000\000\377\377\367\365\365\356\351\351\345fff\000\000\000\347\347\347^^^\363\363\355\216\216\216\340\340\340\237\237\237\223\223\223\247\247\247\236\236\236i^\020' \202\n\001\000;", + 'hmm' => "SOMEWHERE: family above is short for\ntag:somewhere.com,2002:type\n" + } + +--- +test: Application specific family +spec: D6 +yaml: | + --- !clarkevans.com,2002/graph/^shape + - !^circle + center: &ORIGIN {x: 73, y: 129} + radius: 7 + - !^line # !clarkevans.com,2002/graph/line + start: *ORIGIN + finish: { x: 89, y: 102 } + - !^text + start: *ORIGIN + color: 0xFFEEBB + value: Pretty vector drawing. +ruby-setup: | + YAML.add_domain_type( "clarkevans.com,2002", /^graph\/shape/ ) { |type, val| + if val.type == Array + val << "Shape Container" + return val + else + raise YAML::Error, "Invalid graph of type #{val.type}: " + val.inspect + end + } + one_shape_proc = Proc.new { |type, val| + if val.is_a? Kernel::Hash + val['TYPE'] = "Shape: #{type}" + return val + else + raise YAML::Error, "Invalid graph of type #{val.type}: " + val.inspect + end + } + YAML.add_domain_type( "clarkevans.com,2002", /^graph\/circle/, &one_shape_proc ) + YAML.add_domain_type( "clarkevans.com,2002", /^graph\/line/, &one_shape_proc ) + YAML.add_domain_type( "clarkevans.com,2002", /^graph\/text/, &one_shape_proc ) +ruby: | + [ + { + "radius" => 7, + "center"=> + { + "x" => 73, + "y" => 129 + }, + "TYPE" => "Shape: graph/circle" + }, { + "finish" => + { + "x" => 89, + "y" => 102 + }, + "TYPE" => "Shape: graph/line", + "start" => + { + "x" => 73, + "y" => 129 + } + }, { + "TYPE" => "Shape: graph/text", + "value" => "Pretty vector drawing.", + "start" => + { + "x" => 73, + "y" => 129 + }, + "color" => 16772795 + }, + "Shape Container" + ] + +--- +test: Invoice +spec: E1 +yaml: | + --- !clarkevans.com,2002/^invoice + invoice: 34843 + date : 2001-01-23 + bill-to: &id001 + given : Chris + family : Dumars + address: + lines: | + 458 Walkman Dr. + Suite #292 + city : Royal Oak + state : MI + postal : 48046 + ship-to: *id001 + product: + - sku : BL394D + quantity : 4 + description : Basketball + price : 450.00 + - sku : BL4438H + quantity : 1 + description : Super Hoop + price : 2392.00 + tax : 251.42 + total: 4443.52 + comments: > + Late afternoon is best. + Backup contact is Nancy + Billsmer @ 338-4338. +ruby-setup: | + YAML.add_domain_type( "clarkevans.com,2002", "invoice" ) { |type, val| val } + id001 = { 'given' => 'Chris', 'family' => 'Dumars', 'address' => + { 'lines' => "458 Walkman Dr.\nSuite #292\n", 'city' => 'Royal Oak', + 'state' => 'MI', 'postal' => 48046 } } +ruby: | + { + 'invoice' => 34843, 'date' => Date.new( 2001, 1, 23 ), + 'bill-to' => id001, 'ship-to' => id001, 'product' => + [ { 'sku' => 'BL394D', 'quantity' => 4, + 'description' => 'Basketball', 'price' => 450.00 }, + { 'sku' => 'BL4438H', 'quantity' => 1, + 'description' => 'Super Hoop', 'price' => 2392.00 } ], + 'tax' => 251.42, 'total' => 4443.52, + 'comments' => "Late afternoon is best. Backup contact is Nancy Billsmer @ 338-4338.\n" } + +--- +test: Log file +spec: E2 +yaml: | + --- + Time: 2001-11-23 15:01:42 -05:00 + User: ed + Warning: > + This is an error message + for the log file + --- + Time: 2001-11-23 15:02:31 -05:00 + User: ed + Warning: > + A slightly different error + message. + --- + Date: 2001-11-23 15:03:17 -05:00 + User: ed + Fatal: > + Unknown variable "bar" + Stack: + - file: TopClass.py + line: 23 + code: | + x = MoreObject("345\n") + - file: MoreClass.py + line: 58 + code: |- + foo = bar +ruby: | + y = Stream.new + y.add( { 'Time' => YAML::mktime( 2001, 11, 23, 15, 01, 42, 00, "-05:00" ), + 'User' => 'ed', 'Warning' => "This is an error message for the log file\n" } ) + y.add( { 'Time' => YAML::mktime( 2001, 11, 23, 15, 02, 31, 00, "-05:00" ), + 'User' => 'ed', 'Warning' => "A slightly different error message.\n" } ) + y.add( { 'Date' => YAML::mktime( 2001, 11, 23, 15, 03, 17, 00, "-05:00" ), + 'User' => 'ed', 'Fatal' => "Unknown variable \"bar\"\n", + 'Stack' => [ + { 'file' => 'TopClass.py', 'line' => 23, 'code' => "x = MoreObject(\"345\\n\")\n" }, + { 'file' => 'MoreClass.py', 'line' => 58, 'code' => "foo = bar" } ] } ) +documents: 3 + +--- +test: Throwaway comments +yaml: | + ### These are four throwaway comment ### + + ### lines (the second line is empty). ### + this: | # Comments may trail lines. + contains three lines of text. + The third one starts with a + # character. This isn't a comment. + + # These are three throwaway comment + # lines (the first line is empty). +ruby: | + { + 'this' => "contains three lines of text.\nThe third one starts with a\n# character. This isn't a comment.\n" + } + +--- +test: Document with a single value +yaml: | + --- > + This YAML stream contains a single text value. + The next stream is a log file - a sequence of + log entries. Adding an entry to the log is a + simple matter of appending it at the end. +ruby: | + "This YAML stream contains a single text value. The next stream is a log file - a sequence of log entries. Adding an entry to the log is a simple matter of appending it at the end.\n" + +--- +test: Document stream +yaml: | + --- + at: 2001-08-12 09:25:00.00 Z + type: GET + HTTP: '1.0' + url: '/index.html' + --- + at: 2001-08-12 09:25:10.00 Z + type: GET + HTTP: '1.0' + url: '/toc.html' +ruby: | + y = Stream.new + y.add( { + 'at' => Time::utc( 2001, 8, 12, 9, 25, 00 ), + 'type' => 'GET', + 'HTTP' => '1.0', + 'url' => '/index.html' + } ) + y.add( { + 'at' => Time::utc( 2001, 8, 12, 9, 25, 10 ), + 'type' => 'GET', + 'HTTP' => '1.0', + 'url' => '/toc.html' + } ) +documents: 2 + +--- +test: Top level mapping +yaml: | + # This stream is an example of a top-level mapping. + invoice : 34843 + date : 2001-01-23 + total : 4443.52 +ruby: | + { + 'invoice' => 34843, + 'date' => Date.new( 2001, 1, 23 ), + 'total' => 4443.52 + } + +--- +test: Single-line documents +yaml: | + # The following is a sequence of three documents. + # The first contains an empty mapping, the second + # an empty sequence, and the last an empty string. + --- {} + --- [ ] + --- '' +ruby: | + y = Stream.new + y.add( {} ) + y.add( [] ) + y.add( '' ) +documents: 3 + +--- +test: Document with pause +yaml: | + # A communication channel based on a YAML stream. + --- + sent at: 2002-06-06 11:46:25.10 Z + payload: Whatever + # Receiver can process this as soon as the following is sent: + ... + # Even if the next message is sent long after: + --- + sent at: 2002-06-06 12:05:53.47 Z + payload: Whatever + ... +ruby: | + y = Stream.new + y.add( + { 'sent at' => YAML::mktime( 2002, 6, 6, 11, 46, 25, .10 ), + 'payload' => 'Whatever' } + ) + y.add( + { "payload" => "Whatever", "sent at" => YAML::mktime( 2002, 6, 6, 12, 5, 53, .47 ) } + ) + y.add( nil ) +documents: 3 + +--- +test: Explicit typing +yaml: | + integer: 12 + also int: ! "12" + string: !str 12 +ruby: | + { 'integer' => 12, 'also int' => 12, 'string' => '12' } + +--- +test: Private types +yaml: | + # Both examples below make use of the 'x-private:ball' + # type family URI, but with different semantics. + --- + pool: !!ball + number: 8 + color: black + --- + bearing: !!ball + material: steel +ruby: | + y = Stream.new + y.add( { 'pool' => + PrivateType.new( 'ball', + { 'number' => 8, 'color' => 'black' } ) } + ) + y.add( { 'bearing' => + PrivateType.new( 'ball', + { 'material' => 'steel' } ) } + ) +documents: 2 + +--- +test: Type family under yaml.org +yaml: | + # The URI is 'tag:yaml.org,2002:str' + - !str a Unicode string +python: | + [ [ 'a Unicode string' ] ] +ruby: | + [ 'a Unicode string' ] + +--- +test: Type family under perl.yaml.org +yaml: | + # The URI is 'tag:perl.yaml.org,2002:Text::Tabs' + - !perl/Text::Tabs {} +ruby: | + DomainType.new( 'perl.yaml.org,2002', 'Text::Tabs', {} ) + +--- +test: Type family under clarkevans.com +yaml: | + # The URI is 'tag:clarkevans.com,2003-02:timesheet' + - !clarkevans.com,2003-02/timesheet +ruby: | + DomainType.new( 'clarkevans.com,2003-02', 'timesheet', {} ) + +--- +test: URI Escaping +yaml: | + same: + - !domain.tld,2002/type%30%10 value + - !domain.tld,2002/type\0x30\n value + different: # As far as the YAML parser is concerned + - !domain.tld,2002/type0%10 value +ruby-setup: | + YAML.add_domain_type( "domain.tld,2002", "type%30%10" ) { |type, val| + "ONE: #{val}" + } + YAML.add_domain_type( "domain.tld,2002", "type0%10" ) { |type, val| + "TWO: #{val}" + } +ruby: | + { 'same' => [ 'ONE: value', 'ONE: value' ], 'different' => [ 'TWO: value' ] } + +--- +test: URI Prefixing +yaml: | + # 'tag:domain.tld,2002:invoice' is some type family. + invoice: !domain.tld,2002/^invoice + # 'seq' is shorthand for 'tag:yaml.org,2002:seq'. + # This does not effect '^customer' below + # because it is does not specify a prefix. + customers: !seq + # '^customer' is shorthand for the full + # notation 'tag:domain.tld,2002:customer'. + - !^customer + given : Chris + family : Dumars +ruby-setup: | + YAML.add_domain_type( "domain.tld,2002", /(invoice|customer)/ ) { |type, val| + if val.is_a? Kernel::Hash + val['type'] = "domain #{type}" + return val + else + raise YAML::Error, "Not a Hash in domain.tld/invoice: " + val.inspect + end + } +ruby: | + { "invoice"=> { "customers"=> [ { "given"=>"Chris", "type"=>"domain customer", "family"=>"Dumars" } ], "type"=>"domain invoice" } } + +--- +test: Overriding anchors +yaml: | + anchor : &A001 This scalar has an anchor. + override : &A001 > + The alias node below is a + repeated use of this value. + alias : *A001 +ruby: | + { 'anchor' => 'This scalar has an anchor.', + 'override' => "The alias node below is a repeated use of this value.\n", + 'alias' => "The alias node below is a repeated use of this value.\n" } + +--- +test: Flow and block formatting +yaml: | + empty: [] + flow: [ one, two, three # May span lines, + , four, # indentation is + five ] # mostly ignored. + block: + - First item in top sequence + - + - Subordinate sequence entry + - > + A folded sequence entry + - Sixth item in top sequence +ruby: | + { 'empty' => [], 'flow' => [ 'one', 'two', 'three', 'four', 'five' ], + 'block' => [ 'First item in top sequence', [ 'Subordinate sequence entry' ], + "A folded sequence entry\n", 'Sixth item in top sequence' ] } + +--- +test: Complete mapping test +yaml: | + empty: {} + flow: { one: 1, two: 2 } + spanning: { one: 1, + two: 2 } + block: + first : First entry + second: + key: Subordinate mapping + third: + - Subordinate sequence + - { } + - Previous mapping is empty. + - A key: value pair in a sequence. + A second: key:value pair. + - The previous entry is equal to the following one. + - + A key: value pair in a sequence. + A second: key:value pair. + !float 12 : This key is a float. + ? > + ? + : This key had to be protected. + "\a" : This key had to be escaped. + ? > + This is a + multi-line + folded key + : Whose value is + also multi-line. + ? this also works as a key + : with a value at the next line. + ? + - This key + - is a sequence + : + - With a sequence value. + ? + This: key + is a: mapping + : + with a: mapping value. +ruby: | + { 'empty' => {}, 'flow' => { 'one' => 1, 'two' => 2 }, + 'spanning' => { 'one' => 1, 'two' => 2 }, + 'block' => { 'first' => 'First entry', 'second' => + { 'key' => 'Subordinate mapping' }, 'third' => + [ 'Subordinate sequence', {}, 'Previous mapping is empty.', + { 'A key' => 'value pair in a sequence.', 'A second' => 'key:value pair.' }, + 'The previous entry is equal to the following one.', + { 'A key' => 'value pair in a sequence.', 'A second' => 'key:value pair.' } ], + 12.0 => 'This key is a float.', "?\n" => 'This key had to be protected.', + "\a" => 'This key had to be escaped.', + "This is a multi-line folded key\n" => "Whose value is also multi-line.", + 'this also works as a key' => 'with a value at the next line.', + [ 'This key', 'is a sequence' ] => [ 'With a sequence value.' ] } } + # Couldn't recreate map exactly, so we'll do a detailed check to be sure it's entact + obj_y['block'].keys.each { |k| + if k.type == Hash + v = obj_y['block'][k] + if k['This'] == 'key' and k['is a'] == 'mapping' and v['with a'] == 'mapping value.' + obj_r['block'][k] = v + end + end + } +no-round-trip: + - ruby + +--- +test: Literal explicit indentation +yaml: | + # Explicit indentation must + # be given in all the three + # following cases. + leading spaces: |2 + This value starts with four spaces. + + leading line break: |2 + + This value starts with a line break. + + leading comment indicator: |2 + # first line starts with a + # character. + + # Explicit indentation may + # also be given when it is + # not required. + redundant: |2 + This value is indented 2 spaces. +ruby: | + { + 'leading spaces' => " This value starts with four spaces.\n", + 'leading line break' => "\nThis value starts with a line break.\n", + 'leading comment indicator' => "# first line starts with a\n# character.\n", + 'redundant' => "This value is indented 2 spaces.\n" + } + +--- +test: Chomping and keep modifiers +yaml: | + clipped: | + This has one newline. + + same as "clipped" above: "This has one newline.\n" + + stripped: |- + This has no newline. + + same as "stripped" above: "This has no newline." + + kept: |+ + This has two newlines. + + same as "kept" above: "This has two newlines.\n\n" +ruby: | + { + 'clipped' => "This has one newline.\n", + 'same as "clipped" above' => "This has one newline.\n", + 'stripped' => 'This has no newline.', + 'same as "stripped" above' => 'This has no newline.', + 'kept' => "This has two newlines.\n\n", + 'same as "kept" above' => "This has two newlines.\n\n" + } + +--- +test: Literal combinations +yaml: | + empty: | + + literal: | + The \ ' " characters may be + freely used. Leading white + space is significant. + + Line breaks are significant. + Thus this value contains one + empty line and ends with a + single line break, but does + not start with one. + + is equal to: "The \\ ' \" characters may \ + be\nfreely used. Leading white\n space \ + is significant.\n\nLine breaks are \ + significant.\nThus this value contains \ + one\nempty line and ends with a\nsingle \ + line break, but does\nnot start with one.\n" + + # Comments may follow a block + # scalar value. They must be + # less indented. + + # Modifiers may be combined in any order. + indented and chomped: |2- + This has no newline. + + also written as: |-2 + This has no newline. + + both are equal to: " This has no newline." +ruby: | + { + 'empty' => '', + 'literal' => "The \\ ' \" characters may be\nfreely used. Leading white\n space " + + "is significant.\n\nLine breaks are significant.\nThus this value contains one\n" + + "empty line and ends with a\nsingle line break, but does\nnot start with one.\n", + 'is equal to' => "The \\ ' \" characters may be\nfreely used. Leading white\n space " + + "is significant.\n\nLine breaks are significant.\nThus this value contains one\n" + + "empty line and ends with a\nsingle line break, but does\nnot start with one.\n", + 'indented and chomped' => ' This has no newline.', + 'also written as' => ' This has no newline.', + 'both are equal to' => ' This has no newline.' + } + +--- +test: Folded combinations +yaml: | + empty: > + + one paragraph: > + Line feeds are converted + to spaces, so this value + contains no line breaks + except for the final one. + + multiple paragraphs: >2 + + An empty line, either + at the start or in + the value: + + Is interpreted as a + line break. Thus this + value contains three + line breaks. + + indented text: > + This is a folded + paragraph followed + by a list: + * first entry + * second entry + Followed by another + folded paragraph, + another list: + + * first entry + + * second entry + + And a final folded + paragraph. + + above is equal to: | + This is a folded paragraph followed by a list: + * first entry + * second entry + Followed by another folded paragraph, another list: + + * first entry + + * second entry + + And a final folded paragraph. + + # Explicit comments may follow + # but must be less indented. +ruby: | + { + 'empty' => '', + 'one paragraph' => 'Line feeds are converted to spaces, so this value' + + " contains no line breaks except for the final one.\n", + 'multiple paragraphs' => "\nAn empty line, either at the start or in the value:\n" + + "Is interpreted as a line break. Thus this value contains three line breaks.\n", + 'indented text' => "This is a folded paragraph followed by a list:\n" + + " * first entry\n * second entry\nFollowed by another folded paragraph, " + + "another list:\n\n * first entry\n\n * second entry\n\nAnd a final folded paragraph.\n", + 'above is equal to' => "This is a folded paragraph followed by a list:\n" + + " * first entry\n * second entry\nFollowed by another folded paragraph, " + + "another list:\n\n * first entry\n\n * second entry\n\nAnd a final folded paragraph.\n" + } + +--- +test: Single quotes +yaml: | + empty: '' + second: '! : \ etc. can be used freely.' + third: 'a single quote '' must be escaped.' + span: 'this contains + six spaces + + and one + line break' + is same as: "this contains six spaces\nand one line break" +ruby: | + { + 'empty' => '', + 'second' => '! : \\ etc. can be used freely.', + 'third' => "a single quote ' must be escaped.", + 'span' => "this contains six spaces\nand one line break", + 'is same as' => "this contains six spaces\nand one line break" + } + +--- +test: Double quotes +yaml: | + empty: "" + second: "! : etc. can be used freely." + third: "a \" or a \\ must be escaped." + fourth: "this value ends with an LF.\n" + span: "this contains + four \ + spaces" + is equal to: "this contains four spaces" +ruby: | + { + 'empty' => '', + 'second' => '! : etc. can be used freely.', + 'third' => 'a " or a \\ must be escaped.', + 'fourth' => "this value ends with an LF.\n", + 'span' => "this contains four spaces", + 'is equal to' => "this contains four spaces" + } + +--- +test: Unquoted strings +yaml: | + first: There is no unquoted empty string. + + second: 12 ## This is an integer. + + boolean: - ## This is (false). + + third: !str 12 ## This is a string. + + span: this contains + six spaces + + and one + line break + + indicators: this has no comments. + #:foo and bar# are + both text. + + flow: [ can span + lines, # comment + like + this ] + + note: { one-line keys: but + multi-line values } + +ruby: | + { + 'first' => 'There is no unquoted empty string.', + 'second' => 12, + 'boolean' => false, + 'third' => '12', + 'span' => "this contains six spaces\nand one line break", + 'indicators' => "this has no comments. #:foo and bar# are both text.", + 'flow' => [ 'can span lines', 'like this' ], + 'note' => { 'one-line keys' => 'but multi-line values' } + } + +--- +test: Spanning sequences +yaml: | + # The following are equal seqs + # with different identities. + flow: [ one, two ] + spanning: [ one, + two ] + block: + - one + - two +ruby: | + { + 'flow' => [ 'one', 'two' ], + 'spanning' => [ 'one', 'two' ], + 'block' => [ 'one', 'two' ] + } + +--- +test: Flow mappings +yaml: | + # The following are equal maps + # with different identities. + flow: { one: 1, two: 2 } + block: + one: 1 + two: 2 +ruby: | + { + 'flow' => { 'one' => 1, 'two' => 2 }, + 'block' => { 'one' => 1, 'two' => 2 } + } + +--- +test: Representations of 12 +yaml: | + - 12 # An integer + # The following scalars + # are loaded to the + # string value '1' '2'. + - !str 12 + - '12' + - "12" + - "\ + 1\ + 2\ + " + # Strings containing paths and regexps can be unquoted: + - /foo/bar + - d:/foo/bar + - foo/bar + - /a.*b/ +ruby: | + [ 12, '12', '12', '12', '12', '/foo/bar', 'd:/foo/bar', 'foo/bar', '/a.*b/' ] + +--- +test: Null +yaml: | + canonical: ~ + + english: (null) + + # This sequence has four + # entries, two with values. + sparse: + - ~ + - 2nd entry + - (nil) + - 4th entry + + four: This mapping has four keys, + only two with values. +ruby: | + { + 'canonical' => nil, + 'english' => nil, + 'sparse' => [ nil, '2nd entry', nil, '4th entry' ], + 'four' => 'This mapping has four keys, only two with values.' + } + +--- +test: Boolean +yaml: | + - : used as key # Does not indicate a sequence. + canonical: + + logical: (true) + informal: (no) +ruby: | + { + false => 'used as key', + 'canonical' => true, + 'logical' => true, + 'informal' => false + } + +--- +test: Integer +yaml: | + canonical: 12345 + decimal: +12,345 + octal: 014 + hexadecimal: 0xC +ruby: | + { + 'canonical' => 12345, + 'decimal' => 12345, + 'octal' => 12, + 'hexadecimal' => 12 + } + +--- +test: Float +yaml: | + canonical: 1.23015e+3 + exponential: 12.3015e+02 + fixed: 1,230.15 + negative infinity: (-inf) + not a number: (NaN) +ruby: | + { + 'canonical' => 1230.15, + 'exponential' => 1230.15, + 'fixed' => 1230.15, + 'negative infinity' => -1.0/0.0, + 'not a number' => 0.0/0.0 + } + if obj_y['not a number'].nan? # NaN comparison doesn't work right against 0.0/0.0 + obj_r['not a number'] = obj_y['not a number'] + end +no-round-trip: + - ruby + +--- +test: Timestamp +yaml: | + canonical: 2001-12-15T02:59:43.1Z + valid iso8601: 2001-12-14t21:59:43.10-05:00 + space separated: 2001-12-14 21:59:43.10 -05:00 + date (noon UTC): 2002-12-14 +ruby: | + { + 'canonical' => YAML::mktime( 2001, 12, 15, 2, 59, 43, .10 ), + 'valid iso8601' => YAML::mktime( 2001, 12, 14, 21, 59, 43, .10, "-05:00" ), + 'space separated' => YAML::mktime( 2001, 12, 14, 21, 59, 43, .10, "-05:00" ), + 'date (noon UTC)' => Date.new( 2002, 12, 14 ) + } + +--- +test: Binary +yaml: | + canonical: !binary "\ + R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOf\ + n515eXvPz7Y6OjuDg4J+fn5OTk6enp56enmlpaW\ + NjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++\ + f/++f/++f/++f/++f/++f/++f/++SH+Dk1hZGUg\ + d2l0aCBHSU1QACwAAAAADAAMAAAFLCAgjoEwnuN\ + AFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84Bww\ + EeECcgggoBADs=" + base64: !binary | + R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOf + n515eXvPz7Y6OjuDg4J+fn5OTk6enp56enmlpaW + NjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++ + f/++f/++f/++f/++f/++f/++f/++SH+Dk1hZGUg + d2l0aCBHSU1QACwAAAAADAAMAAAFLCAgjoEwnuN + AFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84Bww + EeECcgggoBADs= + description: > + The binary value above is a tiny arrow + encoded as a gif image. +ruby-setup: | + arrow_gif = "GIF89a\f\000\f\000\204\000\000\377\377\367\365\365\356\351\351\345fff\000\000\000\347\347\347^^^\363\363\355\216\216\216\340\340\340\237\237\237\223\223\223\247\247\247\236\236\236iiiccc\243\243\243\204\204\204\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371!\376\016Made with GIMP\000,\000\000\000\000\f\000\f\000\000\005, \216\2010\236\343@\024\350i\020\304\321\212\010\034\317\200M$z\357\3770\205p\270\2601f\r\e\316\001\303\001\036\020' \202\n\001\000;" +ruby: | + { + 'canonical' => arrow_gif, + 'base64' => arrow_gif, + 'description' => "The binary value above is a tiny arrow encoded as a gif image.\n" + } + +--- +test: Default key +yaml: | + --- # Old schema + link with: + - library1.dll + - library2.dll + --- # New schema + link with: + - = : library1.dll + version: 1.2 + - = : library2.dll + version: 2.3 +ruby: | + y = Stream.new + y.add( { 'link with' => [ 'library1.dll', 'library2.dll' ] } ) + obj_h = YAML::SpecialHash[ 'version' => 1.2 ] + obj_h.default = 'library1.dll' + obj_h2 = YAML::SpecialHash[ 'version' => 2.3 ] + obj_h2.default = 'library2.dll' + y.add( { 'link with' => [ obj_h, obj_h2 ] } ) +documents: 2 + +--- +test: Special keys +yaml: | + "!": These three keys + "&": had to be quoted + "=": and are normal strings. + # NOTE: the following node should NOT be serialized this way. + encoded node : + !special '!' : '!type' + !special|canonical '&' : 12 + = : value + # The proper way to serialize the above node is as follows: + node : !!type &12 value Index: /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/docSep.yml =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/docSep.yml (revision 71) +++ /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/docSep.yml (revision 71) @@ -0,0 +1,103 @@ +--- #YAML:1.0 +test: Trailing Document Separator +brief: > + You can separate YAML documents + with a string of three dashes. +yaml: | + - foo: 1 + bar: 2 + --- + more: stuff +python: | + [ + [ {'foo': 1, 'bar': 2}], + {'more': 'stuff'} + ] +ruby: | + [ { 'foo' => 1, 'bar' => 2 } ] + +--- +test: Leading Document Separator +brief: > + You can explicity give an opening + document separator to your YAML stream. +yaml: | + --- + - foo: 1 + bar: 2 + --- + more: stuff +python: | + [ + [ {'foo': 1, 'bar': 2}], + {'more': 'stuff'} + ] +ruby: | + [ { 'foo' => 1, 'bar' => 2 } ] + +--- +test: YAML Header +brief: > + The opening separator can contain directives + to the YAML parser, such as the version + number. +yaml: | + --- #YAML:1.0 + foo: 1 + bar: 2 +python: | + [ + { 'foo': 1, 'bar': 2 } + ] +ruby: | + y = Stream.new + y.add( { 'foo' => 1, 'bar' => 2 } ) +documents: 1 + +--- +test: Red Herring Document Separator +brief: > + Separators included in blocks or strings + are treated as blocks or strings, as the + document separator should have no indentation + preceding it. +yaml: | + foo: | + --- +python: | + [ + { 'foo': "---\n" } + ] +ruby: | + { 'foo' => "---\n" } + +--- +test: Multiple Document Separators in Block +brief: > + This technique allows you to embed other YAML + documents within literal blocks. +yaml: | + foo: | + --- + foo: bar + --- + yo: baz + bar: | + fooness +python: | + [ + { 'foo': flushLeft(""" + --- + foo: bar + --- + yo: baz + """), + 'bar': "fooness\n" + } + ] +ruby: | + { + 'foo' => "---\nfoo: bar\n---\nyo: baz\n", + 'bar' => "fooness\n" + } + Index: /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/basic.yml =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/basic.yml (revision 71) +++ /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/basic.yml (revision 71) @@ -0,0 +1,242 @@ +--- #YAML:1.0 +test: Simple Sequence +brief: > + You can specify a list in YAML by placing each + member of the list on a new line with an opening + dash. These lists are called sequences. +yaml: | + - apple + - banana + - carrot +perl: | + ['apple', 'banana', 'carrot'] +python: | + [ + ['apple', 'banana', 'carrot'] + ] +ruby: | + ['apple', 'banana', 'carrot'] + +--- +test: Nested Sequences +brief: > + You can include a sequence within another + sequence by giving the sequence an empty + dash, followed by an indented list. +yaml: | + - + - foo + - bar + - baz +perl: | + [['foo', 'bar', 'baz']] +python: | + [ + [['foo', 'bar', 'baz']] + ] +ruby: | + [['foo', 'bar', 'baz']] + +--- +test: Mixed Sequences +brief: > + Sequences can contain any YAML data, + including strings and other sequences. +yaml: | + - apple + - + - foo + - bar + - x123 + - banana + - carrot +perl: | + ['apple', ['foo', 'bar', 'x123'], 'banana', 'carrot'] +python: | + [ + ['apple', ['foo', 'bar', 'x123'], 'banana', 'carrot'] + ] +ruby: | + ['apple', ['foo', 'bar', 'x123'], 'banana', 'carrot'] + +--- +test: Deeply Nested Sequences +brief: > + Sequences can be nested even deeper, with each + level of indentation representing a level of + depth. +yaml: | + - + - + - uno + - dos +perl: | + [[['uno', 'dos']]] +python: | + [ + [[['uno', 'dos']]] + ] +ruby: | + [[['uno', 'dos']]] + +--- +test: Simple Mapping +brief: > + You can add a keyed list (also known as a dictionary or + hash) to your document by placing each member of the + list on a new line, with a colon seperating the key + from its value. In YAML, this type of list is called + a mapping. +yaml: | + foo: whatever + bar: stuff +perl: | + { foo => 'whatever', bar => 'stuff' } +python: | + [ + {'foo': 'whatever', 'bar': 'stuff'} + ] +ruby: | + { 'foo' => 'whatever', 'bar' => 'stuff' } + +--- +test: Sequence in a Mapping +brief: > + A value in a mapping can be a sequence. +yaml: | + foo: whatever + bar: + - uno + - dos +perl: | + { foo => 'whatever', bar => [ 'uno', 'dos' ] } +python: | + [ + {'foo': 'whatever', 'bar': ['uno', 'dos']} + ] +ruby: | + { 'foo' => 'whatever', 'bar' => [ 'uno', 'dos' ] } + +--- +test: Nested Mappings +yaml: | + foo: whatever + bar: + fruit: apple + name: steve + sport: baseball +brief: > + A value in a mapping can be another mapping. +perl: | + { foo => 'whatever', + bar => { + fruit => 'apple', + name => 'steve', + sport => 'baseball' + } + } +python: | + [ + {'foo': 'whatever', + 'bar': { + 'fruit': 'apple', + 'name': 'steve', + 'sport': 'baseball' + } + } + ] +ruby: | + { 'foo' => 'whatever', + 'bar' => { + 'fruit' => 'apple', + 'name' => 'steve', + 'sport' => 'baseball' + } + } + +--- +test: Mixed Mapping +brief: > + A mapping can contain any assortment + of mappings and sequences as values. +yaml: | + foo: whatever + bar: + - + fruit: apple + name: steve + sport: baseball + - more + - + python: rocks + perl: papers + ruby: scissorses +perl: | + { foo => 'whatever', + bar => [ + { + fruit => 'apple', + name => 'steve', + sport => 'baseball' + }, + 'more', + { + python => 'rocks', + perl => 'papers', + ruby => 'scissorses' + } + ] + } +python: | + [ + {'foo': 'whatever', + 'bar': [ + { + 'fruit': 'apple', + 'name': 'steve', + 'sport': 'baseball' + }, + 'more', + { + 'python': 'rocks', + 'perl': 'papers', + 'ruby': 'scissorses' + } + ] + } + ] +ruby: | + { 'foo' => 'whatever', + 'bar' => [ + { + 'fruit' => 'apple', + 'name' => 'steve', + 'sport' => 'baseball' + }, + 'more', + { + 'python' => 'rocks', + 'perl' => 'papers', + 'ruby' => 'scissorses' + } + ] + } + +--- +test: Sequence-Mapping Shortcut +brief: > + If you are adding a mapping to a sequence, you + can place the mapping on the same line as the + dash as a shortcut. +yaml: | + - work on YAML.py: + - work on Store +perl: | + [ { 'work on YAML.py' => ['work on Store'] } ] +python: | + [ + [ {'work on YAML.py': ['work on Store']} ] + ] +ruby: | + [ { 'work on YAML.py' => ['work on Store'] } ] + Index: /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/ruby.yml =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/ruby.yml (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/TestingSuite/ruby.yml (revision 75) @@ -0,0 +1,222 @@ +--- #YAML:1.0 +test: Symbols +brief: > + Ruby Symbols can be simply serialized using + the !ruby/symbol transfer method, or the + abbreviated !ruby/sym. +yaml: | + simple symbol: !ruby/symbol Simple + shortcut syntax: !ruby/sym Simple + symbols in seqs: + - !ruby/symbol ValOne + - !ruby/symbol ValTwo + - !ruby/symbol ValThree + symbols in maps: + !ruby/symbol MapKey: !ruby/symbol MapValue +ruby: | + { 'simple symbol' => :Simple, + 'shortcut syntax' => :Simple, + 'symbols in seqs' => [ :ValOne, :ValTwo, :ValThree ], + 'symbols in maps' => { :MapKey => :MapValue } + } + +--- +test: Ranges +brief: > + Ranges are serialized with the !ruby/range + type family. +yaml: | + normal range: !ruby/range 10..20 + exclusive range: !ruby/range 11...20 + negative range: !ruby/range -1..-5 + ? !ruby/range 0..40 + : range as a map key +ruby: | + { 'normal range' => (10..20), + 'exclusive range' => (11...20), + 'negative range' => (-1..-5), + (0..40) => 'range as a map key' + } + +--- +test: Regexps +brief: > + Regexps may be serialized to YAML, both its + syntax and any modifiers. +yaml: | + case-insensitive: !ruby/regexp "/George McFly/i" + complex: !ruby/regexp "/\\A\"((?:[^\"]|\\\")+)\"/" + simple: !ruby/regexp '/a.b/' +ruby: | + { 'simple' => /a.b/, 'complex' => /\A"((?:[^"]|\")+)"/, + 'case-insensitive' => /George McFly/i } + +--- +test: Perl Regexps +brief: > + Regexps may also be imported from serialized + Perl. +yaml: | + --- !perl/regexp: + REGEXP: "R[Uu][Bb][Yy]$" + MODIFIERS: i +ruby: | + /R[Uu][Bb][Yy]$/i + +--- +test: Struct class +brief: > + The Ruby Struct class is registered as a YAML + builtin type through Ruby, so it can safely + be serialized. To use it, first make sure you + define your Struct with Struct::new. Then, + you are able to serialize with Struct#to_yaml + and unserialize from a YAML stream. +yaml: | + --- !ruby/struct:BookStruct + author: Yukihiro Matsumoto + title: Ruby in a Nutshell + year: 2002 + isbn: 0-596-00214-9 +ruby-setup: | + book_struct = Struct::new( "BookStruct", :author, :title, :year, :isbn ) +ruby: | + book_struct.new( "Yukihiro Matsumoto", "Ruby in a Nutshell", 2002, "0-596-00214-9" ) + +--- +test: Nested Structs +brief: > + As with other YAML builtins, you may nest the + Struct inside of other Structs or other data + types. +yaml: | + - !ruby/struct:FoodStruct + name: Nachos + ingredients: + - Mission Chips + - !ruby/struct:FoodStruct + name: Tostitos Nacho Cheese + ingredients: + - Milk and Enzymes + - Jack Cheese + - Some Volatile Chemicals + taste: Angelic + - Sour Cream + taste: Zesty + - !ruby/struct:FoodStruct + name: Banana Cream Pie + ingredients: + - Bananas + - Creamy Stuff + - And Such + taste: Puffy +ruby-setup: | + food_struct = Struct::new( "FoodStruct", :name, :ingredients, :taste ) +ruby: | + [ + food_struct.new( 'Nachos', [ 'Mission Chips', + food_struct.new( 'Tostitos Nacho Cheese', [ 'Milk and Enzymes', 'Jack Cheese', 'Some Volatile Chemicals' ], 'Angelic' ), + 'Sour Cream' ], 'Zesty' ), + food_struct.new( 'Banana Cream Pie', [ 'Bananas', 'Creamy Stuff', 'And Such' ], 'Puffy' ) + ] + +--- +test: Objects +brief: > + YAML has generic support for serializing objects + from any class available in Ruby. If using the + generic object serialization, no extra code is + needed. +yaml: | + --- !ruby/object:YAML::Zoolander + name: Derek + look: Blue Steel +ruby-setup: | + class Zoolander + attr_accessor :name, :look + def initialize( look ) + @name = "Derek" + @look = look + end + def ==( z ) + self.name == z.name and self.look == z.look + end + end +ruby: | + Zoolander.new( "Blue Steel" ) + +--- +test: Extending Kernel::Array +brief: > + When extending the Array class, your instances + of such a class will dump as YAML sequences, + tagged with a class name. +yaml: | + --- !ruby/array:YAML::MyArray + - jacket + - sweater + - windbreaker +ruby-setup: | + class MyArray < Kernel::Array; end +ruby: | + outerwear = MyArray.new + outerwear << 'jacket' + outerwear << 'sweater' + outerwear << 'windbreaker' + outerwear + +--- +test: Extending Kernel::Hash +brief: > + When extending the Hash class, your instances + of such a class will dump as YAML maps, tagged + with a class name. +yaml: | + --- !ruby/hash:YAML::MyHash + Black Francis: Frank Black + Kim Deal: Breeders + Joey Santiago: Martinis +ruby-setup: | + # Note that the @me attribute isn't dumped + # because the default to_yaml is trained + # to dump as a regular Hash. + class MyHash < Kernel::Hash + attr_accessor :me + def initialize + @me = "Why" + end + end +ruby: | + pixies = MyHash.new + pixies['Black Francis'] = 'Frank Black' + pixies['Kim Deal'] = 'Breeders' + pixies['Joey Santiago'] = 'Martinis' + pixies + +--- +test: YAML::Pairs +brief: > + The sequence-mapping shortcut in YAML allows you to + place the first line of the mapping on the same line + as the dash for the entry containing the mapping. + The !ruby/pairs type takes advantage of this shortcut + to create (instead of a sequence including maps) a + single object of pairs which can be accessed like an + ordered hash. Entries in which the last value in the + pair is null can simply show the first value in the pair. +yaml: | + --- !ruby/pairs + - Minh Thai: 22.95 + - Guus Razous-Schultz: 24.32 + - Zoltan Labas Hungary: 24.49 + - Lars Petrus + - Ken`ichi Ueno Japan +ruby: | + winners = YAML::Pairs.new + winners[ 'Minh Thai' ] = 22.95 + winners[ 'Guus Razous-Schultz' ] = 24.32 + winners[ 'Zoltan Labas Hungary' ] = 24.49 + winners[ 'Lars Petrus' ] = nil + winners[ 'Ken`ichi Ueno Japan' ] = nil + winners + Index: /pyyaml-legacy/tags/PyYaml_0.32/patches/stream.py.patch =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/patches/stream.py.patch (revision 72) +++ /pyyaml-legacy/tags/PyYaml_0.32/patches/stream.py.patch (revision 72) @@ -0,0 +1,53 @@ +--- yaml/stream.py 2002-12-26 09:53:42.000000000 -0800 ++++ yaml/stream.py 2003-12-04 13:14:41.000000000 -0800 +@@ -94,12 +94,15 @@ + return self.commentEater.lastLineRead() + + def reset(self): + self.indentLevel = 0 + self.oldIndents = [0] ++ self.empty = 0 + + def peek(self): ++ if self.empty: ++ return + nextLine = self.commentEater.peek() + if nextLine is not None: + if indentLevel(nextLine) >= self.indentLevel: + return nextLine[self.indentLevel:] + elif nextLine == '': +@@ -107,10 +110,11 @@ + + def pop(self): + line = self.peek() + if line is None: + self.indentLevel = self.oldIndents.pop() ++ self.empty = 0 + return + self.commentEater.pop() + return line + + def popNestedLines(self): +@@ -128,19 +132,20 @@ + + def nestToNextLine(self): + line = self.commentEater.peek() + indentation = indentLevel(line) + if len(self.oldIndents) > 1 and indentation <= self.indentLevel: +- self.error("Inadequate indentation", line) ++ self.empty = 1 ++ #self.error("Inadequate indentation", line) + self.setNewIndent(indentation) + + def nestBySpecificAmount(self, adjust): + self.setNewIndent(self.indentLevel + adjust) + + def setNewIndent(self, indentLevel): + self.oldIndents.append(self.indentLevel) +- self.indentLevel = indentLevel ++ self.indentLevel = indentLevel + + class YamlLoaderException(Exception): + def __init__(self, *args): + (self.msg, self.lineNum, self.line, self.filename) = args + Index: /pyyaml-legacy/tags/PyYaml_0.32/patches/load.py.patch =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/patches/load.py.patch (revision 72) +++ /pyyaml-legacy/tags/PyYaml_0.32/patches/load.py.patch (revision 72) @@ -0,0 +1,103 @@ +--- yaml/load.py 2002-12-26 08:38:51.000000000 -0800 ++++ yaml/load.py 2003-10-02 15:53:06.000000000 -0700 +@@ -45,10 +45,13 @@ + if ok: + return (1, result) + + def dumpDictionary(): return {} + ++_STRIP = 1 ++_KEEP = 2 ++ + class Parser: + def __init__(self, stream, typeResolver=None): + try: + self.dictionary = dict + except: +@@ -167,19 +170,16 @@ + if alias: + self.aliases[alias] = value + return value + + def parse_unaliased_value(self, value): +- match = re.match(r"(!\S*)(.*)", value) ++ match = re.match(r"(!\S*) (.*)", value) + if match: + (url, value) = match.groups() +- value = self.parse_untyped_value(value) + if url[:2] == '!!': + return self.typeResolver.resolveType(value, url) +- else: +- # XXX - allows syntax, but ignores it +- return value ++ return self.parse_untyped_value(value) + return self.parse_untyped_value(value) + + def parseInlineArray(self, value): + if re.match("\s*\[", value): + return self.parseInline([], value, ']', +@@ -231,36 +231,54 @@ + + def parseNative(self, value): + return (1, convertImplicit(value)) + + def parseMultiLineScalar(self, value): ++ # XXX does not handle indentation ex. >2, or |2 + if value == '>': + return (1, self.parseFolded()) ++ elif value == '>-': ++ return (1, self.parseFolded(_STRIP)) ++ elif value == '>+': ++ return (1, self.parseFolded(_KEEP)) + elif value == '|': +- return (1, joinLiteral(self.parseBlock())) ++ return (1, self.parseBlock()) ++ elif value == '|-': ++ return (1, self.parseBlock(_STRIP)) + elif value == '|+': +- return (1, joinLiteral(self.unprunedBlock())) ++ return (1, self.parseBlock(_KEEP)) + +- def parseFolded(self): +- data = self.parseBlock() ++ def parseFolded(self, chomping = 0): ++ data = self.unprunedBlock() ++ if chomping != _KEEP: ++ data = pruneTrailingEmpties(data) + i = 0 + resultString = '' + while i < len(data)-1: +- resultString = resultString + data[i] +- resultString = resultString + foldChar(data[i], data[i+1]) +- i = i + 1 +- return resultString + data[-1] + "\n" ++ resultString += data[i] ++ resultString += foldChar(data[i], data[i+1]) ++ i += 1 ++ resultString += data[-1] ++ if chomping ==_STRIP: ++ return resultString ++ return resultString + "\n" + + def unprunedBlock(self): + self.nestedDocs.nestToNextLine() + data = [] + while self.nestPop(): + data.append(self.line) + return data + +- def parseBlock(self): +- return pruneTrailingEmpties(self.unprunedBlock()) ++ def parseBlock(self, chomping = 0): ++ data = self.unprunedBlock() ++ if chomping != _KEEP: ++ data = pruneTrailingEmpties(data) ++ resultString = string.join(data, "\n") ++ if chomping == _STRIP: ++ return resultString ++ return resultString + "\n" + + def testForAlias(self, value): + match = re.match("&(\S*)\s*(.*)", value) + if match: + return match.groups() Index: /pyyaml-legacy/tags/PyYaml_0.32/CHANGELOG =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/CHANGELOG (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/CHANGELOG (revision 75) @@ -0,0 +1,71 @@ +--- +- version: 0.32 + date: 2002-12-26 + changes: + - report filenames in loadFile exceptions + - added loadOrdered() method +--- +- version: 0.31 + date: 2002-11-17 + changes: + - dumper doesn't quote strings just because they have dashes + - dumper does quote strings that look like negative numbers + - dumper does quote strings w/*, &, and white space on edges + - dumper doesn't quote strings starting with "* " + - loader can tolerate "* " unquoted + - complain about duplicate keys in dictionary + - complain about trailing spaces + - l() and d() convenience methods + - applied Tim Hochberg's FLOAT/SCIENTIFIC patch + - sync __version__ to CHANGELOG +--- +- version: 0.30 + date: 2002-11-06 + changes: + - bunch of changes for 2.1 support + - fully tested on 2.1.3 and 2.2 + - added YamlLoaderException + - pluggable dictionaries (2.2 only) + - simplified iterator interface (deprecated getNextDocument) + - single quote &foo properly + - quote "foo'bar properly +--- +- version: 0.29 + date: 2002-11-03 + changes: + - support |+ syntax +--- +- version: 0.28 + date: 2002-09-25 + changes: + - use compiled regexes for speed + - streamlined stream.py for speed + - added profileYaml.py +--- +- version: 0.27 + date: 2002-09-24 + changes: + - better error handling + - removed spurious spaces from specs.yml + - use a true FileStream class vs. reading in entire file up front +--- +- version: 0.26 + date: 2002-09-23 + changes: + - support to_yaml() when you inherit from Python's dict class + - move implicit and inline logic into own modules + - require space after comma for inline collections (Brian Dorsey) + - only call user's resolver for !!private types + - don't choke on !str, etc. (but doesn't yet respect them) + - fixed bugs in loader/dumper related to integer dict keys (Joel Shprentz) +--- +- version: 0.25 + date: 2002-08-21 + changes: + - extensive refactorings on dumper + - Dumper class made public + - new interface for setIndent and setSort + - added Dave Kuhlman's XmlYaml stuff + - limiting support to Python 2.2 and above + + Index: /pyyaml-legacy/tags/PyYaml_0.32/YamlTest.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/YamlTest.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/YamlTest.py (revision 75) @@ -0,0 +1,118 @@ +import unittest, sys, string +import yaml +from here import flushLeft +import re +import glob +from test import assertEquals, assertError +from yaml.klass import makeClass + +try: + unicode('') + hasUnicode = 1 +except: + hasUnicode = 0 + + +def loadFlushLeft(stream, typeResolver=None): + return list(yaml.load(flushLeft(stream), typeResolver)) + +class YamlTest(unittest.TestCase): + + def runTest(self): + # reinvent the wheel, instead of trying to + # understand unittest's braindead interface + for name in dir(self.__class__): + if re.match('test', name): + exec('self.%s()' % name) + + def verify(self, stream, results): + self.verifyMany(stream, [results]) + + def verifyMany(self, stream, expected): + results = loadFlushLeft(stream) + assertEquals(results, expected) + +class ClassForRuntime: + def __init__(self): + self.foo = 1 + self.bar = 2 + +class YamlLoader: + # XXX python 2.1 has weak lambda support + def __init__(self, doc): + self.doc = doc + def __call__(self): + return list(yaml.load(self.doc['yaml'])) + +class TestFromSpec(YamlTest): + def testFromYaml(self): + testFiles = glob.glob('TestingSuite/*.yml') + for file in testFiles: + # print "\n\n\n\n", file + try: + docs = yaml.loadFile(file) + except IOError: + raise "See TESTING for how to set up TestingSuite" + for doc in docs: + if doc.has_key('python'): + self.verifyOneDoc(doc) + if doc.has_key('error') and doc['error'].has_key('python'): + assertError(YamlLoader(doc), doc['error']['python']) + + def verifyOneDoc(self, doc): + if doc.has_key('python_setup'): + exec(doc['python_setup']) + data = eval(doc['python']) + # print data + assertEquals(list(yaml.load(doc['yaml'])), data) + if not doc.has_key('NO_ROUND_TRIP'): + self.assertRoundTrip(data) + + def assertRoundTrip(self, data): + # XXX - A5 won't round trip when enclosed by + # an array...need to investigate + for item in data: + # print dump(item) + assertEquals(item, + yaml.load(yaml.dump(item)).next(), 'roundtrip') + + +class TestUtils(YamlTest): + class Dummy: + pass + + def testMakeClass(self): + self.assertEquals(42, + makeClass('YamlTest', 'TestUtils.Dummy', + {'a': 27, 'b': 42}).b) + + class FromYaml: + def from_yaml(self, dict): + self.sum = dict['a'] + dict['b'] + return self + + def testMakeClassFromYaml(self): + self.assertEquals(6, + makeClass('YamlTest', 'TestUtils.FromYaml', + {'a': 2, 'b': 4}).sum) + + +def testVersion(): + from yaml import __version__ + assertEquals(__version__, str(yaml.loadFile('CHANGELOG').next()[0]['version'])) + +if __name__ == '__main__': + import TestYamlBasics + import TestNestedText + import TestInlineTokenizer + import TestDumper + ts = unittest.TestSuite() + ts.addTest(TestYamlBasics.Test()) + ts.addTest(TestNestedText.Test()) + ts.addTest(TestInlineTokenizer.Test()) + ts.addTest(TestDumper.Test()) + ts.addTest(TestFromSpec()) + ts.addTest(TestUtils()) + unittest.TextTestRunner().run(ts) + yaml.dumpToFile(sys.stdout, {'TESTING dumpToFile': 'ok'}) + testVersion() Index: /pyyaml-legacy/tags/PyYaml_0.32/insert.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/insert.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/insert.py (revision 75) @@ -0,0 +1,20 @@ +from PyYaml import yaml +from test import assertEquals +from ypath import Ypath +import re + +def Insert(data, command): + if command.has_key('ypath'): + Ypath(data, command['ypath']).append(command['value']) + return data + return data + [command['value']] + +def TestInsert(data, command, expected): + assertEquals(Insert(data, command), expected) + +doc = yaml.loadFile("insert.yml")[0] +for test in doc['tests']: + if not test.has_key('ignore'): + TestInsert(test['data'], test['command'], test['expected']) + + Index: /pyyaml-legacy/tags/PyYaml_0.32/query.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/query.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/query.py (revision 75) @@ -0,0 +1,66 @@ +import yaml +from test import assertEquals +import re + +def Query(query, doc): + results = [] + for row in yaml.ypath(query['from'],doc): + data = {} + if Where(row, query): + for field in query['select']: + data[field] = yaml.ypath(field,row).next() + if query.has_key('order'): + data['__row__'] = row + results.append(data) + return Order(results, query) + +def Where(row, query): + if query.has_key('where'): + where = query['where'] + return WhereRow(row, query['where']) + return 1 + +def WhereRow(row, where): + if type(where) == type([]): + return And(row, where, WhereRow) + if type(where) == type(''): + return WhereString(row, where) + return And(row, where.keys(), + lambda row, field: where[field] == row[field]) + +def And(row, conds, condFunc): + for cond in conds: + if not condFunc(row, cond): + return 0 + return 1 + +def WhereString(row, where): + where = re.sub("\[(.*?)\]", r"row['\1']", where) + return eval(where) + +def Order(results, query): + if not query.has_key('order'): + return results + compare = lambda x,y: Compare(x,y,query['order']) + results.sort(compare) + for result in results: + del result['__row__'] + return results + +def Compare(x, y, order): + for field in order: + val = cmp( + yaml.ypath(field,x['__row__']).next(), + yaml.ypath(field,y['__row__']).next() + ) + if val != 0: return val + +def TestQuery(query, expected, data): + assertEquals(Query(query, data), expected, query) + +doc = yaml.loadFile("query.yml").next() +for test in doc['tests']: + if not test.has_key('ignore'): + TestQuery(test['query'], test['expected'], doc['data']) + + Index: /pyyaml-legacy/tags/PyYaml_0.32/LIMITATIONS =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/LIMITATIONS (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/LIMITATIONS (revision 75) @@ -0,0 +1,38 @@ +PYTHON VERSION: > + PyYaml is developed with Python version 2.2. I can't live + without Python 2.2--too many great features. Please do + yourself a favor and upgrade now. I know the decision to + only support 2.2 and above may lock out some potential users, + but I believe it will pay dividends in the future, because + the version 2.2 features allow cleaner and more expressive + code. I do intend to support version 2.2 for a long time. + +DISCLAIMER: > + PyYaml is not ready to be used as a robust serialization tool, + although it is moving in that direction, and you can certainly + experiment with it. + + You can use it more safely for one-way applications. You can + make YAML be an input-tool only, such as for configuration files + or data-driven programs. You can also use YAML as an output-only + tool, for things like logging and debugging. + + You can report bugs to showell@zipcon.net. As of this writing + (August 2002), I am actively improving PyYaml. + + The interface for YAML is stabilizing, but it is too early in + the life cycle for me to guarantee backward compatibility in + future releases. I recommend wrapping your YAML calls in your + own methods, if you are concerned about changing interfaces. + The basic paradigm of load, loadFile, save, and saveFile + shouldn't change, but the way that you customize the loader + and parser's behavior may. + +SOME KNOWN BUGS/LIMITATIONS: + - folded scalars can't lead with blank line + - emitter gives invalid YAML for multi-line scalars starting w/whitespace + - trailing white space after quotes not ignored + - support for inlined hashes and arrays very primitize--can't nest + structures and must use simple scalars + - specifiers like !str, !int, etc. are ignored + Index: /pyyaml-legacy/tags/PyYaml_0.32/README =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/README (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/README (revision 75) @@ -0,0 +1,105 @@ +- Introductions: > + Hello. Welcome to the Python YAML parser. This is + a work in progress. The primary author is Steve Howell, + with a few contributions by Clark Evans. + +- installation: > + Simply type "make install" as root, this runs python setup.py install. + If you do not have distutils installed, you can simply copy the + yaml sub-directory into site-packages. + +- testing: > + You should be able to type "make test" both before and + after the installation. This simply runs python on the + test programs. + + This package uses python iterators, but there is a surrogate + which returns a list object instead of an iterator for python + versions below 2.2 + + This package should work with 1.5.2 and up, although many of + the tests fail with 1.5.2; if you are an expert with 1.5.2 + please help us patch this up so that it works on older versions + of Python. + +- playing: > + The best way to play, is to start with demo.py and + work from there. Note that this implementation has quite + a way to go before it is compliant with the YAML specification. + + If something is failing in the tests for your platform + please let us know. If something doesn't work, check the + tests to see if the test covering the feature you need is + active; if not, chances are it's not implemented. + + Your feedback or any other contributions are certainly welcome. + +- ypath: > + The YPATH implementation is EXPERIMENTAL but included + in the yaml package beacuse it is fun and we'd like to get + feedback from the user community as to how they'd like it + to work. It requries Python 2.2 since it uses iterators. + +- query: > + There is a query.py and query.yml file in this directory, + it is currently broke as ypath was re-written. + +--- +contributors: + - who: Steve Howell + why?: | + Original author of the pure Python implementations of the + YAML parser and emitter. Many thanks to the other folks + listed here, and some not listed here. + email: showell@zipcon.net + + - who: Brian Ingerson + why?: | + Brian got me hooked on YAML. We have used his Perl + implementation to do some really cool stuff, even on projects + that primarily used XML. He also got me started on + the Python project. + + - who: Clark Evans + why?: | + Clark's YAML fame far precedes the Python implementation--he + founded the whole project. But, he also contributed alias + emitting to this project, and he's also generously allowed + me to bundle his very cool YPATH implementation. Finally, + he's helped with module packaging issues and miscellaneous + features and bug fixes. + + - who: Why The Lucky Stiff + why?: | + That's right, Why's the name, Ruby's the game. Why devotes + most of his YAML effort to a Ruby implementation that grows + increasingly robust, but he's also a great team player on + the YAML project. For example, he consolidated the YAML + testing suites, so that multiple YAML implementations can + share the same YAML test files. If you look in this YAML + distribution, you will see Ruby all over the place. Think + of it as a free introduction to another great scripting + language. + + - who: Ryan King + why?: | + Sharpener of saws and pair programmer extraordinaire. + + - who: Neil Watkiss + why?: | + Donated hardware and major expertise to the project. + + - who: Oren Ben-Kiki + why?: | + YAML cofounder. All library implementors owe a huge gratitude + toward Oren for his work on the YAML spec. + + - who: Lion Kimbro + why?: | + Early adopter, also known for his three-humped YAML. + + - who: Dave Kuhlman + why?: | + Dave's contributions include, but are not limited to, the + XmlYaml code bundled with this distribution. The README + with that code talks more about Dave. Index: /pyyaml-legacy/tags/PyYaml_0.32/TestInlineTokenizer.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TestInlineTokenizer.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/TestInlineTokenizer.py (revision 75) @@ -0,0 +1,22 @@ +import YamlTest +from test import assertEquals +from yaml.load import * + + +class Test(YamlTest.YamlTest): + def testSimple(self): + tokenizer = InlineTokenizer('[ foo, bar ]') + assertEquals(tokenizer.next(), '[') + assertEquals(tokenizer.next(), 'foo') + assertEquals(tokenizer.next(), 'bar') + assertEquals(tokenizer.next(), ']') + + def testSimpleHash(self): + tokenizer = InlineTokenizer('{ foo: bar }') + assertEquals(tokenizer.next(), '{') + assertEquals(tokenizer.next(), 'foo: bar') # might change + assertEquals(tokenizer.next(), '}') + +if __name__ == '__main__': + import unittest + unittest.main() Index: /pyyaml-legacy/tags/PyYaml_0.32/yaml/implicit.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/yaml/implicit.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/yaml/implicit.py (revision 75) @@ -0,0 +1,46 @@ +import re +import string +from timestamp import timestamp, matchTime + +DATETIME_REGEX = re.compile("^[0-9]{4}-[0-9]{2}-[0-9]{2}$") +FLOAT_REGEX = re.compile("^[-+]?[0-9][0-9,]*\.[0-9]*$") +SCIENTIFIC_REGEX = re.compile("^[-+]?[0-9]+(\.[0-9]*)?[eE][-+][0-9]+$") +OCTAL_REGEX = re.compile("^[-+]?([0][0-7,]*)$") +HEX_REGEX = re.compile("^[-+]?0x[0-9a-fA-F,]+$") +INT_REGEX = re.compile("^[-+]?(0|[1-9][0-9,]*)$") + +def convertImplicit(val): + if val == '~': + return None + if val == '+': + return 1 + if val == '-': + return 0 + if val[0] == "'" and val[-1] == "'": + val = val[1:-1] + return string.replace(val, "''", "\'") + if val[0] == '"' and val[-1] == '"': + if re.search(r"\u", val): + val = "u" + val + unescapedStr = eval (val) + return unescapedStr + if matchTime.match(val): + return timestamp(val) + if INT_REGEX.match(val): + return int(cleanseNumber(val)) + if OCTAL_REGEX.match(val): + return int(val, 8) + if HEX_REGEX.match(val): + return int(val, 16) + if FLOAT_REGEX.match(val): + return float(cleanseNumber(val)) + if SCIENTIFIC_REGEX.match(val): + return float(cleanseNumber(val)) + return val + +def cleanseNumber(str): + if str[0] == '+': + str = str[1:] + str = string.replace(str,',','') + return str + Index: /pyyaml-legacy/tags/PyYaml_0.32/yaml/stream.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/yaml/stream.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/yaml/stream.py (revision 75) @@ -0,0 +1,193 @@ +import re +import string + +def indentLevel(line): + n = 0 + while n < len(line) and line[n] == ' ': + n = n + 1 + return n + +class LineNumberStream: + def __init__(self, filename=None): + self.curLine = 0 + self.filename = filename + + def get(self): + line = self.getLine() + self.curLine += 1 # used by subclass + if line: + line = noLineFeed(line) + return line + + def lastLineRead(self): + return self.curLine + +class FileStream(LineNumberStream): + def __init__(self, filename): + self.fp = open(filename) + LineNumberStream.__init__(self, filename) + + def getLine(self): + line = self.fp.readline() + if line == '': line = None + return line + +class StringStream(LineNumberStream): + def __init__(self, text): + self.lines = split(text) + self.numLines = len(self.lines) + LineNumberStream.__init__(self) + + def getLine(self): + if self.curLine < self.numLines: + return self.lines[self.curLine] + +def split(text): + lines = string.split(text, '\n') + if lines[-1] == '': + lines.pop() + return lines + +def eatNewLines(stream): + while 1: + line = stream.get() + if line is None or len(string.strip(line)): + return line + +COMMENT_LINE_REGEX = re.compile(R"\s*#") +def isComment(line): + return line is not None and COMMENT_LINE_REGEX.match(line) + +class CommentEater: + def __init__(self, stream): + self.stream = stream + self.peeked = 1 + self.line = eatNewLines(stream) + self.eatComments() + + def eatComments(self): + while isComment(self.line): + self.line = self.stream.get() + + def peek(self): + if self.peeked: + return self.line + self.peeked = 1 + self.line = self.stream.get() + self.eatComments() + return self.line + + def lastLineRead(self): + return self.stream.lastLineRead() + + def pop(self): + data = self.peek() + self.peeked = 0 + return data + +class NestedText: + def __init__(self, stream): + self.commentEater = CommentEater(stream) + self.reset() + + def lastLineRead(self): + return self.commentEater.lastLineRead() + + def reset(self): + self.indentLevel = 0 + self.oldIndents = [0] + + def peek(self): + nextLine = self.commentEater.peek() + if nextLine is not None: + if indentLevel(nextLine) >= self.indentLevel: + return nextLine[self.indentLevel:] + elif nextLine == '': + return '' + + def pop(self): + line = self.peek() + if line is None: + self.indentLevel = self.oldIndents.pop() + return + self.commentEater.pop() + return line + + def popNestedLines(self): + nextLine = self.peek() + if nextLine is None or nextLine == '' or nextLine[0] != ' ': + return [] + self.nestToNextLine() + lines = [] + while 1: + line = self.pop() + if line is None: + break + lines.append(line) + return lines + + def nestToNextLine(self): + line = self.commentEater.peek() + indentation = indentLevel(line) + if len(self.oldIndents) > 1 and indentation <= self.indentLevel: + self.error("Inadequate indentation", line) + self.setNewIndent(indentation) + + def nestBySpecificAmount(self, adjust): + self.setNewIndent(self.indentLevel + adjust) + + def setNewIndent(self, indentLevel): + self.oldIndents.append(self.indentLevel) + self.indentLevel = indentLevel + +class YamlLoaderException(Exception): + def __init__(self, *args): + (self.msg, self.lineNum, self.line, self.filename) = args + + def __str__(self): + msg = """\ +%(msg)s: +near line %(lineNum)d: +%(line)s +""" % self.__dict__ + if self.filename: + msg += "file: " + self.filename + return msg + +class NestedDocs(NestedText): + def __init__(self, stream): + self.filename = stream.filename + NestedText.__init__(self,stream) + line = NestedText.peek(self) + self.sep = '---' + if self.startsWithSep(line): + self.eatenDocSep = NestedText.pop(self) + else: + self.eatenDocSep = self.sep + + def startsWithSep(self,line): + if line and self.sep == line[:3]: return 1 + return 0 + + def popDocSep(self): + line = self.eatenDocSep + self.eatenDocSep = None + self.reset() + return line + + def pop(self): + if self.eatenDocSep is not None: + raise "error" + line = self.commentEater.peek() + if line and self.startsWithSep(line): + self.eatenDocSep = NestedText.pop(self) + return None + return NestedText.pop(self) + + def error(self, msg, line): + raise YamlLoaderException(msg, self.lastLineRead(), line, self.filename) + +def noLineFeed(s): + while s[-1:] in ('\n', '\r'): + s = s[:-1] + return s Index: /pyyaml-legacy/tags/PyYaml_0.32/yaml/redump.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/yaml/redump.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/yaml/redump.py (revision 75) @@ -0,0 +1,14 @@ +from yaml.ordered_dict import OrderedDict +from yaml import Parser, Dumper, StringStream + +def loadOrdered(stream): + parser = Parser(StringStream(stream)) + parser.dictionary = OrderedDict + return iter(parser) + +def redump(stream): + docs = list(loadOrdered(stream)) + dumper = Dumper() + dumper.alphaSort = 0 + return dumper.dump(*docs) + Index: /pyyaml-legacy/tags/PyYaml_0.32/yaml/klass.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/yaml/klass.py (revision 71) +++ /pyyaml-legacy/tags/PyYaml_0.32/yaml/klass.py (revision 71) @@ -0,0 +1,48 @@ +import new +import re + +class DefaultResolver: + def resolveType(self, data, typestring): + match = re.match('!!(.*?)\.(.*)', typestring) + if not match: + raise "Invalid private type specifier" + (modname, classname) = match.groups() + return makeClass(modname, classname, data) + +def makeClass(module, classname, dict): + exec('import %s' % (module)) + klass = eval('%s.%s' % (module, classname)) + obj = new.instance(klass) + if hasMethod(obj, 'from_yaml'): + return obj.from_yaml(dict) + obj.__dict__ = dict + return obj + +def hasMethod(object, method_name): + try: + klass = object.__class__ + except: + return 0 + if not hasattr(klass, method_name): + return 0 + method = getattr(klass, method_name) + if not callable(method): + return 0 + return 1 + +def isDictionary(data): + return isinstance(data, dict) + +try: + isDictionary({}) +except: + def isDictionary(data): return type(data) == type({}) # XXX python 2.1 + +if __name__ == '__main__': + print isDictionary({'foo': 'bar'}) + try: + print isDictionary(dict()) + from ordered_dict import OrderedDict + print isDictionary(OrderedDict()) + except: + pass Index: /pyyaml-legacy/tags/PyYaml_0.32/yaml/inline.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/yaml/inline.py (revision 71) +++ /pyyaml-legacy/tags/PyYaml_0.32/yaml/inline.py (revision 71) @@ -0,0 +1,38 @@ +import re +import string + +class InlineTokenizer: + def __init__(self, data): + self.data = data + + def punctuation(self): + puncts = [ '[', ']', '{', '}' ] + for punct in puncts: + if self.data[0] == punct: + self.data = self.data[1:] + return punct + + def up_to_comma(self): + match = re.match('(.*?)\s*, (.*)', self.data) + if match: + self.data = match.groups()[1] + return match.groups()[0] + + def up_to_end_brace(self): + match = re.match('(.*?)(\s*[\]}].*)', self.data) + if match: + self.data = match.groups()[1] + return match.groups()[0] + + def next(self): + self.data = string.strip(self.data) + productions = [ + self.punctuation, + self.up_to_comma, + self.up_to_end_brace + ] + for production in productions: + token = production() + if token: + return token + Index: /pyyaml-legacy/tags/PyYaml_0.32/yaml/__init__.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/yaml/__init__.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/yaml/__init__.py (revision 75) @@ -0,0 +1,17 @@ +__version__ = "0.32" +from load import loadFile, load, Parser, l +from dump import dump, dumpToFile, Dumper, d +from stream import YamlLoaderException, StringStream, FileStream +from timestamp import timestamp +import sys +if sys.hexversion >= 0x02020000: + from redump import loadOrdered + +try: + from ypath import ypath +except NameError: + def ypath(expr,target='',cntx=''): + raise NotImplementedError("ypath requires Python 2.2") + +if sys.hexversion < 0x02010000: + raise 'YAML is not tested for pre-2.1 versions of Python' Index: /pyyaml-legacy/tags/PyYaml_0.32/yaml/load.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/yaml/load.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/yaml/load.py (revision 75) @@ -0,0 +1,327 @@ +import re, string +from implicit import convertImplicit +from inline import InlineTokenizer +from yaml.klass import DefaultResolver +from yaml.stream import YamlLoaderException, FileStream, StringStream, NestedDocs + +try: + iter(list()) # is iter supported by this version of Python? +except: + # XXX - Python 2.1 does not support iterators + class StopIteration: pass + class iter: + def __init__(self,parser): + self._docs = [] + try: + while 1: + self._docs.append(parser.next()) + except StopIteration: pass + self._idx = 0 + def __len__(self): return len(self._docs) + def __getitem__(self,idx): return self._docs[idx] + def next(self): + if self._idx < len(self._docs): + ret = self._docs[self._idx] + self._idx = self._idx + 1 + return ret + raise StopIteration + +def loadFile(filename, typeResolver=None): + return loadStream(FileStream(filename),typeResolver) + +def load(str, typeResolver=None): + return loadStream(StringStream(str), typeResolver) + +def l(str): return load(str).next() + +def loadStream(stream, typeResolver): + return iter(Parser(stream, typeResolver)) + +def tryProductions(productions, value): + for production in productions: + results = production(value) + if results: + (ok, result) = results + if ok: + return (1, result) + +def dumpDictionary(): return {} + +class Parser: + def __init__(self, stream, typeResolver=None): + try: + self.dictionary = dict + except: + self.dictionary = dumpDictionary + self.nestedDocs = NestedDocs(stream) + self.aliases = {} + if typeResolver: + self.typeResolver = typeResolver + else: + self.typeResolver = DefaultResolver() + + def error(self, msg): + self.nestedDocs.error(msg, self.line) + + def nestPop(self): + line = self.nestedDocs.pop() + if line is not None: + self.line = line + return 1 + + def value(self, indicator): + return getToken(indicator+"\s*(.*)", self.line) + + def getNextDocument(self): raise "getNextDocument() deprecated--use next()" + + def next(self): + line = self.nestedDocs.popDocSep() + indicator = getIndicator(line) + if indicator: + return self.parse_value(indicator) + if line: + self.nestedDocs.nestToNextLine() + return self.parseLines() + raise StopIteration + + def __iter__(self): return self + + def parseLines(self): + peekLine = self.nestedDocs.peek() + if peekLine: + if re.match("\s*-", peekLine): + return self.parse_collection([], self.parse_seq_line) + else: + return self.parse_collection(self.dictionary(), self.parse_map_line) + raise StopIteration + + def parse_collection(self, items, lineParser): + while self.nestPop(): + if self.line: + lineParser(items) + return items + + def parse_seq_line(self, items): + value = self.value("-") + if value is not None: + items.append(self.parse_seq_value(value)) + else: + self.error("missing '-' for seq") + + def parse_map_line(self, items): + if (self.line == '?'): + self.parse_map_line_nested(items) + else: + self.parse_map_line_simple(items, self.line) + + def parse_map_line_nested(self, items): + self.nestedDocs.nestToNextLine() + key = self.parseLines() + if self.nestPop(): + value = self.value(':') + if value is not None: + items[tuple(key)] = self.parse_value(value) + return + self.error("key has no value for nested map") + + def parse_map_line_simple(self, items, line): + map_item = self.key_value(line) + if map_item: + (key, value) = map_item + key = convertImplicit(key) + if items.has_key(key): + self.error("Duplicate key "+key) + items[key] = self.parse_value(value) + else: + self.error("bad key for map") + + def is_map(self, value): + # XXX - need real tokenizer + if len(value) == 0: + return 0 + if value[0] == "'": + return 0 + if re.search(':(\s|$)', value): + return 1 + + def parse_seq_value(self, value): + if self.is_map(value): + return self.parse_compressed_map(value) + else: + return self.parse_value(value) + + def parse_compressed_map(self, value): + items = self.dictionary() + line = self.line + token = getToken("(\s*-\s*)", line) + self.nestedDocs.nestBySpecificAmount(len(token)) + self.parse_map_line_simple(items, value) + return self.parse_collection(items, self.parse_map_line) + + def parse_value(self, value): + (alias, value) = self.testForRepeatOfAlias(value) + if alias: + return value + (alias, value) = self.testForAlias(value) + value = self.parse_unaliased_value(value) + if alias: + self.aliases[alias] = value + return value + + def parse_unaliased_value(self, value): + match = re.match(r"(!\S*)(.*)", value) + if match: + (url, value) = match.groups() + value = self.parse_untyped_value(value) + if url[:2] == '!!': + return self.typeResolver.resolveType(value, url) + else: + # XXX - allows syntax, but ignores it + return value + return self.parse_untyped_value(value) + + def parseInlineArray(self, value): + if re.match("\s*\[", value): + return self.parseInline([], value, ']', + self.parseInlineArrayItem) + + def parseInlineHash(self, value): + if re.match("\s*{", value): + return self.parseInline(self.dictionary(), value, '}', + self.parseInlineHashItem) + + def parseInlineArrayItem(self, result, token): + return result.append(convertImplicit(token)) + + def parseInlineHashItem(self, result, token): + (key, value) = self.key_value(token) + result[key] = value + + def parseInline(self, result, value, end_marker, itemMethod): + tokenizer = InlineTokenizer(value) + tokenizer.next() + while 1: + token = tokenizer.next() + if token == end_marker: + break + itemMethod(result, token) + return (1, result) + + def parseSpecial(self, value): + productions = [ + self.parseMultiLineScalar, + self.parseInlineHash, + self.parseInlineArray, + ] + return tryProductions(productions, value) + + def parse_untyped_value(self, value): + parse = self.parseSpecial(value) + if parse: + (ok, data) = parse + return data + token = getToken("(\S.*)", value) + if token: + lines = [token] + \ + pruneTrailingEmpties(self.nestedDocs.popNestedLines()) + return convertImplicit(joinLines(lines)) + else: + self.nestedDocs.nestToNextLine() + return self.parseLines() + + def parseNative(self, value): + return (1, convertImplicit(value)) + + def parseMultiLineScalar(self, value): + if value == '>': + return (1, self.parseFolded()) + elif value == '|': + return (1, joinLiteral(self.parseBlock())) + elif value == '|+': + return (1, joinLiteral(self.unprunedBlock())) + + def parseFolded(self): + data = self.parseBlock() + i = 0 + resultString = '' + while i < len(data)-1: + resultString = resultString + data[i] + resultString = resultString + foldChar(data[i], data[i+1]) + i = i + 1 + return resultString + data[-1] + "\n" + + def unprunedBlock(self): + self.nestedDocs.nestToNextLine() + data = [] + while self.nestPop(): + data.append(self.line) + return data + + def parseBlock(self): + return pruneTrailingEmpties(self.unprunedBlock()) + + def testForAlias(self, value): + match = re.match("&(\S*)\s*(.*)", value) + if match: + return match.groups() + return (None, value) + + def testForRepeatOfAlias(self, value): + match = re.match("\*(\S+)", value) + if match: + alias = match.groups()[0] + if self.aliases.has_key(alias): + return (alias, self.aliases[alias]) + else: + self.error("Unknown alias") + return (None, value) + + def key_value(self, str): + if str[-1] == ' ': + self.error("Trailing spaces not allowed without quotes.") + # XXX This allows mis-balanced " vs. ' stuff + match = re.match("[\"'](.+)[\"']\s*:\s*(.*)", str) + if match: + (key, value) = match.groups() + return (key, value) + match = re.match("(.+?)\s*:\s*(.*)", str) + if match: + (key, value) = match.groups() + if len(value) and value[0] == '#': + value = '' + return (key, value) + +def getToken(regex, value): + match = re.search(regex, value) + if match: + return match.groups()[0] + +def pruneTrailingEmpties(data): + while len(data) > 0 and data[-1] == '': + data = data[:-1] + return data + +def foldChar(line1, line2): + if re.match("^\S", line1) and re.match("^\S", line2): + return " " + return "\n" + +def getIndicator(line): + if line: + header = r"(#YAML:\d+\.\d+\s*){0,1}" + match = re.match("--- "+header+"(\S*.*)", line) + if match: + return match.groups()[-1] + +def joinLines(lines): + result = '' + for line in lines[:-1]: + if line[-1] == '\\': + result = result + line[:-1] + else: + result = result + line + " " + return result + lines[-1] + +def joinLiteral(data): + return string.join(data,"\n") + "\n" + Index: /pyyaml-legacy/tags/PyYaml_0.32/yaml/timestamp.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/yaml/timestamp.py (revision 71) +++ /pyyaml-legacy/tags/PyYaml_0.32/yaml/timestamp.py (revision 71) @@ -0,0 +1,145 @@ +import time, re, string +from types import ListType, TupleType + +PRIVATE_NOTICE = """ + This module is considered to be private implementation + details and is subject to change. Please only use the + objects and methods exported to the top level yaml package. +""" + +# +# Time specific operations +# + +_splitTime = re.compile('\-|\s|T|t|:|\.|Z') +matchTime = re.compile(\ + '\d+-\d+-\d+([\s|T|t]\d+:\d+:\d+.\d+(Z|(\s?[\-|\+]\d+:\d+)))?') + +def _parseTime(val): + if not matchTime.match(val): raise ValueError(val) + tpl = _splitTime.split(val) + if not(tpl): raise ValueError(val) + siz = len(tpl) + sec = 0 + if 3 == siz: + tpl += [0,0,0,0,0,-1] + elif 7 == siz: + tpl.append(0) + tpl.append(-1) + elif 8 == siz: + if len(tpl.pop()) > 0: raise ValueError(val) + tpl.append(0) + tpl.append(-1) + elif 9 == siz or 10 == siz: + mn = int(tpl.pop()) + hr = int(tpl.pop()) + sec = (hr*60+mn)*60 + if val.find("+") > -1: sec = -sec + if 10 == siz: tpl.pop() + tpl.append(0) + tpl.append(-1) + else: + raise ValueError(val) + idx = 0 + while idx < 9: + tpl[idx] = int(tpl[idx]) + idx += 1 + if tpl[1] < 1 or tpl[1] > 12: raise ValueError(val) + if tpl[2] < 1 or tpl[2] > 31: raise ValueError(val) + if tpl[3] > 24: raise ValueError(val) + if tpl[4] > 61: raise ValueError(val) + if tpl[5] > 61: raise ValueError(val) + if tpl[0] > 2038: + #TODO: Truncation warning + tpl = (2038,1,18,0,0,0,0,0,-1) + tpl = tuple(tpl) + ret = time.mktime(tpl) + ret = time.localtime(ret+sec) + ret = ret[:8] + (0,) + return ret + + +class _timestamp: + def __init__(self,val=None): + if not val: + self.__tval = time.gmtime() + else: + typ = type(val) + if ListType == typ: + self.__tval = tuple(val) + elif TupleType == typ: + self.__tval = val + else: + self.__tval = _parseTime(val) + if 9 != len(self.__tval): raise ValueError + def __getitem__(self,idx): return self.__tval[idx] + def __len__(self): return 9 + def strftime(self,format): return time.strftime(format,self.__tval) + def mktime(self): return time.mktime(self.__tval) + def asctime(self): return time.asctime(self.__tval) + def isotime(self): + return "%04d-%02d-%02dT%02d:%02d:%02d.00Z" % self.__tval[:6] + def __repr__(self): return "yaml.timestamp('%s')" % self.isotime() + def __str__(self): return self.isotime() + def to_yaml_implicit(self): return self.isotime() + def __hash__(self): return hash(self.__tval[:6]) + def __cmp__(self,other): + try: + return cmp(self.__tval[:6],other.__tval[:6]) + except AttributeError: + return -1 + +try: # inherit from mx.DateTime functionality if available + from mx import DateTime + class timestamp(_timestamp): + def __init__(self,val=None): + _timestamp.__init__(self,val) + self.__mxdt = DateTime.mktime(self.__tval) + def __getattr__(self, name): + return getattr(self.__mxdt, name) +except: + class timestamp(_timestamp): pass + + + +def unquote(expr): + """ + summary: > + Simply returns the unquoted string, and the + length of the quoted string token at the + beginning of the expression. + """ + tok = expr[0] + if "'" == tok: + idx = 1 + odd = 0 + ret = "" + while idx < len(expr): + chr = expr[idx] + if "'" == chr: + if odd: ret += chr + odd = not odd + else: + if odd: + tok = expr[:idx] + break + ret += chr + idx += 1 + if "'" == tok: tok = expr + return (ret,len(tok)) + if '"' == tok: + idx = 1 + esc = 0 + while idx < len(expr): + chr = expr[idx] + if '"' == chr and not esc: + tok = expr[:idx] + '"' + break + if '\\' == chr and not esc: esc = 1 + else: esc = 0 + idx += 1 + if '"' == tok: + raise SyntaxError("unmatched quote: " + expr) + ret = eval(tok) #TODO: find better way to unquote + return (ret,len(tok)) + return (expr,len(expr)) Index: /pyyaml-legacy/tags/PyYaml_0.32/yaml/dump.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/yaml/dump.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/yaml/dump.py (revision 75) @@ -0,0 +1,296 @@ +import types +import string +from types import StringType, UnicodeType, IntType, FloatType +from types import DictType, ListType, TupleType, InstanceType +from yaml.klass import hasMethod, isDictionary +import re + +""" + The methods from this module that are exported to the top + level yaml package should remain stable. If you call + directly into other methods of this module, be aware that + they may change or go away in future implementations. + Contact the authors if there are methods in this file + that you wish to remain stable. +""" + +def dump(*data): + return Dumper().dump(*data) + +def d(data): return dump(data) + +def dumpToFile(file, *data): + return Dumper().dumpToFile(file, *data) + +class Dumper: + def __init__(self): + self.currIndent = "\n" + self.indent = " " + self.keysrt = None + self.alphaSort = 1 # legacy -- on by default + + def setIndent(self, indent): + self.indent = indent + return self + + def setSort(self, sort_hint): + self.keysrt = sortMethod(sort_hint) + return self + + def dump(self, *data): + self.result = [] + self.output = self.outputToString + self.dumpDocuments(data) + return string.join(self.result,"") + + def outputToString(self, data): + self.result.append(data) + + def dumpToFile(self, file, *data): + self.file = file + self.output = self.outputToFile + self.dumpDocuments(data) + + def outputToFile(self, data): + self.file.write(data) + + def dumpDocuments(self, data): + for obj in data: + self.anchors = YamlAnchors(obj) + self.output("---") + self.dumpData(obj) + self.output("\n") + + def indentDump(self, data): + oldIndent = self.currIndent + self.currIndent += self.indent + self.dumpData(data) + self.currIndent = oldIndent + + def dumpData(self, data): + anchor = self.anchors.shouldAnchor(data) + if anchor: + self.output(" &%d" % anchor ) + else: + anchor = self.anchors.isAlias(data) + if anchor: + self.output(" *%d" % anchor ) + return + if (data is None): + self.output(' ~') + elif hasMethod(data, 'to_yaml'): + self.dumpTransformedObject(data) + elif hasMethod(data, 'to_yaml_implicit'): + self.output(" " + data.to_yaml_implicit()) + elif type(data) is InstanceType: + self.dumpRawObject(data) + elif isDictionary(data): + self.dumpDict(data) + elif type(data) in [ListType, TupleType]: + self.dumpList(data) + else: + self.dumpScalar(data) + + def dumpTransformedObject(self, data): + obj_yaml = data.to_yaml() + if type(obj_yaml) is not TupleType: + self.raiseToYamlSyntaxError() + (data, typestring) = obj_yaml + if typestring: + self.output(" " + typestring) + self.dumpData(data) + + def dumpRawObject(self, data): + self.output(' !!%s.%s' % (data.__module__, data.__class__.__name__)) + self.dumpData(data.__dict__) + + def dumpDict(self, data): + keys = data.keys() + if len(keys) == 0: + self.output(" {}") + return + if self.keysrt: + keys = sort_keys(keys,self.keysrt) + else: + if self.alphaSort: + keys.sort() + for key in keys: + self.output(self.currIndent) + self.dumpKey(key) + self.output(":") + self.indentDump(data[key]) + + def dumpKey(self, key): + if type(key) is TupleType: + self.output("?") + self.indentDump(key) + self.output("\n") + else: + self.output(quote(key)) + + def dumpList(self, data): + if len(data) == 0: + self.output(" []") + return + for item in data: + self.output(self.currIndent) + self.output("-") + self.indentDump(item) + + def dumpScalar(self, data): + if isUnicode(data): + self.output(' "%s"' % repr(data)[2:-1]) + elif isMulti(data): + self.dumpMultiLineScalar(data.splitlines()) + else: + self.output(" ") + self.output(quote(data)) + + def dumpMultiLineScalar(self, lines): + self.output(" |") + if lines[-1] == "": + self.output("+") + for line in lines: + self.output(self.currIndent) + self.output(line) + + def raiseToYamlSyntaxError(self): + raise """ +to_yaml should return tuple w/object to dump +and optional YAML type. Example: +({'foo': 'bar'}, '!!foobar') +""" + +#### ANCHOR-RELATED METHODS + +def accumulate(obj,occur): + typ = type(obj) + if obj is None or \ + typ is IntType or \ + typ is FloatType or \ + ((typ is StringType or typ is UnicodeType) \ + and len(obj) < 32): return + obid = id(obj) + if 0 == occur.get(obid,0): + occur[obid] = 1 + if typ is ListType: + for x in obj: + accumulate(x,occur) + if typ is DictType: + for (x,y) in obj.items(): + accumulate(x,occur) + accumulate(y,occur) + else: + occur[obid] = occur[obid] + 1 + +class YamlAnchors: + def __init__(self,data): + occur = {} + accumulate(data,occur) + anchorVisits = {} + for (obid, occur) in occur.items(): + if occur > 1: + anchorVisits[obid] = 0 + self._anchorVisits = anchorVisits + self._currentAliasIndex = 0 + def shouldAnchor(self,obj): + ret = self._anchorVisits.get(id(obj),None) + if 0 == ret: + self._currentAliasIndex = self._currentAliasIndex + 1 + ret = self._currentAliasIndex + self._anchorVisits[id(obj)] = ret + return ret + return 0 + def isAlias(self,obj): + return self._anchorVisits.get(id(obj),0) + +### SORTING METHODS + +def sort_keys(keys,fn): + tmp = [] + for key in keys: + val = fn(key) + if val is None: val = '~' + tmp.append((val,key)) + tmp.sort() + return [ y for (x,y) in tmp ] + +def sortMethod(sort_hint): + typ = type(sort_hint) + if DictType == typ: + return sort_hint.get + elif ListType == typ or TupleType == typ: + indexes = {}; idx = 0 + for item in sort_hint: + indexes[item] = idx + idx += 1 + return indexes.get + else: + return sort_hint + +### STRING QUOTING AND SCALAR HANDLING +def isStr(data): + # XXX 2.1 madness + if type(data) == type(''): + return 1 + if type(data) == type(u''): + return 1 + return 0 + +def doubleUpQuotes(data): + return data.replace("'", "''") + +def quote(data): + if not isStr(data): + return str(data) + single = "'" + double = '"' + quote = '' + if len(data) == 0: + return "''" + if hasSpecialChar(data) or data[0] == single: + data = `data`[1:-1] + data = string.replace(data, r"\x08", r"\b") + quote = double + elif needsSingleQuote(data): + quote = single + data = doubleUpQuotes(data) + return "%s%s%s" % (quote, data, quote) + +def needsSingleQuote(data): + if re.match(r"^-?\d", data): + return 1 + if re.match(r"\*\S", data): + return 1 + if data[0] in ['&', ' ']: + return 1 + if data[0] == '"': + return 1 + if data[-1] == ' ': + return 1 + return (re.search(r'[:]', data) or re.search(r'(\d\.){2}', data)) + +def hasSpecialChar(data): + # need test to drive out '#' from this + return re.search(r'[\t\b\r\f#]', data) + +def isMulti(data): + if not isStr(data): + return 0 + if hasSpecialChar(data): + return 0 + return re.search("\n", data) + +def isUnicode(data): + return type(data) == unicode + +def sloppyIsUnicode(data): + # XXX - hack to make tests pass for 2.1 + return repr(data)[:2] == "u'" and repr(data) != data + +import sys +if sys.hexversion < 0x20200000: + isUnicode = sloppyIsUnicode + + + Index: /pyyaml-legacy/tags/PyYaml_0.32/yaml/ypath.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/yaml/ypath.py (revision 71) +++ /pyyaml-legacy/tags/PyYaml_0.32/yaml/ypath.py (revision 71) @@ -0,0 +1,462 @@ +from types import ListType, StringType, IntType, DictType, InstanceType +import re +from urllib import quote +from timestamp import unquote + +noTarget = object() + +def escape(node): + """ + summary: > + This function escapes a given key so that it + may appear within a ypath. URI style escaping + is used so that ypath expressions can be a + valid URI expression. + """ + typ = type(node) + if typ is IntType: return str(node) + if typ is StringType: + return quote(node,'') + raise ValueError("TODO: Support more than just string and integer keys.") + +class context: + """ + summary: > + A ypath visit context through a YAML rooted graph. + This is implemented as a 3-tuple including the parent + node, the current key/index and the value. This is + an immutable object so it can be cached. + properties: + key: mapping key or index within the parent collection + value: current value within the parent's range + parent: the parent context + root: the very top of the yaml graph + path: a tuple of the domain keys + notes: > + The context class doesn't yet handle going down the + domain side of the tree... + """ + def __init__(self,parent,key,value): + """ + args: + parent: parent context (or None if this is the root) + key: mapping key or index for this context + value: value of current location... + """ + self.parent = parent + self.key = key + self.value = value + if parent: + assert parent.__class__ is self.__class__ + self.path = parent.path + (escape(key),) + self.root = parent.root + else: + assert not key + self.path = tuple() + self.root = self + def __setattr__(self,attname,attval): + if attname in ('parent','key','value'): + if self.__dict__.get(attname): + raise ValueError("context is read-only") + self.__dict__[attname] = attval + def __hash__(self): return hash(self.path) + def __cmp__(self,other): + try: + return cmp(self.path,other.path) + except AttributeError: + return -1 + def __str__(self): + if self.path: + return "/".join(('',)+self.path) + else: + return '/' + +def to_context(target): + if type(target) is InstanceType: + if target.__class__ is context: + return target + return context(None,None,target) + +def context_test(): + lst = ['value'] + map = {'key':lst} + x = context(None,None,map) + y = context(x,'key',lst) + z = context(y,0,'value') + assert ('key',) == y.path + assert 'key' == y.key + assert lst == y.value + assert x == y.parent + assert x == y.root + assert 0 == z.key + assert 'value' == z.value + assert y == z.parent + assert x == z.root + assert hash(x) + assert hash(y) + assert hash(z) + assert '/' == str(x) + assert '/key' == str(y) + assert '/key/0' == str(z) + +class null_seg: + """ + summary: > + This is the simplest path segment, it + doesn't return any results and doesn't + depend upon its context. It also happens to + be the base class which all segments derive. + """ + def __iter__(self): + return self + def next_null(self): + raise StopIteration + def bind(self,cntx): + """ + summary: > + The bind function is called whenever + the parent context has changed. + """ + assert(cntx.__class__ is context) + self.cntx = cntx + def apply(self,target): + self.bind(to_context(target)) + return iter(self) + def exists(self,cntx): + try: + self.bind(cntx) + self.next() + return 1 + except StopIteration: + return 0 + next = next_null + +class self_seg(null_seg): + """ + summary: > + This path segment returns the context + node exactly once. + """ + def __str__(self): return '.' + def next_self(self): + self.next = self.next_null + return self.cntx + def bind(self,cntx): + null_seg.bind(self,cntx) + self.next = self.next_self + +class root_seg(self_seg): + def __str__(self): return '/' + def bind(self,cntx): + self_seg.bind(self,cntx.root) + +class parent_seg(self_seg): + def __str__(self): return '..' + def bind(self,cntx): + if cntx.parent: cntx = cntx.parent + self_seg.bind(self,cntx) + +class wild_seg(null_seg): + """ + summary: > + The wild segment simply loops through + all of the sub-contexts for a given object. + If there aren't any children, this isn't an + error it just doesn't return anything. + """ + def __str__(self): return '*' + def next_wild(self): + key = self.keys.next() + return context(self.cntx,key,self.values[key]) + def bind(self,cntx): + null_seg.bind(self,cntx) + typ = type(cntx.value) + if typ is ListType: + self.keys = iter(xrange(0,len(cntx.value))) + self.values = cntx.value + self.next = self.next_wild + return + if typ is DictType: + self.keys = iter(cntx.value) + self.values = cntx.value + self.next = self.next_wild + return + self.next = self.next_null + +class trav_seg(null_seg): + """ + summary: > + This is a recursive traversal of the range, preorder. + It is a recursive combination of self and wild. + """ + def __str__(self): return '/' + def next(self): + while 1: + (cntx,seg) = self.stk[-1] + if not seg: + seg = wild_seg() + seg.bind(cntx) + self.stk[-1] = (cntx,seg) + return cntx + try: + cntx = seg.next() + self.stk.append((cntx,None)) + except StopIteration: + self.stk.pop() + if not(self.stk): + self.next = self.next_null + raise StopIteration + + def bind(self,cntx): + null_seg.bind(self,cntx) + self.stk = [(cntx,None)] + +class match_seg(self_seg): + """ + summary: > + Matches a particular key within the + current context. Kinda boring. + """ + def __str__(self): return str(self.key) + def __init__(self,key): + #TODO: Do better implicit typing + try: + key = int(key) + except: pass + self.key = key + def bind(self,cntx): + try: + mtch = cntx.value[self.key] + cntx = context(cntx,self.key,mtch) + self_seg.bind(self,cntx) + except: + null_seg.bind(self,cntx) + +class conn_seg(null_seg): + """ + summary: > + When two segments are connected via a slash, + this is a composite. For each context of the + parent, it binds the child, and returns each + context of the child. + """ + def __str__(self): + if self.parent.__class__ == root_seg: + return "/%s" % self.child + return "%s/%s" % (self.parent, self.child) + def __init__(self,parent,child): + self.parent = parent + self.child = child + def next(self): + while 1: + try: + return self.child.next() + except StopIteration: + cntx = self.parent.next() + self.child.bind(cntx) + + def bind(self,cntx): + null_seg.bind(self,cntx) + self.parent.bind(cntx) + try: + cntx = self.parent.next() + except StopIteration: + return + self.child.bind(cntx) + + +class pred_seg(null_seg): + def __str__(self): return "%s[%s]" % (self.parent, self.filter) + def __init__(self,parent,filter): + self.parent = parent + self.filter = filter + def next(self): + while 1: + ret = self.parent.next() + if self.filter.exists(ret): + return ret + def bind(self,cntx): + null_seg.bind(self,cntx) + self.parent.bind(cntx) + +class or_seg(null_seg): + def __str__(self): return "%s|%s" % (self.lhs,self.rhs) + def __init__(self,lhs,rhs): + self.rhs = rhs + self.lhs = lhs + self.unq = {} + def next(self): + seg = self.lhs + try: + nxt = seg.next() + self.unq[nxt] = nxt + return nxt + except StopIteration: pass + seg = self.rhs + while 1: + nxt = seg.next() + if self.unq.get(nxt,None): + continue + return nxt + def bind(self,cntx): + null_seg.bind(self,cntx) + self.lhs.bind(cntx) + self.rhs.bind(cntx) + +class scalar: + def __init__(self,val): + self.val = val + def __str__(self): + return str(self.val) + def value(self): + return self.val + +class equal_pred: + def exists_true(self,cntx): return 1 + def exists_false(self,cntx): return 0 + def exists_scalar(self,cntx): + self.rhs.bind(cntx) + try: + while 1: + cntx = self.rhs.next() + if str(cntx.value) == self.lhs: #TODO: Remove type hack + return 1 + except StopIteration: pass + return 0 + def exists_segment(self,cntx): + raise NotImplementedError() + def __init__(self,lhs,rhs): + if lhs.__class__ == scalar: + if rhs.__class__ == scalar: + if rhs.value() == lhs.value(): + self.exists = self.exists_true + else: + self.exists = self.exists_false + else: + self.exists = self.exists_scalar + else: + if rhs.__class__ == scalar: + (lhs,rhs) = (rhs,lhs) + self.exists = self.exists_scalar + else: + self.exists = self.exists_segment + self.lhs = str(lhs.value()) #TODO: Remove type hack + self.rhs = rhs + +matchSegment = re.compile(r"""^(\w+|/|\.|\*|\"|\')""") + +def parse_segment(expr): + """ + Segments occur between the slashes... + """ + mtch = matchSegment.search(expr) + if not(mtch): return (None,expr) + tok = mtch.group(); siz = len(tok) + if '/' == tok: return (trav_seg(),expr) + elif '.' == tok: + if len(expr) > 1 and '.' == expr[1]: + seg = parent_seg() + siz = 2 + else: + seg = self_seg() + elif '*' == tok: seg = wild_seg() + elif '"' == tok or "'" == tok: + (cur,siz) = unquote(expr) + seg = match_seg(cur) + else: + seg = match_seg(tok) + return (seg,expr[siz:]) + +matchTerm = re.compile(r"""^(\w+|/|\.|\(|\"|\')""") + +def parse_term(expr): + mtch = matchTerm.search(expr) + if not(mtch): return (None,expr) + tok = mtch.group(); siz = len(tok) + if '/' == tok or '.' == tok: + return parse(expr) + if '(' == tok: + (term,expr) = parse_predicate(expr) + assert ')' == expr[0] + return (term,expr[1:]) + elif '"' == tok or "'" == tok: + (val,siz) = unquote(expr) + else: + val = tok; siz = len(tok) + return (scalar(val),expr[siz:]) + +def parse_predicate(expr): + (term,expr) = parse_term(expr) + if not term: raise SyntaxError("term expected: '%s'" % expr) + tok = expr[0] + if '=' == tok: + (rhs,expr) = parse_term(expr[1:]) + return (equal_pred(term,rhs),expr) + if '(' == tok: + raise "No functions allowed... yet!" + if ']' == tok or ')' == tok: + if term.__class__ is scalar: + term = match_seg(str(term)) + return (term,expr) + raise SyntaxError("ypath: expecting operator '%s'" % expr) + +def parse_start(expr): + """ + Initial checking on the expression, and + determine if it is relative or absolute. + """ + if type(expr) != StringType or len(expr) < 1: + raise TypeError("string required: " + repr(expr)) + if '/' == expr[0]: + ypth = root_seg() + else: + ypth = self_seg() + expr = '/' + expr + return (ypth,expr) + +def parse(expr): + """ + This the parser entry point, the top level node + is always a root or self segment. The self isn't + strictly necessary, but it keeps things simple. + """ + (ypth,expr) = parse_start(expr) + while expr: + tok = expr[0] + if '/' == tok: + (child, expr) = parse_segment(expr[1:]) + if child: ypth = conn_seg(ypth,child) + continue + if '[' == tok: + (filter, expr) = parse_predicate(expr[1:]) + assert ']' == expr[0] + expr = expr[1:] + ypth = pred_seg(ypth,filter) + continue + if '|' == tok: + (rhs, expr) = parse(expr[1:]) + ypth = or_seg(ypth,rhs) + continue + if '(' == tok: + (child,expr) = parse(expr[1:]) + assert ')' == expr[0] + expr = expr[1:] + ypth = conn_seg(ypth,child) + continue + break + return (ypth,expr) + +class convert_to_value(null_seg): + def __init__(self,itr): + self.itr = itr + def next(self): + return self.itr.next().value + def bind(self,cntx): + self.itr.bind(cntx) + +def ypath(expr,target=noTarget,cntx=0): + (ret,expr) = parse(expr) + if expr: raise SyntaxError("ypath parse error `%s`" % expr) + if not cntx: ret = convert_to_value(ret) + if target is noTarget: return ret + return ret.apply(target) Index: /pyyaml-legacy/tags/PyYaml_0.32/yaml/ordered_dict.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/yaml/ordered_dict.py (revision 71) +++ /pyyaml-legacy/tags/PyYaml_0.32/yaml/ordered_dict.py (revision 71) @@ -0,0 +1,31 @@ +# This is extremely crude implementation of an OrderedDict. +# If you know of a better implementation, please send it to +# the author Steve Howell. You can find my email via +# the YAML mailing list or wiki. + +class OrderedDict(dict): + def __init__(self): + self._keys = [] + + def __setitem__(self, key, val): + self._keys.append(key) + dict.__setitem__(self, key, val) + + def keys(self): + return self._keys + + def items(self): + return [(key, self[key]) for key in self._keys] + +if __name__ == '__main__': + data = OrderedDict() + data['z'] = 26 + data['m'] = 13 + data['a'] = 1 + for key in data.keys(): + print "The value for %s is %s" % (key, data[key]) + print data + + + + Index: /pyyaml-legacy/tags/PyYaml_0.32/insert.yml =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/insert.yml (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/insert.yml (revision 75) @@ -0,0 +1,72 @@ +tests: + - data: + - foo + - bar + command: + value: baz + expected: + - foo + - bar + - baz + - data: + - apple + - banana + command: + value: carrot + expected: + - apple + - banana + - carrot + - + data: + - foo + command: + value: + name: steve + sport: hoops + expected: + - foo + - name: steve + sport: hoops + - + data: + persons: + - name: steve + - name: clark + tasks: + - task: eat + - task: sleep + command: + ypath: /persons + value: + name: brian + expected: + persons: + - name: steve + - name: clark + - name: brian + tasks: + - task: eat + - task: sleep + - + data: + folks: + - name: steve + - name: clark + tasks: + - task: eat + - task: sleep + command: + ypath: /folks + value: + name: ryan + expected: + folks: + - name: steve + - name: clark + - name: ryan + tasks: + - task: eat + - task: sleep + + Index: /pyyaml-legacy/tags/PyYaml_0.32/profile.out =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/profile.out (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/profile.out (revision 75) @@ -0,0 +1,36 @@ +['Profile', 'Stats', '__all__', '__builtins__', '__doc__', '__file__', '__name__', '_get_time_times', 'help', 'marshal', 'os', 'run', 'sys', 'time'] +Wed Sep 25 08:59:14 2002 profileResults + + 93074 function calls (91948 primitive calls) in 8.740 CPU seconds + + Ordered by: internal time + List reduced from 134 to 25 due to restriction <25> + + ncalls tottime percall cumtime percall filename:lineno(function) + 12179 0.727 0.000 1.967 0.000 yaml\stream.py:65(peek) + 3747 0.672 0.000 3.529 0.001 yaml\stream.py:156(pop) + 6176 0.664 0.000 1.082 0.000 C:\PYTHON22\lib\sre.py:129(match) + 4551 0.578 0.000 1.196 0.000 yaml\stream.py:93(peek) + 3772 0.457 0.000 1.554 0.000 yaml\stream.py:101(pop) + 3324 0.408 0.000 0.764 0.000 yaml\stream.py:14(get) + 3727 0.326 0.000 3.837 0.001 yaml\load.py:75(nestPop) + 7018 0.319 0.000 0.509 0.000 C:\PYTHON22\lib\sre.py:215(_compile) + 3266 0.292 0.000 0.519 0.000 yaml\stream.py:61(eatComments) + 5137 0.282 0.000 0.282 0.000 yaml\stream.py:4(indentLevel) + 3206 0.234 0.000 0.331 0.000 yaml\stream.py:76(pop) + 380 0.233 0.001 3.412 0.009 yaml\load.py:257(parseBlock) + 914/731 0.214 0.000 5.739 0.008 yaml\load.py:221(parse_untyped_value) + 3324 0.214 0.000 0.214 0.000 yaml\stream.py:51(isComment) + 2999 0.183 0.000 0.183 0.000 yaml\stream.py:29(getLine) + 917/733 0.166 0.000 6.457 0.009 yaml\load.py:164(parse_value) + 3216 0.163 0.000 0.163 0.000 yaml\stream.py:169(noLineFeed) + 3528 0.152 0.000 0.152 0.000 yaml\stream.py:146(startsWithSep) + 1235 0.148 0.000 0.167 0.000 yaml\implicit.py:12(convertImplicit) + 793/697 0.148 0.000 6.731 0.010 yaml\load.py:132(parse_map_line_simple) + 675 0.139 0.000 0.543 0.001 yaml\stream.py:122(nestToNextLine) + 795 0.136 0.000 0.419 0.001 yaml\load.py:285(key_value) + 914 0.131 0.000 4.038 0.004 yaml\load.py:55(tryProductions) + 914/731 0.124 0.000 5.958 0.008 yaml\load.py:174(parse_unaliased_value) + 318/190 0.113 0.000 7.956 0.042 yaml\load.py:103(parse_collection) + + Index: /pyyaml-legacy/tags/PyYaml_0.32/IncludeHack/doc1.yml =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/IncludeHack/doc1.yml (revision 71) +++ /pyyaml-legacy/tags/PyYaml_0.32/IncludeHack/doc1.yml (revision 71) @@ -0,0 +1,1 @@ +foo: bar Index: /pyyaml-legacy/tags/PyYaml_0.32/IncludeHack/doc2.yml =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/IncludeHack/doc2.yml (revision 71) +++ /pyyaml-legacy/tags/PyYaml_0.32/IncludeHack/doc2.yml (revision 71) @@ -0,0 +1,1 @@ +more: stuff Index: /pyyaml-legacy/tags/PyYaml_0.32/IncludeHack/toplevel.yml =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/IncludeHack/toplevel.yml (revision 71) +++ /pyyaml-legacy/tags/PyYaml_0.32/IncludeHack/toplevel.yml (revision 71) @@ -0,0 +1,4 @@ + + - doc1: !!include doc1.yml + - doc2: !!include doc2.yml + Index: /pyyaml-legacy/tags/PyYaml_0.32/IncludeHack/demo.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/IncludeHack/demo.py (revision 71) +++ /pyyaml-legacy/tags/PyYaml_0.32/IncludeHack/demo.py (revision 71) @@ -0,0 +1,19 @@ +import yaml + +def writeFile(fn, data): + f = open(fn, 'w') + f.write(data) + +writeFile('toplevel.yml', """ + - doc1: !!include doc1.yml + - doc2: !!include doc2.yml + """) + +writeFile('doc1.yml', "foo: bar") +writeFile('doc2.yml', "more: stuff") + +class Includer: + def resolveType(self, value, url): + return yaml.loadFile(value).next() + +print yaml.loadFile('toplevel.yml', Includer()).next() Index: /pyyaml-legacy/tags/PyYaml_0.32/TestNestedText.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TestNestedText.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/TestNestedText.py (revision 75) @@ -0,0 +1,311 @@ +import YamlTest +from yaml.load import * +from here import flushLeft +from test import assertEquals +from yaml.stream import NestedText, CommentEater, split + +here = flushLeft # pardon the Perlism + +def stringStream(str): + return StringStream(here(str)) + +def commentEater(str): + return CommentEater(stringStream(str)) + +def nestedText(str): + return NestedText(stringStream(str)) + +def nestedDocs(str): + return NestedDocs(stringStream(str)) + +class Test(YamlTest.YamlTest): + def tryPop(self, expected): + assertEquals(self.nt.pop(), expected) + + def tryPopNestedLines(self, expected): + assertEquals(self.nt.popNestedLines(), expected) + + def tryPeek(self, expected): + assertEquals(self.nt.peek(), expected) + + def test1(self): + self.nt = nestedText( + """ + 1a + 2a + 2b + 3a + 2c + 1b + """) + self.tryPop('1a') + self.nt.nestToNextLine() + self.tryPop('2a') + self.tryPop('2b') + self.nt.nestToNextLine() + self.tryPop('3a') + self.tryPop(None) + self.tryPop('2c') + self.tryPop(None) + self.tryPeek('1b') + self.tryPop('1b') + self.tryPop('') + self.tryPop(None) + + def test2(self): + self.nt = nestedText(""" + apple + banana + foo + """) + self.tryPop('apple') + self.nt.nestToNextLine() + self.tryPop('banana') + self.nt.nestBySpecificAmount(2) + self.tryPop(' foo') + + def test3(self): + self.nt = nestedDocs(""" + seattle + --- foo + bluffton + """) + assertEquals(self.nt.popDocSep(), '---') + self.tryPop('seattle') + self.tryPop(None) + assertEquals(self.nt.popDocSep(), '--- foo') + self.tryPop('bluffton') + self.tryPop(None) + + def testEatComments(self): + self.nt = commentEater(""" + # ignore + # these + silly + """) + self.tryPop('silly') + + def testNestedDocsEatComments(self): + self.nt = nestedDocs(""" + # foo + # bar + --- + shabazz + """) + self.nt.popDocSep() + self.tryPop('shabazz') + assertEquals(self.nt.lastLineRead(), 4) + + def testNestedTextEatNewline(self): + self.nt = nestedDocs(""" + + --- + shabazz + """) + self.nt.popDocSep() + self.tryPop('shabazz') + + def testDocSep(self): + data = here(""" + --- city + seattle + --- town + bluffton + """) + self.nt = NestedDocs(StringStream(data)) + assertEquals(self.nt.popDocSep(), '--- city') + self.tryPop('seattle') + self.tryPop(None) + assertEquals(self.nt.popDocSep(), '--- town') + self.tryPop('bluffton') + self.tryPop(None) + + data = here(""" + # comments at top + # should be ignored + """) + data + self.nt = NestedDocs(StringStream(data)) + assertEquals(self.nt.popDocSep(), '--- city') + self.tryPop('seattle') + + def testNestedComments(self): + self.nt = nestedText(""" + apple + # ignore this comment + banana + foo + """) + self.tryPop('apple') + self.nt.nestToNextLine() + self.tryPop('banana') + self.nt.nestBySpecificAmount(2) + self.tryPop(' foo') + + def testStream(self): + stream = StringStream(here(""" + python + perl + java + """)) + assertEquals(stream.get(), "python") + assertEquals(stream.get(), "perl") + assertEquals(stream.get(), "java") + + def test1(self): + self.nt = nestedText( + """ + 1a + 2a + 2b + 3a + 2c + 1b + """) + self.tryPop('1a') + self.nt.nestToNextLine() + self.tryPop('2a') + self.tryPop('2b') + self.nt.nestToNextLine() + self.tryPop('3a') + self.tryPop(None) + self.tryPop('2c') + self.tryPop(None) + self.tryPeek('1b') + self.tryPop('1b') + self.tryPop(None) + + def XXXtestEmptyLines(self): + # not sure if this is valid test any more + self.nt = nestedDocs(""" + --- + apple + + banana + """) + self.nt.popDocSep() + self.nt.nestToNextLine() + self.tryPop('apple') + self.nt.nestToNextLine() + self.tryPop('') + self.nt.nestToNextLine() + self.tryPop('banana') + + def testFoldedCase(self): + self.nt = nestedText( + """ + --- + Aaa + Bbb + + 11 + 22 + + Ccc + """) + self.nt.pop() + self.nt.nestToNextLine() + self.tryPop('Aaa') + self.tryPop('Bbb') + self.tryPop('') + + def testRedHerringDocSep(self): + self.nt = nestedDocs( + """ + --- + foo: + --- + """) + self.nt.popDocSep() + self.tryPop('foo:') + self.nt.nestToNextLine() + self.tryPop('---') + + def testGetToNextIndent(self): + self.nt = nestedText( + """ + --- + line1: this is + continued + line2 + """) + self.nt.pop() + self.nt.nestToNextLine() + self.tryPop('line1: this is') + self.tryPopNestedLines(['continued']) + self.tryPop('line2') + + def testGetToNextIndent(self): + self.nt = nestedText( + """ + --- + key1: this is + continued + with multiple lines + key2: + key2a: + hello + world + key3: + """) + self.nt.pop() + self.nt.nestToNextLine() + self.tryPop('key1: this is') + self.tryPopNestedLines(['continued', 'with multiple lines']) + self.tryPop('key2:') + self.nt.nestToNextLine() + self.tryPop('key2a:') + self.tryPopNestedLines(['hello', 'world']) + + def testPopNestedLinesWithNoneNested(self): + self.nt = nestedText( + """ + --- + - apple + - banana + - carrot + """) + self.nt.pop() + self.nt.nestToNextLine() + self.tryPop('- apple') + self.tryPopNestedLines([]) + self.tryPop('- banana') + + def testLineNumbers(self): + data = \ + """ + one + two + # + three + """ + stream = StringStream(here(data)) + stream.get() + assertEquals(stream.lastLineRead(), 1) + stream.get() + assertEquals(stream.lastLineRead(), 2) + nt = nestedText(data) + nt.pop() + assertEquals(nt.lastLineRead(), 1) + nt.pop() + assertEquals(nt.lastLineRead(), 2) + nt.pop() # eats a comment too + assertEquals(nt.lastLineRead(), 4) + + def testSplit(self): + assertEquals(split("foo\nbar"), ['foo', 'bar']) + assertEquals(split("foo\nbar\n"), ['foo', 'bar']) + + def testLoaderException(self): + import yaml + from yaml.stream import YamlLoaderException + exception = None + try: + yaml.load('invalid YAML').next() + except YamlLoaderException, e: + exception = e + assertEquals(exception.lineNum, 1) + + +if __name__ == '__main__': + import unittest + unittest.main() Index: /pyyaml-legacy/tags/PyYaml_0.32/TestFileNamesInErrors.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TestFileNamesInErrors.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/TestFileNamesInErrors.py (revision 75) @@ -0,0 +1,8 @@ +#!/usr/bin/env python +import yaml, re +try: + print yaml.loadFile('TestFileNamesInErrors.py').next() + raise "YAML actually parsed this file, uh oh!" +except Exception, e: + if not re.search('TestFileNamesInErrors\.py', str(e)): + raise 'YAML not reporting filename properly ("%s")' % e Index: /pyyaml-legacy/tags/PyYaml_0.32/LICENSE =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/LICENSE (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/LICENSE (revision 75) @@ -0,0 +1,71 @@ +A. HISTORY OF THE SOFTWARE +========================== + +The Python library for YAML was started by Steve Howell in +February 2002. Steve is the primary author of the project, +but others have contributed. See the README for more on +the project. The term "PyYaml" refers to the entire +distribution of this library, including examples, documentation, +and test files, as well as the core implementation. + +This library is intended for general use, and the license +below protects the "open source" nature of the library. The +license does, however, allow for use of the library in +commercial applications as well, subject to the terms +and conditions listed. The license below is a minor +rewrite of the Python 2.2 license, with no substantive +differences. + + +B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PyYaml +=============================================================== + +LICENSE AGREEMENT FOR PyYaml +---------------------------- + +1. This LICENSE AGREEMENT is between Stephen S. Howell ("Author"), +and the Individual or Organization ("Licensee") accessing and +otherwise using PyYaml software in source or binary form and its +associated documentation. + +2. Subject to the terms and conditions of this License Agreement, Author +hereby grants Licensee a nonexclusive, royalty-free, world-wide +license to reproduce, analyze, test, perform and/or display publicly, +prepare derivative works, distribute, and otherwise use PyYaml +alone or in any derivative version, provided, however, that Author's +License Agreement and Author's notice of copyright, i.e., "Copyright (c) +2001 Steve Howell and Friends; All Rights Reserved" are never removed +from PyYaml, and are included in any derivative version prepared by Licensee. + +3. In the event Licensee prepares a derivative work that is based on +or incorporates PyYaml or any part thereof, and wants to make +the derivative work available to others as provided herein, then +Licensee hereby agrees to include in any such work a brief summary of +the changes made to PyYaml. + +4. Author is making PyYaml available to Licensee on an "AS IS" +basis. Author MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR +IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, Author MAKES NO AND +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PyYaml WILL NOT +INFRINGE ANY THIRD PARTY RIGHTS. + +5. Author SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON +2.2 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS +A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 2.2, +OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + +6. This License Agreement will automatically terminate upon a material +breach of its terms and conditions. + +7. Nothing in this License Agreement shall be deemed to create any +relationship of agency, partnership, or joint venture between Author and +Licensee. This License Agreement does not grant permission to use Author +trademarks or trade name in a trademark sense to endorse or promote +products or services of Licensee, or any third party. + +8. By copying, installing or otherwise using PyYaml, Licensee +agrees to be bound by the terms and conditions of this License +Agreement. + + Index: /pyyaml-legacy/tags/PyYaml_0.32/TestPushDumper.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TestPushDumper.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/TestPushDumper.py (revision 75) @@ -0,0 +1,123 @@ +import YamlTest +from here import * +from test import assertEquals +from types import DictType, ListType, TupleType, InstanceType + +""" +This is experimental code. It generates simulated events +for a pull-based YAML parser. +""" + +class MockEmitter: + """ + A pushed-based emitter may be more awkward to write, + because you have to keep track of more state. + """ + def __init__(self): + self.events = [] + + def append(self, *event): + self.events.append(event) + + def pushScalar(self, data): + self.append('getType', 'scalar') + self.append('getScalar', data) + + def appendType(self, typ): + self.append('getType', typ) + + def startSeq(self): + self.appendType('seq') + + def endSeq(self): + self.appendType(None) + + def startMap(self): + self.appendType('map') + + def endMap(self): + self.appendType(None) + +class Dumper: + def __init__(self, emitter): + self.emitter = emitter + + def dump(self, data): + if type(data) in (ListType, TupleType): + return self.dumpList(data) + elif type(data) is DictType: + return self.dumpDict(data) + else: + self.emitter.pushScalar(data) + + def dumpList(self, data): + self.emitter.startSeq() + for item in data: + self.dump(item) + self.emitter.endSeq() + + def dumpDict(self, data): + self.emitter.startMap() + keys = data.keys() + keys.sort() # XXX - only for now + for key in keys: + value = data[key] + self.dump(key) + self.dump(value) + self.emitter.endMap() + +def mockEvents(data): + emitter = MockEmitter() + dumper = Dumper(emitter) + dumper.dump(data) + return emitter.events + +class Test(YamlTest.YamlTest): + + def testScalar(self): + assertEquals(mockEvents('foobar'), self.scalar('foobar')) + + def scalar(self, data): + return [ + ('getType', 'scalar'), + ('getScalar', data) + ] + + def list123(self): + (result) = ( + [('getType', 'seq' )] + + self.scalar(1) + + self.scalar(2) + + self.scalar(3) + + [( 'getType', None )]) + return result + + def testList(self): + assertEquals(mockEvents([1,2,3]), self.list123()) + + def dictFoobar(self): + (result) = ( + [('getType', 'map')] + + self.scalar('bar') + + self.scalar(2) + + self.scalar('foo') + + self.scalar(1) + + [( 'getType', None)]) + return result + + def testDict(self): + events = mockEvents({'foo': 1, 'bar': 2}) + assertEquals(events, self.dictFoobar()) + + def testListDict(self): + events = mockEvents([ [1,2,3], {'foo': 1, 'bar': 2} ]) + self.assertEquals( + events, + [('getType', 'seq' )] + + self.list123() + + self.dictFoobar() + + [('getType', None)]) + +if __name__ == '__main__': + import unittest + unittest.main() Index: /pyyaml-legacy/tags/PyYaml_0.32/TestDumper.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/TestDumper.py (revision 75) +++ /pyyaml-legacy/tags/PyYaml_0.32/TestDumper.py (revision 75) @@ -0,0 +1,469 @@ +import YamlTest +from yaml.dump import * +import yaml +from here import flushLeft +from test import assertEquals + +class SampleClass: + def expected(self, modname, classname): + """ + Tough to test, because this class may be in __main__ + namespace, may be in TestDumper, depending where you + run it + """ + return """ + --- !!%s.%s + bar: 4 + foo: 3 + items: + - apple + - banana + """ % (modname, classname) + + def __init__(self): + self.foo = 3 + self.bar = 4 + self.items = ['apple', 'banana'] + + +class SampleException(Exception): + def __init__(self, args): + self.args = args + +class Test(YamlTest.YamlTest): + def dumpTest(self, obj, expect): + assertEquals(yaml.dump(obj), flushLeft(expect)) + def dumpTestSort(self,sort): + obj = {'a':'aaaa','d':'dddd','b':'bbbb','c':'cccc'} + exp = flushLeft(\ + """ + --- + b: bbbb + d: dddd + a: aaaa + c: cccc + """) + dumper = yaml.Dumper().setSort(sort) + self.assertEquals(dumper.dump(obj),exp) + def testsort_map(self): + self.dumpTestSort({'a':4,'b':2,'d':3}) + def testsort_tuple(self): + self.dumpTestSort(('b','d','a')) + def testsort_list(self): + self.dumpTestSort(['b','d','a']) + def testsort_func(self): + self.dumpTestSort({'a':4,'b':2,'d':3}.get) + def test1(self): + self.dumpTest( + { 'foo': 'bar', 'yo': 'mama' }, + """ + --- + foo: bar + yo: mama + """, + ) + + def test2(self): + self.dumpTest( + { 'foo': {'bar': 3} }, + """ + --- + foo: + bar: 3 + """, + ) + + def test3(self): + self.dumpTest( + { + 'foo': 3, + 'fruits': { + 'apple': 'red', + 'banana': 'yellow', + } + }, + """ + --- + foo: 3 + fruits: + apple: red + banana: yellow + """ + ) + + def test4(self): + self.dumpTest( + { + 'foo': 3, + 'fruits': ['apple', 'orange'] + }, + """ + --- + foo: 3 + fruits: + - apple + - orange + """ + ) + + def testTuple(self): + self.dumpTest( + { + 'foo': 3, + 'fruits': ('apple', 'orange') + }, + """ + --- + foo: 3 + fruits: + - apple + - orange + """ + ) + + def testMultiLineBlock(self): + self.dumpTest( + { + 'foo': "a\nb\nc\n", + }, + """ + --- + foo: | + a + b + c + """ + ) + + def testDoubleQuote(self): + assertEquals(doubleUpQuotes("foo'bar"), "foo''bar") + assertEquals(doubleUpQuotes("''x'"), "''''x''") + + def testQuotingRules(self): + # Raw: + self.assertEquals(dump(None), "--- ~\n") + self.assertEquals(dump('simple'), "--- simple\n") + self.assertEquals(dump(''), "--- ''\n") + self.assertEquals(dump('two words'), "--- two words\n") + self.assertEquals(dump('single\'quote'), "--- single'quote\n") + self.assertEquals(dump('5.2'), "--- '5.2'\n") + self.assertEquals(dump(5.2), "--- 5.2\n") + self.assertEquals(dump(1234), "--- 1234\n") + self.assertEquals(dump('harmless-dash'), "--- harmless-dash\n") + self.assertEquals(dump('* harmless bullet'), "--- * harmless bullet\n") + self.dumpTest( + [ "a - b", "another-harmless-dash" ], + """ + --- + - a - b + - another-harmless-dash + """) + # Single Quoted: + self.assertEquals(dump(''), "--- ''\n") + self.assertEquals(dump('4.3.1.5.2'), "--- '4.3.1.5.2'\n") + self.assertEquals(dump("'leading quote"), '--- "\'leading quote"\n') + self.assertEquals(dump('4.3.'), "--- '4.3.'\n") + self.assertEquals(dump('12345'), "--- '12345'\n") + self.assertEquals(dump('-12345'), "--- '-12345'\n") + self.assertEquals(dump('key: value'), "--- 'key: value'\n") + self.assertEquals(dump('ending colon:'), "--- 'ending colon:'\n") + self.assertEquals(dump('&foo'), "--- '&foo'\n") + self.assertEquals(dump(' xx'), "--- ' xx'\n") + self.assertEquals(dump('*bar'), "--- '*bar'\n") + assertEquals(dump('"middle \'quote'), '--- \'"middle \'\'quote\'\n') + # Double quoted: + self.assertEquals(dump("\thas a tab"), "--- \"\\thas a tab\"\n") + self.dumpTest( + { "key: quote": 'normal value' }, + """ + --- + 'key: quote': normal value + """) + + def testArrayWithSingleQuoted(self): + self.dumpTest( + [ 'foo:', {'bar': 'colon:'}], + """ + --- + - 'foo:' + - + bar: 'colon:' + """ + ) + + def testDumpObject(self): + sample = SampleClass() + self.dumpTest(sample, + sample.expected(sample.__module__, 'SampleClass')) + + def testWithSpuriousToYaml(self): + class ClassWithSpuriousToYaml(SampleClass): + to_yaml = 1 # Shouldn't get invoked + x = ClassWithSpuriousToYaml() + self.dumpTest(x, + x.expected(x.__module__,'ClassWithSpuriousToYaml')) + + def testNormalToYamlUse(self): + class NormalYamlUse(SampleClass): + def to_yaml(self): + dict = {} + dict['bar'] = self.foo * 2 + return (dict, None) + self.dumpTest(NormalYamlUse(), + """ + --- + bar: 6 + """) + + def testDumpingPrivateTypes(self): + class Foobar(SampleClass): + def to_yaml(self): + dict = {'foo': 'bar'} + return (dict, '!!foobar') + self.dumpTest(Foobar(), + """ + --- !!foobar + foo: bar + """) + class OddList(SampleClass): + def to_yaml(self): + return ([1, 3, 5], '!!oddlist') + self.dumpTest(OddList(), + """ + --- !!oddlist + - 1 + - 3 + - 5 + """) + + + def testToYamlShouldBeAllowedToThrowIfItWants(self): + class ThrowsInsideToYaml: + def to_yaml(self): + raise SampleException('bla') + caught_exception = 'undef' + try: + dump(ThrowsInsideToYaml()) + except Exception, e: + caught_exception = e + self.assertEquals('bla', caught_exception.args) + + def testObjectWithListOfClasses(self): + class Foo: + def __init__(self, items): + self.items = items + + class Bar: + def __init__(self, data): + self.data = data + + foo = Foo([Bar('apple'), Bar('banana')]) + mod = foo.__module__ # depends where called + self.dumpTest(foo, + """ + --- !!%s.Foo + items: + - !!%s.Bar + data: apple + - !!%s.Bar + data: banana + """ % (mod, mod, mod)) + + def testHasMethod(self): + class ClassWithMethodA: + b = 1 + def a(): pass + + sc = ClassWithMethodA() + self.assertEquals(1, hasMethod(sc, 'a')) + self.assertEquals(0, hasMethod(sc, 'b')) + + def testComplexKey(self): + self.dumpTest( {(3,4): 4}, + """ + --- + ? + - 3 + - 4 + : 4 + """) + + def testApostrophe(self): + self.dumpTest( "Joe's hot dogs.\n", + """ + --- | + Joe's hot dogs. + """) + + def testCustomIndent(self): + self.assertEquals( + yaml.Dumper().setIndent('xx').dump( + { + 'foo': 3, + 'fruits': ('apple', 'orange') + }, + ), + flushLeft( + """ + --- + foo: 3 + fruits: + xx- apple + xx- orange + """ + ) + ) + + def testUnicode(self): + if YamlTest.hasUnicode: + self.dumpTest({'foo': u"Foo\u263A"}, + r""" + --- + foo: "Foo\u263a" + """) + + def testTab(self): + self.dumpTest({'tab': "foo\tbar"}, + r""" + --- + tab: "foo\tbar" + """) + + def testIsMulti(self): + self.failUnless(isMulti("foo\nbar")) + self.failIf(isMulti("foobar")) + self.failIf(isMulti("line\twith tab\nsecond line")) + self.failUnless(isMulti("foo\\slash\nbar")) + + def testHasSpecialChar(self): + self.failUnless(hasSpecialChar("foo\tbar")) + self.failIf(hasSpecialChar("foobar")) + + def testTabs(self): + self.dumpTest({'control': "\b1998\t1999\t2000\n"}, + r""" + --- + control: "\b1998\t1999\t2000\n" + """) + + def test12345(self): + self.dumpTest({'foo': 12345, 'bar': '12345'}, + r""" + --- + bar: '12345' + foo: 12345 + """) + + def testDataThatsCoincidentallyTheSame(self): + self.dumpTest([ {'foo': 'bar'}, {'foo': 'bar'} ], + """ + --- + - + foo: bar + - + foo: bar + """) + + def testAliasClass(self): + dup = {'foo': 'bar'} + dupList = [dup, dup] + myAnchors = YamlAnchors(dupList) + self.assertEquals(id(dup), myAnchors._anchorVisits.keys()[0]) + self.assertEquals(0,myAnchors.isAlias(dup)) + self.assertEquals(1,myAnchors.shouldAnchor(dup) ) + self.assertEquals(0,myAnchors.shouldAnchor('bar')) + self.assertEquals(0,myAnchors.shouldAnchor(dup['foo'])) + self.assertEquals(0,myAnchors.shouldAnchor(dup)) + self.assertEquals(1,myAnchors.isAlias(dup)) + + def testAliases(self): + dup = {'foo': 'bar'} + self.dumpTest([dup, dup], + """ + --- + - &1 + foo: bar + - *1 + """) + + def testHashAlias(self): + dup = {} + dup['foo'] = dup + self.dumpTest(dup, + """ + --- &1 + foo: *1 + """) + + def testEmptyArray(self): + self.dumpTest([], + """ + --- [] + """) + + def testEmptyHash(self): + self.dumpTest({}, + """ + --- {} + """) + + def testEmptyHashAsHashKey(self): + self.dumpTest({'foo': {} }, + """ + --- + foo: {} + """) + + def testEmptyArrrayAsHashKey(self): + self.dumpTest({'foo': [] }, + """ + --- + foo: [] + """) + + def testAliasNone(self): + foo = None + self.dumpTest([foo, foo, foo], + """ + --- + - ~ + - ~ + - ~ + """) + + def testDumpMany(self): + assertEquals( + yaml.dump({'foo': 1}, ['a', 'b', 'c']), + flushLeft( + """ + --- + foo: 1 + --- + - a + - b + - c + """)) + + def testDumpExtraNewLines(self): + self.dumpTest( "Joe's hot dogs.\n\n", + """ + --- |+ + Joe's hot dogs. + + """) + + + def testDumpExtraNewLinesInDict(self): + data = {'preserving': "extra new lines are kept\n\n\n"} + self.dumpTest(data, + """ + --- + preserving: |+ + extra new lines are kept + + + """) + +if __name__ == '__main__': + import unittest + unittest.main() Index: /pyyaml-legacy/tags/PyYaml_0.32/XmlYaml/convertyaml_map.py =================================================================== --- /pyyaml-legacy/tags/PyYaml_0.32/XmlYaml/convertyaml_map.py (revision 71) +++ /pyyaml-legacy/tags/PyYaml_0.32/XmlYaml/convertyaml_map.py (revision 71) @@ -0,0 +1,178 @@ +#!/usr/bin/env python +""" +Sample code to convert YAML to XML and XML to YAML using a canonical +form. + +The canonical YAML representation of an XML element is a +dictionary (mapping) containing the following key/value pairs: + (1) "name" (required) -- a string. + (2) "attributes" (optional) -- a dictionary (mapping) of name/value + pairs. + (3) "text" (optional) -- a string. + (4) "children" (optional) -- a sequence of dictionaries (mappings). + +For usage information, type: + python convertyaml_map.py + +Usage: python convertyaml_map.py