Index: /pyyaml/tags/3.04/MANIFEST.in =================================================================== --- /pyyaml/tags/3.04/MANIFEST.in (revision 232) +++ /pyyaml/tags/3.04/MANIFEST.in (revision 232) @@ -0,0 +1,3 @@ +include README LICENSE setup.py setup_with_libyaml.py +include ext/_yaml.pyx ext/_yaml.pxd ext/_yaml.h ext/_yaml.c +recursive-include examples *.py *.cfg Index: /pyyaml/tags/3.04/setup_with_libyaml.py =================================================================== --- /pyyaml/tags/3.04/setup_with_libyaml.py (revision 232) +++ /pyyaml/tags/3.04/setup_with_libyaml.py (revision 232) @@ -0,0 +1,31 @@ + +from setup import * + +from distutils.core import setup +from distutils.extension import Extension +from Pyrex.Distutils import build_ext + +if __name__ == '__main__': + + setup( + name=NAME, + version=VERSION, + description=DESCRIPTION, + long_description=LONG_DESCRIPTION, + author=AUTHOR, + author_email=AUTHOR_EMAIL, + license=LICENSE, + platforms=PLATFORMS, + url=URL, + download_url=DOWNLOAD_URL, + classifiers=CLASSIFIERS, + + package_dir={'': 'lib'}, + packages=['yaml'], + ext_modules=[ + Extension("_yaml", ["ext/_yaml.pyx"], libraries=['yaml']), + ], + + cmdclass = {'build_ext': build_ext} + ) + Index: /pyyaml/tags/3.04/Makefile =================================================================== --- /pyyaml/tags/3.04/Makefile (revision 232) +++ /pyyaml/tags/3.04/Makefile (revision 232) @@ -0,0 +1,39 @@ + +.PHONY: default build buildext force forceext install installext test testext dist clean + +PYTHON=/usr/bin/python +TEST= +PARAMETERS= + +build: + ${PYTHON} setup.py build ${PARAMETERS} + +buildext: + ${PYTHON} setup_with_libyaml.py build ${PARAMETERS} + +force: + ${PYTHON} setup.py build -f ${PARAMETERS} + +forceext: + ${PYTHON} setup_with_libyaml.py build -f ${PARAMETERS} + +install: build + ${PYTHON} setup.py install ${PARAMETERS} + +installext: buildext + ${PYTHON} setup_with_libyaml.py install ${PARAMETERS} + +test: build + ${PYTHON} tests/test_build.py ${TEST} + +testext: buildext + ${PYTHON} tests/test_build_ext.py ${TEST} + +dist: + ${PYTHON} setup.py sdist --formats=zip,gztar + +windist: + ${PYTHON} setup.py bdist_wininst + +clean: + ${PYTHON} setup.py clean -a Index: /pyyaml/tags/3.04/README =================================================================== --- /pyyaml/tags/3.04/README (revision 232) +++ /pyyaml/tags/3.04/README (revision 232) @@ -0,0 +1,24 @@ +PyYAML 3000 - The next generation YAML parser and emitter for Python. + +To install, type 'python setup.py install'. + +You may build faster LibYAML based parser and emitter with +'python setup_with_libyaml.py install'. +Then you may use them with the calls: + >>> yaml.load(stream, Loader=yaml.CLoader) + >>> yaml.dump(data, Dumper=yaml.CDumper) + +For more information, check the PyYAML homepage: +'http://pyyaml.org/wiki/PyYAML'. + +Documentation (rough and incomplete though): +'http://pyyaml.org/wiki/PyYAMLDocumentation'. + +Post your questions and opinions to the YAML-Core mailing list: +'http://lists.sourceforge.net/lists/listinfo/yaml-core'. + +Submit bug reports and feature requests to the PyYAML bug tracker: +'http://pyyaml.org/newticket?component=pyyaml'. + +PyYAML 3000 is written by Kirill Simonov . It is released +under the MIT license. See the file LICENSE for more details. Index: /pyyaml/tags/3.04/examples/yaml-highlight/yaml_hl.cfg =================================================================== --- /pyyaml/tags/3.04/examples/yaml-highlight/yaml_hl.cfg (revision 164) +++ /pyyaml/tags/3.04/examples/yaml-highlight/yaml_hl.cfg (revision 164) @@ -0,0 +1,115 @@ +%YAML 1.1 +--- + +ascii: + + header: "\e[0;1;30;40m" + + footer: "\e[0m" + + tokens: + stream-start: + stream-end: + directive: { start: "\e[35m", end: "\e[0;1;30;40m" } + document-start: { start: "\e[35m", end: "\e[0;1;30;40m" } + document-end: { start: "\e[35m", end: "\e[0;1;30;40m" } + block-sequence-start: + block-mapping-start: + block-end: + flow-sequence-start: { start: "\e[33m", end: "\e[0;1;30;40m" } + flow-mapping-start: { start: "\e[33m", end: "\e[0;1;30;40m" } + flow-sequence-end: { start: "\e[33m", end: "\e[0;1;30;40m" } + flow-mapping-end: { start: "\e[33m", end: "\e[0;1;30;40m" } + key: { start: "\e[33m", end: "\e[0;1;30;40m" } + value: { start: "\e[33m", end: "\e[0;1;30;40m" } + block-entry: { start: "\e[33m", end: "\e[0;1;30;40m" } + flow-entry: { start: "\e[33m", end: "\e[0;1;30;40m" } + alias: { start: "\e[32m", end: "\e[0;1;30;40m" } + anchor: { start: "\e[32m", end: "\e[0;1;30;40m" } + tag: { start: "\e[32m", end: "\e[0;1;30;40m" } + scalar: { start: "\e[36m", end: "\e[0;1;30;40m" } + + replaces: + - "\r\n": "\n" + - "\r": "\n" + - "\n": "\n" + - "\x85": "\n" + - "\u2028": "\n" + - "\u2029": "\n" + +html: &html + + tokens: + stream-start: + stream-end: + directive: { start: , end: } + document-start: { start: , end: } + document-end: { start: , end: } + block-sequence-start: + block-mapping-start: + block-end: + flow-sequence-start: { start: , end: } + flow-mapping-start: { start: , end: } + flow-sequence-end: { start: , end: } + flow-mapping-end: { start: , end: } + key: { start: , end: } + value: { start: , end: } + block-entry: { start: , end: } + flow-entry: { start: , end: } + alias: { start: , end: } + anchor: { start: , end: } + tag: { start: , end: } + scalar: { start: , end: } + + events: + stream-start: { start: 
 }
+        stream-end:     { end:
} + document-start: { start: } + document-end: { end: } + sequence-start: { start: } + sequence-end: { end: } + mapping-start: { start: } + mapping-end: { end: } + scalar: { start: , end: } + + replaces: + - "\r\n": "\n" + - "\r": "\n" + - "\n": "\n" + - "\x85": "\n" + - "\u2028": "\n" + - "\u2029": "\n" + - "&": "&" + - "<": "<" + - ">": ">" + +html-page: + + header: | + + + A YAML stream + + + + footer: | + + + + <<: *html + + +# vim: ft=yaml Index: /pyyaml/tags/3.04/examples/yaml-highlight/yaml_hl.py =================================================================== --- /pyyaml/tags/3.04/examples/yaml-highlight/yaml_hl.py (revision 164) +++ /pyyaml/tags/3.04/examples/yaml-highlight/yaml_hl.py (revision 164) @@ -0,0 +1,114 @@ +#!/usr/bin/python + +import yaml, codecs, sys, os.path, optparse + +class Style: + + def __init__(self, header=None, footer=None, + tokens=None, events=None, replaces=None): + self.header = header + self.footer = footer + self.replaces = replaces + self.substitutions = {} + for domain, Class in [(tokens, 'Token'), (events, 'Event')]: + if not domain: + continue + for key in domain: + name = ''.join([part.capitalize() for part in key.split('-')]) + cls = getattr(yaml, '%s%s' % (name, Class)) + value = domain[key] + if not value: + continue + start = value.get('start') + end = value.get('end') + if start: + self.substitutions[cls, -1] = start + if end: + self.substitutions[cls, +1] = end + + def __setstate__(self, state): + self.__init__(**state) + +yaml.add_path_resolver(u'tag:yaml.org,2002:python/object:__main__.Style', + [None], dict) +yaml.add_path_resolver(u'tag:yaml.org,2002:pairs', + [None, u'replaces'], list) + +class YAMLHighlight: + + def __init__(self, options): + config = yaml.load(file(options.config, 'rb').read()) + self.style = config[options.style] + if options.input: + self.input = file(options.input, 'rb') + else: + self.input = sys.stdin + if options.output: + self.output = file(options.output, 'wb') + else: + self.output = sys.stdout + + def highlight(self): + input = self.input.read() + if input.startswith(codecs.BOM_UTF16_LE): + input = unicode(input, 'utf-16-le') + elif input.startswith(codecs.BOM_UTF16_BE): + input = unicode(input, 'utf-16-be') + else: + input = unicode(input, 'utf-8') + substitutions = self.style.substitutions + tokens = yaml.scan(input) + events = yaml.parse(input) + markers = [] + number = 0 + for token in tokens: + number += 1 + if token.start_mark.index != token.end_mark.index: + cls = token.__class__ + if (cls, -1) in substitutions: + markers.append([token.start_mark.index, +2, number, substitutions[cls, -1]]) + if (cls, +1) in substitutions: + markers.append([token.end_mark.index, -2, number, substitutions[cls, +1]]) + number = 0 + for event in events: + number += 1 + cls = event.__class__ + if (cls, -1) in substitutions: + markers.append([event.start_mark.index, +1, number, substitutions[cls, -1]]) + if (cls, +1) in substitutions: + markers.append([event.end_mark.index, -1, number, substitutions[cls, +1]]) + markers.sort() + markers.reverse() + chunks = [] + position = len(input) + for index, weight1, weight2, substitution in markers: + if index < position: + chunk = input[index:position] + for substring, replacement in self.style.replaces: + chunk = chunk.replace(substring, replacement) + chunks.append(chunk) + position = index + chunks.append(substitution) + chunks.reverse() + result = u''.join(chunks) + if self.style.header: + self.output.write(self.style.header) + self.output.write(result.encode('utf-8')) + if self.style.footer: + self.output.write(self.style.footer) + +if __name__ == '__main__': + parser = optparse.OptionParser() + parser.add_option('-s', '--style', dest='style', default='ascii', + help="specify the highlighting style", metavar='STYLE') + parser.add_option('-c', '--config', dest='config', + default=os.path.join(os.path.dirname(sys.argv[0]), 'yaml_hl.cfg'), + help="set an alternative configuration file", metavar='CONFIG') + parser.add_option('-i', '--input', dest='input', default=None, + help="set the input file (default: stdin)", metavar='FILE') + parser.add_option('-o', '--output', dest='output', default=None, + help="set the output file (default: stdout)", metavar='FILE') + (options, args) = parser.parse_args() + hl = YAMLHighlight(options) + hl.highlight() + Index: /pyyaml/tags/3.04/setup.cfg =================================================================== --- /pyyaml/tags/3.04/setup.cfg (revision 232) +++ /pyyaml/tags/3.04/setup.cfg (revision 232) @@ -0,0 +1,17 @@ + +# The INCLUDE and LIB directories to build the '_yaml' extension. +# You may also set them using the options '-I' and '-L'. +[build_ext] + +# List of directories to search for 'yaml.h' (separated by ':'). +#include_dirs=/usr/local/include:../../include + +# List of directories to search for 'libyaml.a' (separated by ':'). +#library_dirs=/usr/local/lib:../../lib + + +# An alternative compiler to build the extention. +#compiler=mingw32 + +# Additional preprocessor definitions might be required. +#define=YAML_DECLARE_STATIC Index: /pyyaml/tags/3.04/announcement.msg =================================================================== --- /pyyaml/tags/3.04/announcement.msg (revision 232) +++ /pyyaml/tags/3.04/announcement.msg (revision 232) @@ -0,0 +1,82 @@ +From: Kirill Simonov +To: python-list@python.org, python-announce@python.org, yaml-core@lists.sourceforge.net +Subject: [ANN] PyYAML-3.04: YAML parser and emitter for Python + +======================== + Announcing PyYAML-3.04 +======================== + +A new release of PyYAML, featuring LibYAML bindings and support for recursive +structures, is now available: + + http://pyyaml.org/wiki/PyYAML + + +Changes +======= + +* Include experimental LibYAML bindings. +* Fully support recursive structures. +* Fix a number of bugs and annoyances + (see http://pyyaml.org/wiki/PyYAML#History for more details). + + +Resources +========= + +PyYAML homepage: http://pyyaml.org/wiki/PyYAML +PyYAML documentation: http://pyyaml.org/wiki/PyYAMLDocumentation + +TAR.GZ package: http://pyyaml.org/download/pyyaml/PyYAML-3.04.tar.gz +ZIP package: http://pyyaml.org/download/pyyaml/PyYAML-3.04.zip +Windows installer: + http://pyyaml.org/download/pyyaml/PyYAML-3.04.win32-py2.3.exe + http://pyyaml.org/download/pyyaml/PyYAML-3.04.win32-py2.4.exe + +PyYAML SVN repository: http://svn.pyyaml.org/pyyaml +Submit a bug report: http://pyyaml.org/newticket?component=pyyaml + +YAML homepage: http://yaml.org/ +YAML-core mailing list: http://lists.sourceforge.net/lists/listinfo/yaml-core + + +About PyYAML +============ + +YAML is a data serialization format designed for human readability and +interaction with scripting languages. PyYAML is a YAML parser and +emitter for Python. + +PyYAML features a complete YAML 1.1 parser, Unicode support, pickle +support, capable extension API, and sensible error messages. PyYAML +supports standard YAML tags and provides Python-specific tags that allow +to represent an arbitrary Python object. + +PyYAML is applicable for a broad range of tasks from complex +configuration files to object serialization and persistance. + + +Example +======= + +>>> import yaml +>>> print yaml.load(""" +... &A { +... direct self reference: *A, +... indirect self references: [*A, *A, *A] +... } +... """) +{'direct self reference': {...}, +'indirect self references': [{...}, {...}, {...}]} + + +Copyright +========= + +The PyYAML module is written by Kirill Simonov . + +PyYAML is released under the MIT license. + +This release is developed with the support of the Google Summer of Code +program under the mentorship of Clark Evans. + Index: /pyyaml/tags/3.04/ext/_yaml.pyx =================================================================== --- /pyyaml/tags/3.04/ext/_yaml.pyx (revision 223) +++ /pyyaml/tags/3.04/ext/_yaml.pyx (revision 223) @@ -0,0 +1,1344 @@ + +import yaml + +def get_version_string(): + return yaml_get_version_string() + +def get_version(): + cdef int major, minor, patch + yaml_get_version(&major, &minor, &patch) + return (major, minor, patch) + +#Mark = yaml.error.Mark +YAMLError = yaml.error.YAMLError +ReaderError = yaml.reader.ReaderError +ScannerError = yaml.scanner.ScannerError +ParserError = yaml.parser.ParserError +ComposerError = yaml.composer.ComposerError +ConstructorError = yaml.constructor.ConstructorError +EmitterError = yaml.emitter.EmitterError +SerializerError = yaml.serializer.SerializerError +RepresenterError = yaml.representer.RepresenterError + +StreamStartToken = yaml.tokens.StreamStartToken +StreamEndToken = yaml.tokens.StreamEndToken +DirectiveToken = yaml.tokens.DirectiveToken +DocumentStartToken = yaml.tokens.DocumentStartToken +DocumentEndToken = yaml.tokens.DocumentEndToken +BlockSequenceStartToken = yaml.tokens.BlockSequenceStartToken +BlockMappingStartToken = yaml.tokens.BlockMappingStartToken +BlockEndToken = yaml.tokens.BlockEndToken +FlowSequenceStartToken = yaml.tokens.FlowSequenceStartToken +FlowMappingStartToken = yaml.tokens.FlowMappingStartToken +FlowSequenceEndToken = yaml.tokens.FlowSequenceEndToken +FlowMappingEndToken = yaml.tokens.FlowMappingEndToken +KeyToken = yaml.tokens.KeyToken +ValueToken = yaml.tokens.ValueToken +BlockEntryToken = yaml.tokens.BlockEntryToken +FlowEntryToken = yaml.tokens.FlowEntryToken +AliasToken = yaml.tokens.AliasToken +AnchorToken = yaml.tokens.AnchorToken +TagToken = yaml.tokens.TagToken +ScalarToken = yaml.tokens.ScalarToken + +StreamStartEvent = yaml.events.StreamStartEvent +StreamEndEvent = yaml.events.StreamEndEvent +DocumentStartEvent = yaml.events.DocumentStartEvent +DocumentEndEvent = yaml.events.DocumentEndEvent +AliasEvent = yaml.events.AliasEvent +ScalarEvent = yaml.events.ScalarEvent +SequenceStartEvent = yaml.events.SequenceStartEvent +SequenceEndEvent = yaml.events.SequenceEndEvent +MappingStartEvent = yaml.events.MappingStartEvent +MappingEndEvent = yaml.events.MappingEndEvent + +ScalarNode = yaml.nodes.ScalarNode +SequenceNode = yaml.nodes.SequenceNode +MappingNode = yaml.nodes.MappingNode + +cdef class Mark: + cdef readonly object name + cdef readonly int index + cdef readonly int line + cdef readonly int column + cdef readonly buffer + cdef readonly pointer + + def __init__(self, object name, int index, int line, int column, + object buffer, object pointer): + self.name = name + self.index = index + self.line = line + self.column = column + self.buffer = buffer + self.pointer = pointer + + def get_snippet(self): + return None + + def __str__(self): + where = " in \"%s\", line %d, column %d" \ + % (self.name, self.line+1, self.column+1) + return where + +#class YAMLError(Exception): +# pass +# +#class MarkedYAMLError(YAMLError): +# +# def __init__(self, context=None, context_mark=None, +# problem=None, problem_mark=None, note=None): +# self.context = context +# self.context_mark = context_mark +# self.problem = problem +# self.problem_mark = problem_mark +# self.note = note +# +# def __str__(self): +# lines = [] +# if self.context is not None: +# lines.append(self.context) +# if self.context_mark is not None \ +# and (self.problem is None or self.problem_mark is None +# or self.context_mark.name != self.problem_mark.name +# or self.context_mark.line != self.problem_mark.line +# or self.context_mark.column != self.problem_mark.column): +# lines.append(str(self.context_mark)) +# if self.problem is not None: +# lines.append(self.problem) +# if self.problem_mark is not None: +# lines.append(str(self.problem_mark)) +# if self.note is not None: +# lines.append(self.note) +# return '\n'.join(lines) +# +#class ReaderError(YAMLError): +# +# def __init__(self, name, position, character, encoding, reason): +# self.name = name +# self.character = character +# self.position = position +# self.encoding = encoding +# self.reason = reason +# +# def __str__(self): +# if isinstance(self.character, str): +# return "'%s' codec can't decode byte #x%02x: %s\n" \ +# " in \"%s\", position %d" \ +# % (self.encoding, ord(self.character), self.reason, +# self.name, self.position) +# else: +# return "unacceptable character #x%04x: %s\n" \ +# " in \"%s\", position %d" \ +# % (ord(self.character), self.reason, +# self.name, self.position) +# +#class ScannerError(MarkedYAMLError): +# pass +# +#class ParserError(MarkedYAMLError): +# pass +# +#class EmitterError(YAMLError): +# pass +# +#cdef class Token: +# cdef readonly Mark start_mark +# cdef readonly Mark end_mark +# def __init__(self, Mark start_mark, Mark end_mark): +# self.start_mark = start_mark +# self.end_mark = end_mark +# +#cdef class StreamStartToken(Token): +# cdef readonly object encoding +# def __init__(self, Mark start_mark, Mark end_mark, encoding): +# self.start_mark = start_mark +# self.end_mark = end_mark +# self.encoding = encoding +# +#cdef class StreamEndToken(Token): +# pass +# +#cdef class DirectiveToken(Token): +# cdef readonly object name +# cdef readonly object value +# def __init__(self, name, value, Mark start_mark, Mark end_mark): +# self.name = name +# self.value = value +# self.start_mark = start_mark +# self.end_mark = end_mark +# +#cdef class DocumentStartToken(Token): +# pass +# +#cdef class DocumentEndToken(Token): +# pass +# +#cdef class BlockSequenceStartToken(Token): +# pass +# +#cdef class BlockMappingStartToken(Token): +# pass +# +#cdef class BlockEndToken(Token): +# pass +# +#cdef class FlowSequenceStartToken(Token): +# pass +# +#cdef class FlowMappingStartToken(Token): +# pass +# +#cdef class FlowSequenceEndToken(Token): +# pass +# +#cdef class FlowMappingEndToken(Token): +# pass +# +#cdef class KeyToken(Token): +# pass +# +#cdef class ValueToken(Token): +# pass +# +#cdef class BlockEntryToken(Token): +# pass +# +#cdef class FlowEntryToken(Token): +# pass +# +#cdef class AliasToken(Token): +# cdef readonly object value +# def __init__(self, value, Mark start_mark, Mark end_mark): +# self.value = value +# self.start_mark = start_mark +# self.end_mark = end_mark +# +#cdef class AnchorToken(Token): +# cdef readonly object value +# def __init__(self, value, Mark start_mark, Mark end_mark): +# self.value = value +# self.start_mark = start_mark +# self.end_mark = end_mark +# +#cdef class TagToken(Token): +# cdef readonly object value +# def __init__(self, value, Mark start_mark, Mark end_mark): +# self.value = value +# self.start_mark = start_mark +# self.end_mark = end_mark +# +#cdef class ScalarToken(Token): +# cdef readonly object value +# cdef readonly object plain +# cdef readonly object style +# def __init__(self, value, plain, Mark start_mark, Mark end_mark, style=None): +# self.value = value +# self.plain = plain +# self.start_mark = start_mark +# self.end_mark = end_mark +# self.style = style + +cdef class CParser: + + cdef yaml_parser_t parser + cdef yaml_event_t parsed_event + + cdef object stream + cdef object stream_name + cdef object current_token + cdef object current_event + cdef object anchors + + def __init__(self, stream): + if yaml_parser_initialize(&self.parser) == 0: + raise MemoryError + self.parsed_event.type = YAML_NO_EVENT + if hasattr(stream, 'read'): + self.stream = stream + try: + self.stream_name = stream.name + except AttributeError: + self.stream_name = '' + yaml_parser_set_input(&self.parser, input_handler, self) + else: + if PyUnicode_CheckExact(stream) != 0: + stream = PyUnicode_AsUTF8String(stream) + self.stream_name = '' + else: + self.stream_name = '' + if PyString_CheckExact(stream) == 0: + raise TypeError("a string or stream input is required") + self.stream = stream + yaml_parser_set_input_string(&self.parser, PyString_AS_STRING(stream), PyString_GET_SIZE(stream)) + self.current_token = None + self.current_event = None + self.anchors = {} + + def __dealloc__(self): + yaml_parser_delete(&self.parser) + yaml_event_delete(&self.parsed_event) + + cdef object _parser_error(self): + if self.parser.error == YAML_MEMORY_ERROR: + raise MemoryError + elif self.parser.error == YAML_READER_ERROR: + raise ReaderError(self.stream_name, self.parser.problem_offset, + self.parser.problem_value, '?', self.parser.problem) + elif self.parser.error == YAML_SCANNER_ERROR \ + or self.parser.error == YAML_PARSER_ERROR: + context_mark = None + problem_mark = None + if self.parser.context != NULL: + context_mark = Mark(self.stream_name, + self.parser.context_mark.index, + self.parser.context_mark.line, + self.parser.context_mark.column, None, None) + if self.parser.problem != NULL: + problem_mark = Mark(self.stream_name, + self.parser.problem_mark.index, + self.parser.problem_mark.line, + self.parser.problem_mark.column, None, None) + if self.parser.error == YAML_SCANNER_ERROR: + if self.parser.context != NULL: + return ScannerError(self.parser.context, context_mark, + self.parser.problem, problem_mark) + else: + return ScannerError(None, None, + self.parser.problem, problem_mark) + else: + if self.parser.context != NULL: + return ParserError(self.parser.context, context_mark, + self.parser.problem, problem_mark) + else: + return ParserError(None, None, + self.parser.problem, problem_mark) + raise ValueError("no parser error") + + def raw_scan(self): + cdef yaml_token_t token + cdef int done + cdef int count + count = 0 + done = 0 + while done == 0: + if yaml_parser_scan(&self.parser, &token) == 0: + error = self._parser_error() + raise error + if token.type == YAML_NO_TOKEN: + done = 1 + else: + count = count+1 + yaml_token_delete(&token) + return count + + cdef object _scan(self): + cdef yaml_token_t token + if yaml_parser_scan(&self.parser, &token) == 0: + error = self._parser_error() + raise error + token_object = self._token_to_object(&token) + yaml_token_delete(&token) + return token_object + + cdef object _token_to_object(self, yaml_token_t *token): + start_mark = Mark(self.stream_name, + token.start_mark.index, + token.start_mark.line, + token.start_mark.column, + None, None) + end_mark = Mark(self.stream_name, + token.end_mark.index, + token.end_mark.line, + token.end_mark.column, + None, None) + if token.type == YAML_NO_TOKEN: + return None + elif token.type == YAML_STREAM_START_TOKEN: + encoding = None + if token.data.stream_start.encoding == YAML_UTF8_ENCODING: + encoding = "utf-8" + elif token.data.stream_start.encoding == YAML_UTF16LE_ENCODING: + encoding = "utf-16-le" + elif token.data.stream_start.encoding == YAML_UTF16BE_ENCODING: + encoding = "utf-16-be" + return StreamStartToken(start_mark, end_mark, encoding) + elif token.type == YAML_STREAM_END_TOKEN: + return StreamEndToken(start_mark, end_mark) + elif token.type == YAML_VERSION_DIRECTIVE_TOKEN: + return DirectiveToken("YAML", + (token.data.version_directive.major, + token.data.version_directive.minor), + start_mark, end_mark) + elif token.type == YAML_TAG_DIRECTIVE_TOKEN: + return DirectiveToken("TAG", + (token.data.tag_directive.handle, + token.data.tag_directive.prefix), + start_mark, end_mark) + elif token.type == YAML_DOCUMENT_START_TOKEN: + return DocumentStartToken(start_mark, end_mark) + elif token.type == YAML_DOCUMENT_END_TOKEN: + return DocumentEndToken(start_mark, end_mark) + elif token.type == YAML_BLOCK_SEQUENCE_START_TOKEN: + return BlockSequenceStartToken(start_mark, end_mark) + elif token.type == YAML_BLOCK_MAPPING_START_TOKEN: + return BlockMappingStartToken(start_mark, end_mark) + elif token.type == YAML_BLOCK_END_TOKEN: + return BlockEndToken(start_mark, end_mark) + elif token.type == YAML_FLOW_SEQUENCE_START_TOKEN: + return FlowSequenceStartToken(start_mark, end_mark) + elif token.type == YAML_FLOW_SEQUENCE_END_TOKEN: + return FlowSequenceEndToken(start_mark, end_mark) + elif token.type == YAML_FLOW_MAPPING_START_TOKEN: + return FlowMappingStartToken(start_mark, end_mark) + elif token.type == YAML_FLOW_MAPPING_END_TOKEN: + return FlowMappingEndToken(start_mark, end_mark) + elif token.type == YAML_BLOCK_ENTRY_TOKEN: + return BlockEntryToken(start_mark, end_mark) + elif token.type == YAML_FLOW_ENTRY_TOKEN: + return FlowEntryToken(start_mark, end_mark) + elif token.type == YAML_KEY_TOKEN: + return KeyToken(start_mark, end_mark) + elif token.type == YAML_VALUE_TOKEN: + return ValueToken(start_mark, end_mark) + elif token.type == YAML_ALIAS_TOKEN: + value = PyUnicode_DecodeUTF8(token.data.alias.value, + strlen(token.data.alias.value), 'strict') + return AliasToken(value, start_mark, end_mark) + elif token.type == YAML_ANCHOR_TOKEN: + value = PyUnicode_DecodeUTF8(token.data.anchor.value, + strlen(token.data.anchor.value), 'strict') + return AnchorToken(value, start_mark, end_mark) + elif token.type == YAML_TAG_TOKEN: + handle = PyUnicode_DecodeUTF8(token.data.tag.handle, + strlen(token.data.tag.handle), 'strict') + suffix = PyUnicode_DecodeUTF8(token.data.tag.suffix, + strlen(token.data.tag.suffix), 'strict') + if not handle: + handle = None + return TagToken((handle, suffix), start_mark, end_mark) + elif token.type == YAML_SCALAR_TOKEN: + value = PyUnicode_DecodeUTF8(token.data.scalar.value, + token.data.scalar.length, 'strict') + plain = False + style = None + if token.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: + plain = True + style = '' + elif token.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: + style = '\'' + elif token.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: + style = '"' + elif token.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: + style = '|' + elif token.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: + style = '>' + return ScalarToken(value, plain, + start_mark, end_mark, style) + else: + raise ValueError("unknown token type") + + def get_token(self): + if self.current_token is not None: + value = self.current_token + self.current_token = None + else: + value = self._scan() + return value + + def peek_token(self): + if self.current_token is None: + self.current_token = self._scan() + return self.current_token + + def check_token(self, *choices): + if self.current_token is None: + self.current_token = self._scan() + if self.current_token is None: + return False + if not choices: + return True + token_class = self.current_token.__class__ + for choice in choices: + if token_class is choice: + return True + return False + + def raw_parse(self): + cdef yaml_event_t event + cdef int done + cdef int count + count = 0 + done = 0 + while done == 0: + if yaml_parser_parse(&self.parser, &event) == 0: + error = self._parser_error() + raise error + if event.type == YAML_NO_EVENT: + done = 1 + else: + count = count+1 + yaml_event_delete(&event) + return count + + cdef object _parse(self): + cdef yaml_event_t event + if yaml_parser_parse(&self.parser, &event) == 0: + error = self._parser_error() + raise error + event_object = self._event_to_object(&event) + yaml_event_delete(&event) + return event_object + + cdef object _event_to_object(self, yaml_event_t *event): + cdef yaml_tag_directive_t *tag_directive + start_mark = Mark(self.stream_name, + event.start_mark.index, + event.start_mark.line, + event.start_mark.column, + None, None) + end_mark = Mark(self.stream_name, + event.end_mark.index, + event.end_mark.line, + event.end_mark.column, + None, None) + if event.type == YAML_NO_EVENT: + return None + elif event.type == YAML_STREAM_START_EVENT: + encoding = None + if event.data.stream_start.encoding == YAML_UTF8_ENCODING: + encoding = "utf-8" + elif event.data.stream_start.encoding == YAML_UTF16LE_ENCODING: + encoding = "utf-16-le" + elif event.data.stream_start.encoding == YAML_UTF16BE_ENCODING: + encoding = "utf-16-be" + return StreamStartEvent(start_mark, end_mark, encoding) + elif event.type == YAML_STREAM_END_EVENT: + return StreamEndEvent(start_mark, end_mark) + + elif event.type == YAML_DOCUMENT_START_EVENT: + explicit = False + if event.data.document_start.implicit == 0: + explicit = True + version = None + if event.data.document_start.version_directive != NULL: + version = (event.data.document_start.version_directive.major, + event.data.document_start.version_directive.minor) + tags = None + if event.data.document_start.tag_directives.start != NULL: + tags = {} + tag_directive = event.data.document_start.tag_directives.start + while tag_directive != event.data.document_start.tag_directives.end: + handle = PyUnicode_DecodeUTF8(tag_directive.handle, + strlen(tag_directive.handle), 'strict') + prefix = PyUnicode_DecodeUTF8(tag_directive.prefix, + strlen(tag_directive.prefix), 'strict') + tags[handle] = prefix + tag_directive = tag_directive+1 + return DocumentStartEvent(start_mark, end_mark, + explicit, version, tags) + elif event.type == YAML_DOCUMENT_END_EVENT: + explicit = False + if event.data.document_end.implicit == 0: + explicit = True + return DocumentEndEvent(start_mark, end_mark, explicit) + elif event.type == YAML_ALIAS_EVENT: + anchor = PyUnicode_DecodeUTF8(event.data.alias.anchor, + strlen(event.data.alias.anchor), 'strict') + return AliasEvent(anchor, start_mark, end_mark) + elif event.type == YAML_SCALAR_EVENT: + anchor = None + if event.data.scalar.anchor != NULL: + anchor = PyUnicode_DecodeUTF8(event.data.scalar.anchor, + strlen(event.data.scalar.anchor), 'strict') + tag = None + if event.data.scalar.tag != NULL: + tag = PyUnicode_DecodeUTF8(event.data.scalar.tag, + strlen(event.data.scalar.tag), 'strict') + value = PyUnicode_DecodeUTF8(event.data.scalar.value, + event.data.scalar.length, 'strict') + plain_implicit = False + if event.data.scalar.plain_implicit == 1: + plain_implicit = True + quoted_implicit = False + if event.data.scalar.quoted_implicit == 1: + quoted_implicit = True + style = None + if event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: + style = '' + elif event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: + style = '\'' + elif event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: + style = '"' + elif event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: + style = '|' + elif event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: + style = '>' + return ScalarEvent(anchor, tag, + (plain_implicit, quoted_implicit), + value, start_mark, end_mark, style) + elif event.type == YAML_SEQUENCE_START_EVENT: + anchor = None + if event.data.sequence_start.anchor != NULL: + anchor = PyUnicode_DecodeUTF8(event.data.sequence_start.anchor, + strlen(event.data.sequence_start.anchor), 'strict') + tag = None + if event.data.sequence_start.tag != NULL: + tag = PyUnicode_DecodeUTF8(event.data.sequence_start.tag, + strlen(event.data.sequence_start.tag), 'strict') + implicit = False + if event.data.sequence_start.implicit == 1: + implicit = True + flow_style = None + if event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: + flow_style = True + elif event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: + flow_style = False + return SequenceStartEvent(anchor, tag, implicit, + start_mark, end_mark, flow_style) + elif event.type == YAML_MAPPING_START_EVENT: + anchor = None + if event.data.mapping_start.anchor != NULL: + anchor = PyUnicode_DecodeUTF8(event.data.mapping_start.anchor, + strlen(event.data.mapping_start.anchor), 'strict') + tag = None + if event.data.mapping_start.tag != NULL: + tag = PyUnicode_DecodeUTF8(event.data.mapping_start.tag, + strlen(event.data.mapping_start.tag), 'strict') + implicit = False + if event.data.mapping_start.implicit == 1: + implicit = True + flow_style = None + if event.data.mapping_start.style == YAML_FLOW_SEQUENCE_STYLE: + flow_style = True + elif event.data.mapping_start.style == YAML_BLOCK_SEQUENCE_STYLE: + flow_style = False + return MappingStartEvent(anchor, tag, implicit, + start_mark, end_mark, flow_style) + elif event.type == YAML_SEQUENCE_END_EVENT: + return SequenceEndEvent(start_mark, end_mark) + elif event.type == YAML_MAPPING_END_EVENT: + return MappingEndEvent(start_mark, end_mark) + + else: + raise ValueError("unknown token type") + + def get_event(self): + if self.current_event is not None: + value = self.current_event + self.current_event = None + else: + value = self._parse() + return value + + def peek_event(self): + if self.current_event is None: + self.current_event = self._parse() + return self.current_event + + def check_event(self, *choices): + if self.current_event is None: + self.current_event = self._parse() + if self.current_event is None: + return False + if not choices: + return True + event_class = self.current_event.__class__ + for choice in choices: + if event_class is choice: + return True + return False + + def check_node(self): + self._parse_next_event() + if self.parsed_event.type != YAML_STREAM_END_EVENT: + return True + return False + + def get_node(self): + self._parse_next_event() + if self.parsed_event.type != YAML_STREAM_END_EVENT: + return self._compose_document() + + cdef object _compose_document(self): + if self.parsed_event.type == YAML_STREAM_START_EVENT: + yaml_event_delete(&self.parsed_event) + self._parse_next_event() + yaml_event_delete(&self.parsed_event) + node = self._compose_node(None, None) + self._parse_next_event() + yaml_event_delete(&self.parsed_event) + self.anchors = {} + return node + + cdef object _compose_node(self, object parent, object index): + self._parse_next_event() + if self.parsed_event.type == YAML_ALIAS_EVENT: + anchor = PyUnicode_DecodeUTF8(self.parsed_event.data.alias.anchor, + strlen(self.parsed_event.data.alias.anchor), 'strict') + if anchor not in self.anchors: + mark = Mark(self.stream_name, + self.parsed_event.start_mark.index, + self.parsed_event.start_mark.line, + self.parsed_event.start_mark.column, + None, None) + raise ComposerError(None, None, "found undefined alias", mark) + yaml_event_delete(&self.parsed_event) + return self.anchors[anchor] + anchor = None + if self.parsed_event.type == YAML_SCALAR_EVENT \ + and self.parsed_event.data.scalar.anchor != NULL: + anchor = PyUnicode_DecodeUTF8(self.parsed_event.data.scalar.anchor, + strlen(self.parsed_event.data.scalar.anchor), 'strict') + elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT \ + and self.parsed_event.data.sequence_start.anchor != NULL: + anchor = PyUnicode_DecodeUTF8(self.parsed_event.data.sequence_start.anchor, + strlen(self.parsed_event.data.sequence_start.anchor), 'strict') + elif self.parsed_event.type == YAML_MAPPING_START_EVENT \ + and self.parsed_event.data.mapping_start.anchor != NULL: + anchor = PyUnicode_DecodeUTF8(self.parsed_event.data.mapping_start.anchor, + strlen(self.parsed_event.data.mapping_start.anchor), 'strict') + if anchor is not None: + if anchor in self.anchors: + mark = Mark(self.stream_name, + self.parsed_event.start_mark.index, + self.parsed_event.start_mark.line, + self.parsed_event.start_mark.column, + None, None) + raise ComposerError("found duplicate anchor; first occurence", + self.anchors[anchor].start_mark, "second occurence", mark) + self.descend_resolver(parent, index) + if self.parsed_event.type == YAML_SCALAR_EVENT: + node = self._compose_scalar_node(anchor) + elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT: + node = self._compose_sequence_node(anchor) + elif self.parsed_event.type == YAML_MAPPING_START_EVENT: + node = self._compose_mapping_node(anchor) + self.ascend_resolver() + return node + + cdef _compose_scalar_node(self, object anchor): + start_mark = Mark(self.stream_name, + self.parsed_event.start_mark.index, + self.parsed_event.start_mark.line, + self.parsed_event.start_mark.column, + None, None) + end_mark = Mark(self.stream_name, + self.parsed_event.end_mark.index, + self.parsed_event.end_mark.line, + self.parsed_event.end_mark.column, + None, None) + value = PyUnicode_DecodeUTF8(self.parsed_event.data.scalar.value, + self.parsed_event.data.scalar.length, 'strict') + plain_implicit = False + if self.parsed_event.data.scalar.plain_implicit == 1: + plain_implicit = True + quoted_implicit = False + if self.parsed_event.data.scalar.quoted_implicit == 1: + quoted_implicit = True + if self.parsed_event.data.scalar.tag == NULL \ + or (self.parsed_event.data.scalar.tag[0] == c'!' + and self.parsed_event.data.scalar.tag[1] == c'\0'): + tag = self.resolve(ScalarNode, value, (plain_implicit, quoted_implicit)) + else: + tag = PyUnicode_DecodeUTF8(self.parsed_event.data.scalar.tag, + strlen(self.parsed_event.data.scalar.tag), 'strict') + style = None + if self.parsed_event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: + style = '' + elif self.parsed_event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: + style = '\'' + elif self.parsed_event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: + style = '"' + elif self.parsed_event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: + style = '|' + elif self.parsed_event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: + style = '>' + node = ScalarNode(tag, value, start_mark, end_mark, style) + if anchor is not None: + self.anchors[anchor] = node + yaml_event_delete(&self.parsed_event) + return node + + cdef _compose_sequence_node(self, object anchor): + cdef int index + start_mark = Mark(self.stream_name, + self.parsed_event.start_mark.index, + self.parsed_event.start_mark.line, + self.parsed_event.start_mark.column, + None, None) + implicit = False + if self.parsed_event.data.sequence_start.implicit == 1: + implicit = True + if self.parsed_event.data.sequence_start.tag == NULL \ + or (self.parsed_event.data.sequence_start.tag[0] == c'!' + and self.parsed_event.data.sequence_start.tag[1] == c'\0'): + tag = self.resolve(SequenceNode, None, implicit) + else: + tag = PyUnicode_DecodeUTF8(self.parsed_event.data.sequence_start.tag, + strlen(self.parsed_event.data.sequence_start.tag), 'strict') + flow_style = None + if self.parsed_event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: + flow_style = True + elif self.parsed_event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: + flow_style = False + value = [] + node = SequenceNode(tag, value, start_mark, None, flow_style) + if anchor is not None: + self.anchors[anchor] = node + yaml_event_delete(&self.parsed_event) + index = 0 + self._parse_next_event() + while self.parsed_event.type != YAML_SEQUENCE_END_EVENT: + value.append(self._compose_node(node, index)) + index = index+1 + self._parse_next_event() + node.end_mark = Mark(self.stream_name, + self.parsed_event.end_mark.index, + self.parsed_event.end_mark.line, + self.parsed_event.end_mark.column, + None, None) + yaml_event_delete(&self.parsed_event) + return node + + cdef _compose_mapping_node(self, object anchor): + start_mark = Mark(self.stream_name, + self.parsed_event.start_mark.index, + self.parsed_event.start_mark.line, + self.parsed_event.start_mark.column, + None, None) + implicit = False + if self.parsed_event.data.mapping_start.implicit == 1: + implicit = True + if self.parsed_event.data.mapping_start.tag == NULL \ + or (self.parsed_event.data.mapping_start.tag[0] == c'!' + and self.parsed_event.data.mapping_start.tag[1] == c'\0'): + tag = self.resolve(MappingNode, None, implicit) + else: + tag = PyUnicode_DecodeUTF8(self.parsed_event.data.mapping_start.tag, + strlen(self.parsed_event.data.mapping_start.tag), 'strict') + flow_style = None + if self.parsed_event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE: + flow_style = True + elif self.parsed_event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE: + flow_style = False + value = [] + node = MappingNode(tag, value, start_mark, None, flow_style) + if anchor is not None: + self.anchors[anchor] = node + yaml_event_delete(&self.parsed_event) + self._parse_next_event() + while self.parsed_event.type != YAML_MAPPING_END_EVENT: + item_key = self._compose_node(node, None) + item_value = self._compose_node(node, item_key) + value.append((item_key, item_value)) + self._parse_next_event() + node.end_mark = Mark(self.stream_name, + self.parsed_event.end_mark.index, + self.parsed_event.end_mark.line, + self.parsed_event.end_mark.column, + None, None) + yaml_event_delete(&self.parsed_event) + return node + + cdef int _parse_next_event(self) except 0: + if self.parsed_event.type == YAML_NO_EVENT: + if yaml_parser_parse(&self.parser, &self.parsed_event) == 0: + error = self._parser_error() + raise error + return 1 + +cdef int input_handler(void *data, char *buffer, int size, int *read) except 0: + cdef CParser parser + parser = data + value = parser.stream.read(size) + if PyString_CheckExact(value) == 0: + raise TypeError("a string value is expected") + if PyString_GET_SIZE(value) > size: + raise ValueError("a string value it too long") + memcpy(buffer, PyString_AS_STRING(value), PyString_GET_SIZE(value)) + read[0] = PyString_GET_SIZE(value) + return 1 + +cdef class CEmitter: + + cdef yaml_emitter_t emitter + + cdef object stream + + cdef yaml_encoding_t use_encoding + cdef int document_start_implicit + cdef int document_end_implicit + cdef object use_version + cdef object use_tags + + cdef object serialized_nodes + cdef object anchors + cdef int last_alias_id + cdef int closed + + def __init__(self, stream, canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, encoding=None, + explicit_start=None, explicit_end=None, version=None, tags=None): + if yaml_emitter_initialize(&self.emitter) == 0: + raise MemoryError + self.stream = stream + yaml_emitter_set_output(&self.emitter, output_handler, self) + if canonical is not None: + yaml_emitter_set_canonical(&self.emitter, 1) + if indent is not None: + yaml_emitter_set_indent(&self.emitter, indent) + if width is not None: + yaml_emitter_set_width(&self.emitter, width) + if allow_unicode is not None: + yaml_emitter_set_unicode(&self.emitter, 1) + if line_break is not None: + if line_break == '\r': + yaml_emitter_set_break(&self.emitter, YAML_CR_BREAK) + elif line_break == '\n': + yaml_emitter_set_break(&self.emitter, YAML_LN_BREAK) + elif line_break == '\r\n': + yaml_emitter_set_break(&self.emitter, YAML_CRLN_BREAK) + if encoding == 'utf-16-le': + self.use_encoding = YAML_UTF16LE_ENCODING + elif encoding == 'utf-16-be': + self.use_encoding = YAML_UTF16BE_ENCODING + else: + self.use_encoding = YAML_UTF8_ENCODING + self.document_start_implicit = 1 + if explicit_start: + self.document_start_implicit = 0 + self.document_end_implicit = 1 + if explicit_end: + self.document_end_implicit = 0 + self.use_version = version + self.use_tags = tags + self.serialized_nodes = {} + self.anchors = {} + self.last_alias_id = 0 + self.closed = -1 + + def __dealloc__(self): + yaml_emitter_delete(&self.emitter) + + cdef object _emitter_error(self): + if self.emitter.error == YAML_MEMORY_ERROR: + return MemoryError + elif self.emitter.error == YAML_EMITTER_ERROR: + return EmitterError(self.emitter.problem) + raise ValueError("no emitter error") + + cdef int _object_to_event(self, object event_object, yaml_event_t *event) except 0: + cdef yaml_encoding_t encoding + cdef yaml_version_directive_t version_directive_value + cdef yaml_version_directive_t *version_directive + cdef yaml_tag_directive_t tag_directives_value[128] + cdef yaml_tag_directive_t *tag_directives_start + cdef yaml_tag_directive_t *tag_directives_end + cdef int implicit + cdef int plain_implicit + cdef int quoted_implicit + cdef char *anchor + cdef char *tag + cdef char *value + cdef int length + cdef yaml_scalar_style_t scalar_style + cdef yaml_sequence_style_t sequence_style + cdef yaml_mapping_style_t mapping_style + event_class = event_object.__class__ + if event_class is StreamStartEvent: + encoding = YAML_UTF8_ENCODING + if event_object.encoding == 'utf-16-le': + encoding = YAML_UTF16LE_ENCODING + elif event_object.encoding == 'utf-16-be': + encoding = YAML_UTF16BE_ENCODING + yaml_stream_start_event_initialize(event, encoding) + elif event_class is StreamEndEvent: + yaml_stream_end_event_initialize(event) + elif event_class is DocumentStartEvent: + version_directive = NULL + if event_object.version: + version_directive_value.major = event_object.version[0] + version_directive_value.minor = event_object.version[1] + version_directive = &version_directive_value + tag_directives_start = NULL + tag_directives_end = NULL + if event_object.tags: + if len(event_object.tags) > 128: + raise ValueError("too many tags") + tag_directives_start = tag_directives_value + tag_directives_end = tag_directives_value + cache = [] + for handle in event_object.tags: + prefix = event_object.tags[handle] + if PyUnicode_CheckExact(handle): + handle = PyUnicode_AsUTF8String(handle) + cache.append(handle) + if not PyString_CheckExact(handle): + raise TypeError("tag handle must be a string") + tag_directives_end.handle = PyString_AS_STRING(handle) + if PyUnicode_CheckExact(prefix): + prefix = PyUnicode_AsUTF8String(prefix) + cache.append(prefix) + if not PyString_CheckExact(prefix): + raise TypeError("tag prefix must be a string") + tag_directives_end.prefix = PyString_AS_STRING(prefix) + tag_directives_end = tag_directives_end+1 + implicit = 1 + if event_object.explicit: + implicit = 0 + if yaml_document_start_event_initialize(event, version_directive, + tag_directives_start, tag_directives_end, implicit) == 0: + raise MemoryError + elif event_class is DocumentEndEvent: + implicit = 1 + if event_object.explicit: + implicit = 0 + yaml_document_end_event_initialize(event, implicit) + elif event_class is AliasEvent: + anchor = NULL + anchor_object = event_object.anchor + if PyUnicode_CheckExact(anchor_object): + anchor_object = PyUnicode_AsUTF8String(anchor_object) + if not PyString_CheckExact(anchor_object): + raise TypeError("anchor must be a string") + anchor = PyString_AS_STRING(anchor_object) + if yaml_alias_event_initialize(event, anchor) == 0: + raise MemoryError + elif event_class is ScalarEvent: + anchor = NULL + anchor_object = event_object.anchor + if anchor_object is not None: + if PyUnicode_CheckExact(anchor_object): + anchor_object = PyUnicode_AsUTF8String(anchor_object) + if not PyString_CheckExact(anchor_object): + raise TypeError("anchor must be a string") + anchor = PyString_AS_STRING(anchor_object) + tag = NULL + tag_object = event_object.tag + if tag_object is not None: + if PyUnicode_CheckExact(tag_object): + tag_object = PyUnicode_AsUTF8String(tag_object) + if not PyString_CheckExact(tag_object): + raise TypeError("tag must be a string") + tag = PyString_AS_STRING(tag_object) + value_object = event_object.value + if PyUnicode_CheckExact(value_object): + value_object = PyUnicode_AsUTF8String(value_object) + if not PyString_CheckExact(value_object): + raise TypeError("value must be a string") + value = PyString_AS_STRING(value_object) + length = PyString_GET_SIZE(value_object) + plain_implicit = 0 + quoted_implicit = 0 + if event_object.implicit is not None: + plain_implicit = event_object.implicit[0] + quoted_implicit = event_object.implicit[1] + style_object = event_object.style + scalar_style = YAML_PLAIN_SCALAR_STYLE + if style_object == "'": + scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE + elif style_object == "\"": + scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE + elif style_object == "|": + scalar_style = YAML_LITERAL_SCALAR_STYLE + elif style_object == ">": + scalar_style = YAML_FOLDED_SCALAR_STYLE + if yaml_scalar_event_initialize(event, anchor, tag, value, length, + plain_implicit, quoted_implicit, scalar_style) == 0: + raise MemoryError + elif event_class is SequenceStartEvent: + anchor = NULL + anchor_object = event_object.anchor + if anchor_object is not None: + if PyUnicode_CheckExact(anchor_object): + anchor_object = PyUnicode_AsUTF8String(anchor_object) + if not PyString_CheckExact(anchor_object): + raise TypeError("anchor must be a string") + anchor = PyString_AS_STRING(anchor_object) + tag = NULL + tag_object = event_object.tag + if tag_object is not None: + if PyUnicode_CheckExact(tag_object): + tag_object = PyUnicode_AsUTF8String(tag_object) + if not PyString_CheckExact(tag_object): + raise TypeError("tag must be a string") + tag = PyString_AS_STRING(tag_object) + implicit = 0 + if event_object.implicit: + implicit = 1 + sequence_style = YAML_BLOCK_SEQUENCE_STYLE + if event_object.flow_style: + sequence_style = YAML_FLOW_SEQUENCE_STYLE + if yaml_sequence_start_event_initialize(event, anchor, tag, + implicit, sequence_style) == 0: + raise MemoryError + elif event_class is MappingStartEvent: + anchor = NULL + anchor_object = event_object.anchor + if anchor_object is not None: + if PyUnicode_CheckExact(anchor_object): + anchor_object = PyUnicode_AsUTF8String(anchor_object) + if not PyString_CheckExact(anchor_object): + raise TypeError("anchor must be a string") + anchor = PyString_AS_STRING(anchor_object) + tag = NULL + tag_object = event_object.tag + if tag_object is not None: + if PyUnicode_CheckExact(tag_object): + tag_object = PyUnicode_AsUTF8String(tag_object) + if not PyString_CheckExact(tag_object): + raise TypeError("tag must be a string") + tag = PyString_AS_STRING(tag_object) + implicit = 0 + if event_object.implicit: + implicit = 1 + mapping_style = YAML_BLOCK_MAPPING_STYLE + if event_object.flow_style: + mapping_style = YAML_FLOW_MAPPING_STYLE + if yaml_mapping_start_event_initialize(event, anchor, tag, + implicit, mapping_style) == 0: + raise MemoryError + elif event_class is SequenceEndEvent: + yaml_sequence_end_event_initialize(event) + elif event_class is MappingEndEvent: + yaml_mapping_end_event_initialize(event) + else: + raise TypeError("invalid event %s" % event_object) + return 1 + + def emit(self, event_object): + cdef yaml_event_t event + self._object_to_event(event_object, &event) + if yaml_emitter_emit(&self.emitter, &event) == 0: + error = self._emitter_error() + raise error + + def open(self): + cdef yaml_event_t event + if self.closed == -1: + yaml_stream_start_event_initialize(&event, self.use_encoding) + if yaml_emitter_emit(&self.emitter, &event) == 0: + error = self._emitter_error() + raise error + self.closed = 0 + elif self.closed == 1: + raise SerializerError("serializer is closed") + else: + raise SerializerError("serializer is already opened") + + def close(self): + cdef yaml_event_t event + if self.closed == -1: + raise SerializerError("serializer is not opened") + elif self.closed == 0: + yaml_stream_end_event_initialize(&event) + if yaml_emitter_emit(&self.emitter, &event) == 0: + error = self._emitter_error() + raise error + self.closed = 1 + + def serialize(self, node): + cdef yaml_event_t event + cdef yaml_version_directive_t version_directive_value + cdef yaml_version_directive_t *version_directive + cdef yaml_tag_directive_t tag_directives_value[128] + cdef yaml_tag_directive_t *tag_directives_start + cdef yaml_tag_directive_t *tag_directives_end + if self.closed == -1: + raise SerializerError("serializer is not opened") + elif self.closed == 1: + raise SerializerError("serializer is closed") + cache = [] + version_directive = NULL + if self.use_version: + version_directive_value.major = self.use_version[0] + version_directive_value.minor = self.use_version[1] + version_directive = &version_directive_value + tag_directives_start = NULL + tag_directives_end = NULL + if self.use_tags: + if len(self.use_tags) > 128: + raise ValueError("too many tags") + tag_directives_start = tag_directives_value + tag_directives_end = tag_directives_value + for handle in self.use_tags: + prefix = self.use_tags[handle] + if PyUnicode_CheckExact(handle): + handle = PyUnicode_AsUTF8String(handle) + cache.append(handle) + if not PyString_CheckExact(handle): + raise TypeError("tag handle must be a string") + tag_directives_end.handle = PyString_AS_STRING(handle) + if PyUnicode_CheckExact(prefix): + prefix = PyUnicode_AsUTF8String(prefix) + cache.append(prefix) + if not PyString_CheckExact(prefix): + raise TypeError("tag prefix must be a string") + tag_directives_end.prefix = PyString_AS_STRING(prefix) + tag_directives_end = tag_directives_end+1 + if yaml_document_start_event_initialize(&event, version_directive, + tag_directives_start, tag_directives_end, + self.document_start_implicit) == 0: + raise MemoryError + if yaml_emitter_emit(&self.emitter, &event) == 0: + error = self._emitter_error() + raise error + self._anchor_node(node) + self._serialize_node(node, None, None) + yaml_document_end_event_initialize(&event, self.document_end_implicit) + if yaml_emitter_emit(&self.emitter, &event) == 0: + error = self._emitter_error() + raise error + self.serialized_nodes = {} + self.anchors = {} + self.last_alias_id = 0 + + cdef int _anchor_node(self, object node) except 0: + if node in self.anchors: + if self.anchors[node] is None: + self.last_alias_id = self.last_alias_id+1 + self.anchors[node] = "id%03d" % self.last_alias_id + else: + self.anchors[node] = None + node_class = node.__class__ + if node_class is SequenceNode: + for item in node.value: + self._anchor_node(item) + elif node_class is MappingNode: + for key, value in node.value: + self._anchor_node(key) + self._anchor_node(value) + return 1 + + cdef int _serialize_node(self, object node, object parent, object index) except 0: + cdef yaml_event_t event + cdef int implicit + cdef int plain_implicit + cdef int quoted_implicit + cdef char *anchor + cdef char *tag + cdef char *value + cdef int length + cdef int item_index + cdef yaml_scalar_style_t scalar_style + cdef yaml_sequence_style_t sequence_style + cdef yaml_mapping_style_t mapping_style + anchor_object = self.anchors[node] + anchor = NULL + if anchor_object is not None: + anchor = PyString_AS_STRING(anchor_object) + if node in self.serialized_nodes: + if yaml_alias_event_initialize(&event, anchor) == 0: + raise MemoryError + if yaml_emitter_emit(&self.emitter, &event) == 0: + error = self._emitter_error() + raise error + else: + node_class = node.__class__ + self.serialized_nodes[node] = True + self.descend_resolver(parent, index) + if node_class is ScalarNode: + plain_implicit = 0 + quoted_implicit = 0 + tag_object = node.tag + if self.resolve(ScalarNode, node.value, (True, False)) == tag_object: + plain_implicit = 1 + if self.resolve(ScalarNode, node.value, (False, True)) == tag_object: + quoted_implicit = 1 + tag = NULL + if tag_object is not None: + if PyUnicode_CheckExact(tag_object): + tag_object = PyUnicode_AsUTF8String(tag_object) + if not PyString_CheckExact(tag_object): + raise TypeError("tag must be a string") + tag = PyString_AS_STRING(tag_object) + value_object = node.value + if PyUnicode_CheckExact(value_object): + value_object = PyUnicode_AsUTF8String(value_object) + if not PyString_CheckExact(value_object): + raise TypeError("value must be a string") + value = PyString_AS_STRING(value_object) + length = PyString_GET_SIZE(value_object) + style_object = node.style + scalar_style = YAML_PLAIN_SCALAR_STYLE + if style_object == "'": + scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE + elif style_object == "\"": + scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE + elif style_object == "|": + scalar_style = YAML_LITERAL_SCALAR_STYLE + elif style_object == ">": + scalar_style = YAML_FOLDED_SCALAR_STYLE + if yaml_scalar_event_initialize(&event, anchor, tag, value, length, + plain_implicit, quoted_implicit, scalar_style) == 0: + raise MemoryError + if yaml_emitter_emit(&self.emitter, &event) == 0: + error = self._emitter_error() + raise error + elif node_class is SequenceNode: + implicit = 0 + tag_object = node.tag + if self.resolve(SequenceNode, node.value, True) == tag_object: + implicit = 1 + tag = NULL + if tag_object is not None: + if PyUnicode_CheckExact(tag_object): + tag_object = PyUnicode_AsUTF8String(tag_object) + if not PyString_CheckExact(tag_object): + raise TypeError("tag must be a string") + tag = PyString_AS_STRING(tag_object) + sequence_style = YAML_BLOCK_SEQUENCE_STYLE + if node.flow_style: + sequence_style = YAML_FLOW_SEQUENCE_STYLE + if yaml_sequence_start_event_initialize(&event, anchor, tag, + implicit, sequence_style) == 0: + raise MemoryError + if yaml_emitter_emit(&self.emitter, &event) == 0: + error = self._emitter_error() + raise error + item_index = 0 + for item in node.value: + self._serialize_node(item, node, item_index) + item_index = item_index+1 + yaml_sequence_end_event_initialize(&event) + if yaml_emitter_emit(&self.emitter, &event) == 0: + error = self._emitter_error() + raise error + elif node_class is MappingNode: + implicit = 0 + tag_object = node.tag + if self.resolve(MappingNode, node.value, True) == tag_object: + implicit = 1 + tag = NULL + if tag_object is not None: + if PyUnicode_CheckExact(tag_object): + tag_object = PyUnicode_AsUTF8String(tag_object) + if not PyString_CheckExact(tag_object): + raise TypeError("tag must be a string") + tag = PyString_AS_STRING(tag_object) + mapping_style = YAML_BLOCK_MAPPING_STYLE + if node.flow_style: + mapping_style = YAML_FLOW_MAPPING_STYLE + if yaml_mapping_start_event_initialize(&event, anchor, tag, + implicit, mapping_style) == 0: + raise MemoryError + if yaml_emitter_emit(&self.emitter, &event) == 0: + error = self._emitter_error() + raise error + for item_key, item_value in node.value: + self._serialize_node(item_key, node, None) + self._serialize_node(item_value, node, item_key) + yaml_mapping_end_event_initialize(&event) + if yaml_emitter_emit(&self.emitter, &event) == 0: + error = self._emitter_error() + raise error + return 1 + +cdef int output_handler(void *data, char *buffer, int size) except 0: + cdef CEmitter emitter + emitter = data + value = PyString_FromStringAndSize(buffer, size) + emitter.stream.write(value) + return 1 + Index: /pyyaml/tags/3.04/ext/_yaml.h =================================================================== --- /pyyaml/tags/3.04/ext/_yaml.h (revision 205) +++ /pyyaml/tags/3.04/ext/_yaml.h (revision 205) @@ -0,0 +1,3 @@ + +#include + Index: /pyyaml/tags/3.04/ext/_yaml.pxd =================================================================== --- /pyyaml/tags/3.04/ext/_yaml.pxd (revision 223) +++ /pyyaml/tags/3.04/ext/_yaml.pxd (revision 223) @@ -0,0 +1,249 @@ + +cdef extern from "_yaml.h": + + void malloc(int l) + void memcpy(char *d, char *s, int l) + int strlen(char *s) + int PyString_CheckExact(object o) + int PyUnicode_CheckExact(object o) + char *PyString_AS_STRING(object o) + int PyString_GET_SIZE(object o) + object PyString_FromStringAndSize(char *v, int l) + object PyUnicode_DecodeUTF8(char *s, int s, char *e) + object PyUnicode_AsUTF8String(object o) + + ctypedef enum: + SIZEOF_VOID_P + ctypedef enum yaml_encoding_t: + YAML_ANY_ENCODING + YAML_UTF8_ENCODING + YAML_UTF16LE_ENCODING + YAML_UTF16BE_ENCODING + ctypedef enum yaml_break_t: + YAML_ANY_BREAK + YAML_CR_BREAK + YAML_LN_BREAK + YAML_CRLN_BREAK + ctypedef enum yaml_error_type_t: + YAML_NO_ERROR + YAML_MEMORY_ERROR + YAML_READER_ERROR + YAML_SCANNER_ERROR + YAML_PARSER_ERROR + YAML_WRITER_ERROR + YAML_EMITTER_ERROR + ctypedef enum yaml_scalar_style_t: + YAML_ANY_SCALAR_STYLE + YAML_PLAIN_SCALAR_STYLE + YAML_SINGLE_QUOTED_SCALAR_STYLE + YAML_DOUBLE_QUOTED_SCALAR_STYLE + YAML_LITERAL_SCALAR_STYLE + YAML_FOLDED_SCALAR_STYLE + ctypedef enum yaml_sequence_style_t: + YAML_ANY_SEQUENCE_STYLE + YAML_BLOCK_SEQUENCE_STYLE + YAML_FLOW_SEQUENCE_STYLE + ctypedef enum yaml_mapping_style_t: + YAML_ANY_MAPPING_STYLE + YAML_BLOCK_MAPPING_STYLE + YAML_FLOW_MAPPING_STYLE + ctypedef enum yaml_token_type_t: + YAML_NO_TOKEN + YAML_STREAM_START_TOKEN + YAML_STREAM_END_TOKEN + YAML_VERSION_DIRECTIVE_TOKEN + YAML_TAG_DIRECTIVE_TOKEN + YAML_DOCUMENT_START_TOKEN + YAML_DOCUMENT_END_TOKEN + YAML_BLOCK_SEQUENCE_START_TOKEN + YAML_BLOCK_MAPPING_START_TOKEN + YAML_BLOCK_END_TOKEN + YAML_FLOW_SEQUENCE_START_TOKEN + YAML_FLOW_SEQUENCE_END_TOKEN + YAML_FLOW_MAPPING_START_TOKEN + YAML_FLOW_MAPPING_END_TOKEN + YAML_BLOCK_ENTRY_TOKEN + YAML_FLOW_ENTRY_TOKEN + YAML_KEY_TOKEN + YAML_VALUE_TOKEN + YAML_ALIAS_TOKEN + YAML_ANCHOR_TOKEN + YAML_TAG_TOKEN + YAML_SCALAR_TOKEN + ctypedef enum yaml_event_type_t: + YAML_NO_EVENT + YAML_STREAM_START_EVENT + YAML_STREAM_END_EVENT + YAML_DOCUMENT_START_EVENT + YAML_DOCUMENT_END_EVENT + YAML_ALIAS_EVENT + YAML_SCALAR_EVENT + YAML_SEQUENCE_START_EVENT + YAML_SEQUENCE_END_EVENT + YAML_MAPPING_START_EVENT + YAML_MAPPING_END_EVENT + + ctypedef int yaml_read_handler_t(void *data, char *buffer, + int size, int *size_read) except 0 + + ctypedef int yaml_write_handler_t(void *data, char *buffer, + int size) except 0 + + ctypedef struct yaml_mark_t: + int index + int line + int column + ctypedef struct yaml_version_directive_t: + int major + int minor + ctypedef struct yaml_tag_directive_t: + char *handle + char *prefix + + ctypedef struct _yaml_token_stream_start_data_t: + yaml_encoding_t encoding + ctypedef struct _yaml_token_alias_data_t: + char *value + ctypedef struct _yaml_token_anchor_data_t: + char *value + ctypedef struct _yaml_token_tag_data_t: + char *handle + char *suffix + ctypedef struct _yaml_token_scalar_data_t: + char *value + int length + yaml_scalar_style_t style + ctypedef struct _yaml_token_version_directive_data_t: + int major + int minor + ctypedef struct _yaml_token_tag_directive_data_t: + char *handle + char *prefix + ctypedef union _yaml_token_data_t: + _yaml_token_stream_start_data_t stream_start + _yaml_token_alias_data_t alias + _yaml_token_anchor_data_t anchor + _yaml_token_tag_data_t tag + _yaml_token_scalar_data_t scalar + _yaml_token_version_directive_data_t version_directive + _yaml_token_tag_directive_data_t tag_directive + ctypedef struct yaml_token_t: + yaml_token_type_t type + _yaml_token_data_t data + yaml_mark_t start_mark + yaml_mark_t end_mark + + ctypedef struct _yaml_event_stream_start_data_t: + yaml_encoding_t encoding + ctypedef struct _yaml_event_document_start_data_tag_directives_t: + yaml_tag_directive_t *start + yaml_tag_directive_t *end + ctypedef struct _yaml_event_document_start_data_t: + yaml_version_directive_t *version_directive + _yaml_event_document_start_data_tag_directives_t tag_directives + int implicit + ctypedef struct _yaml_event_document_end_data_t: + int implicit + ctypedef struct _yaml_event_alias_data_t: + char *anchor + ctypedef struct _yaml_event_scalar_data_t: + char *anchor + char *tag + char *value + int length + int plain_implicit + int quoted_implicit + yaml_scalar_style_t style + ctypedef struct _yaml_event_sequence_start_data_t: + char *anchor + char *tag + int implicit + yaml_sequence_style_t style + ctypedef struct _yaml_event_mapping_start_data_t: + char *anchor + char *tag + int implicit + yaml_mapping_style_t style + ctypedef union _yaml_event_data_t: + _yaml_event_stream_start_data_t stream_start + _yaml_event_document_start_data_t document_start + _yaml_event_document_end_data_t document_end + _yaml_event_alias_data_t alias + _yaml_event_scalar_data_t scalar + _yaml_event_sequence_start_data_t sequence_start + _yaml_event_mapping_start_data_t mapping_start + ctypedef struct yaml_event_t: + yaml_event_type_t type + _yaml_event_data_t data + yaml_mark_t start_mark + yaml_mark_t end_mark + + ctypedef struct yaml_parser_t: + yaml_error_type_t error + char *problem + int problem_offset + int problem_value + yaml_mark_t problem_mark + char *context + yaml_mark_t context_mark + + ctypedef struct yaml_emitter_t: + yaml_error_type_t error + char *problem + + char *yaml_get_version_string() + void yaml_get_version(int *major, int *minor, int *patch) + + void yaml_token_delete(yaml_token_t *token) + + int yaml_stream_start_event_initialize(yaml_event_t *event, + yaml_encoding_t encoding) + int yaml_stream_end_event_initialize(yaml_event_t *event) + int yaml_document_start_event_initialize(yaml_event_t *event, + yaml_version_directive_t *version_directive, + yaml_tag_directive_t *tag_directives_start, + yaml_tag_directive_t *tag_directives_end, + int implicit) + int yaml_document_end_event_initialize(yaml_event_t *event, + int implicit) + int yaml_alias_event_initialize(yaml_event_t *event, char *anchor) + int yaml_scalar_event_initialize(yaml_event_t *event, + char *anchor, char *tag, char *value, int length, + int plain_implicit, int quoted_implicit, + yaml_scalar_style_t style) + int yaml_sequence_start_event_initialize(yaml_event_t *event, + char *anchor, char *tag, int implicit, yaml_sequence_style_t style) + int yaml_sequence_end_event_initialize(yaml_event_t *event) + int yaml_mapping_start_event_initialize(yaml_event_t *event, + char *anchor, char *tag, int implicit, yaml_mapping_style_t style) + int yaml_mapping_end_event_initialize(yaml_event_t *event) + void yaml_event_delete(yaml_event_t *event) + + int yaml_parser_initialize(yaml_parser_t *parser) + void yaml_parser_delete(yaml_parser_t *parser) + void yaml_parser_set_input_string(yaml_parser_t *parser, + char *input, int size) + void yaml_parser_set_input(yaml_parser_t *parser, + yaml_read_handler_t *handler, void *data) + void yaml_parser_set_encoding(yaml_parser_t *parser, + yaml_encoding_t encoding) + int yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token) except * + int yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event) except * + + int yaml_emitter_initialize(yaml_emitter_t *emitter) + void yaml_emitter_delete(yaml_emitter_t *emitter) + void yaml_emitter_set_output_string(yaml_emitter_t *emitter, + char *output, int size, int *size_written) + void yaml_emitter_set_output(yaml_emitter_t *emitter, + yaml_write_handler_t *handler, void *data) + void yaml_emitter_set_encoding(yaml_emitter_t *emitter, + yaml_encoding_t encoding) + void yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical) + void yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent) + void yaml_emitter_set_width(yaml_emitter_t *emitter, int width) + void yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode) + void yaml_emitter_set_break(yaml_emitter_t *emitter, + yaml_break_t line_break) + int yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event) except * + int yaml_emitter_flush(yaml_emitter_t *emitter) + Index: /pyyaml/tags/3.04/LICENSE =================================================================== --- /pyyaml/tags/3.04/LICENSE (revision 232) +++ /pyyaml/tags/3.04/LICENSE (revision 232) @@ -0,0 +1,19 @@ +Copyright (c) 2006 Kirill Simonov + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. Index: /pyyaml/tags/3.04/tests/test_build_ext.py =================================================================== --- /pyyaml/tags/3.04/tests/test_build_ext.py (revision 195) +++ /pyyaml/tags/3.04/tests/test_build_ext.py (revision 195) @@ -0,0 +1,14 @@ + + +def main(): + import sys, os, distutils.util + build_lib = 'build/lib' + build_lib_ext = os.path.join('build', 'lib.%s-%s' % (distutils.util.get_platform(), sys.version[0:3])) + sys.path.insert(0, build_lib) + sys.path.insert(0, build_lib_ext) + import test_yaml_ext + test_yaml_ext.main('test_yaml_ext') + +if __name__ == '__main__': + main() + Index: /pyyaml/tags/3.04/tests/test_yaml_ext.py =================================================================== --- /pyyaml/tags/3.04/tests/test_yaml_ext.py (revision 223) +++ /pyyaml/tags/3.04/tests/test_yaml_ext.py (revision 223) @@ -0,0 +1,192 @@ + +import unittest, test_appliance + +import _yaml, yaml + +class TestCVersion(unittest.TestCase): + + def testCVersion(self): + self.failUnlessEqual("%s.%s.%s" % _yaml.get_version(), _yaml.get_version_string()) + +class TestCLoader(test_appliance.TestAppliance): + + def _testCScannerFileInput(self, test_name, data_filename, canonical_filename): + self._testCScanner(test_name, data_filename, canonical_filename, True) + + def _testCScanner(self, test_name, data_filename, canonical_filename, file_input=False, Loader=yaml.Loader): + if file_input: + data = file(data_filename, 'r') + else: + data = file(data_filename, 'r').read() + tokens = list(yaml.scan(data, Loader=Loader)) + ext_tokens = [] + try: + if file_input: + data = file(data_filename, 'r') + for token in yaml.scan(data, Loader=yaml.CLoader): + ext_tokens.append(token) + self.failUnlessEqual(len(tokens), len(ext_tokens)) + for token, ext_token in zip(tokens, ext_tokens): + self.failUnlessEqual(token.__class__, ext_token.__class__) + self.failUnlessEqual((token.start_mark.index, token.start_mark.line, token.start_mark.column), + (ext_token.start_mark.index, ext_token.start_mark.line, ext_token.start_mark.column)) + self.failUnlessEqual((token.end_mark.index, token.end_mark.line, token.end_mark.column), + (ext_token.end_mark.index, ext_token.end_mark.line, ext_token.end_mark.column)) + if hasattr(token, 'value'): + self.failUnlessEqual(token.value, ext_token.value) + except: + print + print "DATA:" + print file(data_filename, 'rb').read() + print "TOKENS:", tokens + print "EXT_TOKENS:", ext_tokens + raise + + def _testCParser(self, test_name, data_filename, canonical_filename, Loader=yaml.Loader): + data = file(data_filename, 'r').read() + events = list(yaml.parse(data, Loader=Loader)) + ext_events = [] + try: + for event in yaml.parse(data, Loader=yaml.CLoader): + ext_events.append(event) + #print "EVENT:", event + self.failUnlessEqual(len(events), len(ext_events)) + for event, ext_event in zip(events, ext_events): + self.failUnlessEqual(event.__class__, ext_event.__class__) + if hasattr(event, 'anchor'): + self.failUnlessEqual(event.anchor, ext_event.anchor) + if hasattr(event, 'tag'): + self.failUnlessEqual(event.tag, ext_event.tag) + if hasattr(event, 'implicit'): + self.failUnlessEqual(event.implicit, ext_event.implicit) + if hasattr(event, 'value'): + self.failUnlessEqual(event.value, ext_event.value) + if hasattr(event, 'explicit'): + self.failUnlessEqual(event.explicit, ext_event.explicit) + if hasattr(event, 'version'): + self.failUnlessEqual(event.version, ext_event.version) + if hasattr(event, 'tags'): + self.failUnlessEqual(event.tags, ext_event.tags) + except: + print + print "DATA:" + print file(data_filename, 'rb').read() + print "EVENTS:", events + print "EXT_EVENTS:", ext_events + raise + +TestCLoader.add_tests('testCScanner', '.data', '.canonical') +TestCLoader.add_tests('testCScannerFileInput', '.data', '.canonical') +TestCLoader.add_tests('testCParser', '.data', '.canonical') + +class TestCEmitter(test_appliance.TestAppliance): + + def _testCEmitter(self, test_name, data_filename, canonical_filename, Loader=yaml.Loader): + data1 = file(data_filename, 'r').read() + events = list(yaml.parse(data1, Loader=Loader)) + data2 = yaml.emit(events, Dumper=yaml.CDumper) + ext_events = [] + try: + for event in yaml.parse(data2): + ext_events.append(event) + self.failUnlessEqual(len(events), len(ext_events)) + for event, ext_event in zip(events, ext_events): + self.failUnlessEqual(event.__class__, ext_event.__class__) + if hasattr(event, 'anchor'): + self.failUnlessEqual(event.anchor, ext_event.anchor) + if hasattr(event, 'tag'): + if not (event.tag in ['!', None] and ext_event.tag in ['!', None]): + self.failUnlessEqual(event.tag, ext_event.tag) + if hasattr(event, 'implicit'): + self.failUnlessEqual(event.implicit, ext_event.implicit) + if hasattr(event, 'value'): + self.failUnlessEqual(event.value, ext_event.value) + if hasattr(event, 'explicit'): + self.failUnlessEqual(event.explicit, ext_event.explicit) + if hasattr(event, 'version'): + self.failUnlessEqual(event.version, ext_event.version) + if hasattr(event, 'tags'): + self.failUnlessEqual(event.tags, ext_event.tags) + except: + print + print "DATA1:" + print data1 + print "DATA2:" + print data2 + print "EVENTS:", events + print "EXT_EVENTS:", ext_events + raise + +TestCEmitter.add_tests('testCEmitter', '.data', '.canonical') + +yaml.BaseLoader = yaml.CBaseLoader +yaml.SafeLoader = yaml.CSafeLoader +yaml.Loader = yaml.CLoader +yaml.BaseDumper = yaml.CBaseDumper +yaml.SafeDumper = yaml.CSafeDumper +yaml.Dumper = yaml.CDumper +old_scan = yaml.scan +def scan(stream, Loader=yaml.CLoader): + return old_scan(stream, Loader) +yaml.scan = scan +old_parse = yaml.parse +def parse(stream, Loader=yaml.CLoader): + return old_parse(stream, Loader) +yaml.parse = parse +old_compose = yaml.compose +def compose(stream, Loader=yaml.CLoader): + return old_compose(stream, Loader) +yaml.compose = compose +old_compose_all = yaml.compose_all +def compose_all(stream, Loader=yaml.CLoader): + return old_compose_all(stream, Loader) +yaml.compose_all = compose_all +old_load_all = yaml.load_all +def load_all(stream, Loader=yaml.CLoader): + return old_load_all(stream, Loader) +yaml.load_all = load_all +old_load = yaml.load +def load(stream, Loader=yaml.CLoader): + return old_load(stream, Loader) +yaml.load = load +def safe_load_all(stream): + return yaml.load_all(stream, yaml.CSafeLoader) +yaml.safe_load_all = safe_load_all +def safe_load(stream): + return yaml.load(stream, yaml.CSafeLoader) +yaml.safe_load = safe_load +old_emit = yaml.emit +def emit(events, stream=None, Dumper=yaml.CDumper, **kwds): + return old_emit(events, stream, Dumper, **kwds) +yaml.emit = emit +old_serialize_all = yaml.serialize_all +def serialize_all(nodes, stream=None, Dumper=yaml.CDumper, **kwds): + return old_serialize_all(nodes, stream, Dumper, **kwds) +yaml.serialize_all = serialize_all +old_serialize = yaml.serialize +def serialize(node, stream, Dumper=yaml.CDumper, **kwds): + return old_serialize(node, stream, Dumper, **kwds) +yaml.serialize = serialize +old_dump_all = yaml.dump_all +def dump_all(documents, stream=None, Dumper=yaml.CDumper, **kwds): + return old_dump_all(documents, stream, Dumper, **kwds) +yaml.dump_all = dump_all +old_dump = yaml.dump +def dump(data, stream=None, Dumper=yaml.CDumper, **kwds): + return old_dump(data, stream, Dumper, **kwds) +yaml.dump = dump +def safe_dump_all(documents, stream=None, **kwds): + return yaml.dump_all(documents, stream, yaml.CSafeDumper, **kwds) +yaml.safe_dump_all = safe_dump_all +def safe_dump(data, stream=None, **kwds): + return yaml.dump(data, stream, yaml.CSafeDumper, **kwds) +yaml.safe_dump = safe_dump + +from test_yaml import * + +def main(module='__main__'): + unittest.main(module) + +if __name__ == '__main__': + main() + Index: /pyyaml/tags/3.04/tests/data/value.data =================================================================== --- /pyyaml/tags/3.04/tests/data/value.data (revision 55) +++ /pyyaml/tags/3.04/tests/data/value.data (revision 55) @@ -0,0 +1,1 @@ +- = Index: /pyyaml/tags/3.04/tests/data/spec-02-10.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-10.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-10.structure (revision 44) @@ -0,0 +1,1 @@ +[(True, [True, True]), (True, ['*', True])] Index: /pyyaml/tags/3.04/tests/data/duplicate-merge-key.former-loader-error.data =================================================================== --- /pyyaml/tags/3.04/tests/data/duplicate-merge-key.former-loader-error.data (revision 222) +++ /pyyaml/tags/3.04/tests/data/duplicate-merge-key.former-loader-error.data (revision 222) @@ -0,0 +1,4 @@ +--- +<<: {x: 1, y: 2} +foo: bar +<<: {z: 3, t: 4} Index: /pyyaml/tags/3.04/tests/data/spec-02-06.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-06.tokens (revision 39) +++ /pyyaml/tags/3.04/tests/data/spec-02-06.tokens (revision 39) @@ -0,0 +1,4 @@ +{{ +? _ : { ? _ : _ , ? _ : _ } +? _ : { ? _ : _ , ? _ : _ } +]} Index: /pyyaml/tags/3.04/tests/data/spec-10-12.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-12.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-10-12.data (revision 38) @@ -0,0 +1,3 @@ +block: # Block + # mapping + key: value Index: /pyyaml/tags/3.04/tests/data/construct-custom.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-custom.data (revision 136) +++ /pyyaml/tags/3.04/tests/data/construct-custom.data (revision 136) @@ -0,0 +1,26 @@ +--- +- !tag1 + x: 1 +- !tag1 + x: 1 + 'y': 2 + z: 3 +- !tag2 + 10 +- !tag2 + =: 10 + 'y': 20 + z: 30 +- !tag3 + x: 1 +- !tag3 + x: 1 + 'y': 2 + z: 3 +- !tag3 + =: 1 + 'y': 2 + z: 3 +- !foo + my-parameter: foo + my-another-parameter: [1,2,3] Index: /pyyaml/tags/3.04/tests/data/spec-02-17.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-17.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-17.data (revision 38) @@ -0,0 +1,7 @@ +unicode: "Sosa did fine.\u263A" +control: "\b1998\t1999\t2000\n" +hexesc: "\x13\x10 is \r\n" + +single: '"Howdy!" he cried.' +quoted: ' # not a ''comment''.' +tie-fighter: '|\-*-/|' Index: /pyyaml/tags/3.04/tests/data/spec-09-21.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-21.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-21.data (revision 38) @@ -0,0 +1,8 @@ +- | + + text +- > + text + text +- |1 + text Index: /pyyaml/tags/3.04/tests/data/construct-pairs.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-pairs.code (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-pairs.code (revision 58) @@ -0,0 +1,9 @@ +{ + "Block tasks": [ + ("meeting", "with team."), + ("meeting", "with boss."), + ("break", "lunch."), + ("meeting", "with client."), + ], + "Flow tasks": [ ("meeting", "with team"), ("meeting", "with boss") ], +} Index: /pyyaml/tags/3.04/tests/data/spec-08-05.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-05.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-08-05.data (revision 38) @@ -0,0 +1,5 @@ +%TAG !o! tag:ben-kiki.org,2000: +--- +- !local foo +- !!str bar +- !o!type baz Index: /pyyaml/tags/3.04/tests/data/spec-10-12.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-12.canonical (revision 42) +++ /pyyaml/tags/3.04/tests/data/spec-10-12.canonical (revision 42) @@ -0,0 +1,9 @@ +%YAML 1.1 +--- +!!map { + ? !!str "block" + : !!map { + ? !!str "key" + : !!str "value" + } +} Index: /pyyaml/tags/3.04/tests/data/construct-python-unicode-ascii.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-unicode-ascii.data (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-unicode-ascii.data (revision 144) @@ -0,0 +1,1 @@ +--- !!python/unicode "ascii string" Index: /pyyaml/tags/3.04/tests/data/recursive-list.recursive =================================================================== --- /pyyaml/tags/3.04/tests/data/recursive-list.recursive (revision 223) +++ /pyyaml/tags/3.04/tests/data/recursive-list.recursive (revision 223) @@ -0,0 +1,2 @@ +value = [] +value.append(value) Index: /pyyaml/tags/3.04/tests/data/spec-08-06.error =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-06.error (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-08-06.error (revision 38) @@ -0,0 +1,4 @@ +ERROR: +- The !$a! looks like a handle. +- The !o! handle has no suffix. +- The !h! handle wasn't declared. Index: /pyyaml/tags/3.04/tests/data/construct-timestamp.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-timestamp.code (revision 225) +++ /pyyaml/tags/3.04/tests/data/construct-timestamp.code (revision 225) @@ -0,0 +1,7 @@ +{ + "canonical": datetime.datetime(2001, 12, 15, 2, 59, 43, 100000), + "valid iso8601": datetime.datetime(2001, 12, 15, 2, 59, 43, 100000), + "space separated": datetime.datetime(2001, 12, 15, 2, 59, 43, 100000), + "no time zone (Z)": datetime.datetime(2001, 12, 15, 2, 59, 43, 100000), + "date (00:00:00Z)": datetime.date(2002, 12, 14), +} Index: /pyyaml/tags/3.04/tests/data/spec-02-15.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-15.tokens (revision 41) +++ /pyyaml/tags/3.04/tests/data/spec-02-15.tokens (revision 41) @@ -0,0 +1,1 @@ +_ Index: /pyyaml/tags/3.04/tests/data/spec-02-02.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-02.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-02.data (revision 38) @@ -0,0 +1,3 @@ +hr: 65 # Home runs +avg: 0.278 # Batting average +rbi: 147 # Runs Batted In Index: /pyyaml/tags/3.04/tests/data/int.data =================================================================== --- /pyyaml/tags/3.04/tests/data/int.data (revision 55) +++ /pyyaml/tags/3.04/tests/data/int.data (revision 55) @@ -0,0 +1,6 @@ +- 685230 +- +685_230 +- 02472256 +- 0x_0A_74_AE +- 0b1010_0111_0100_1010_1110 +- 190:20:30 Index: /pyyaml/tags/3.04/tests/data/spec-06-02.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-06-02.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-06-02.data (revision 38) @@ -0,0 +1,3 @@ + # Comment + + Index: /pyyaml/tags/3.04/tests/data/spec-02-26.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-26.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-26.data (revision 38) @@ -0,0 +1,7 @@ +# ordered maps are represented as +# a sequence of mappings, with +# each mapping having one key +--- !!omap +- Mark McGwire: 65 +- Sammy Sosa: 63 +- Ken Griffy: 58 Index: /pyyaml/tags/3.04/tests/data/spec-07-12a.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-12a.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-12a.data (revision 38) @@ -0,0 +1,3 @@ +# Implicit document. Root +# collection (mapping) node. +foo : bar Index: /pyyaml/tags/3.04/tests/data/spec-09-30.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-30.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-30.data (revision 38) @@ -0,0 +1,14 @@ +> + folded + line + + next + line + + * bullet + * list + + last + line + +# Comment Index: /pyyaml/tags/3.04/tests/data/spec-08-14.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-14.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-08-14.data (revision 38) @@ -0,0 +1,5 @@ +- "flow in block" +- > + Block scalar +- !!map # Block collection + foo : bar Index: /pyyaml/tags/3.04/tests/data/yaml.data =================================================================== --- /pyyaml/tags/3.04/tests/data/yaml.data (revision 56) +++ /pyyaml/tags/3.04/tests/data/yaml.data (revision 56) @@ -0,0 +1,3 @@ +- !!yaml '!' +- !!yaml '&' +- !!yaml '*' Index: /pyyaml/tags/3.04/tests/data/timestamp.data =================================================================== --- /pyyaml/tags/3.04/tests/data/timestamp.data (revision 55) +++ /pyyaml/tags/3.04/tests/data/timestamp.data (revision 55) @@ -0,0 +1,5 @@ +- 2001-12-15T02:59:43.1Z +- 2001-12-14t21:59:43.10-05:00 +- 2001-12-14 21:59:43.10 -5 +- 2001-12-15 2:59:43.10 +- 2002-12-14 Index: /pyyaml/tags/3.04/tests/data/construct-python-name-module.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-name-module.code (revision 146) +++ /pyyaml/tags/3.04/tests/data/construct-python-name-module.code (revision 146) @@ -0,0 +1,1 @@ +[file, Loader, dump, abs, yaml.tokens] Index: /pyyaml/tags/3.04/tests/data/str.data =================================================================== --- /pyyaml/tags/3.04/tests/data/str.data (revision 55) +++ /pyyaml/tags/3.04/tests/data/str.data (revision 55) @@ -0,0 +1,1 @@ +- abcd Index: /pyyaml/tags/3.04/tests/data/value.detect =================================================================== --- /pyyaml/tags/3.04/tests/data/value.detect (revision 55) +++ /pyyaml/tags/3.04/tests/data/value.detect (revision 55) @@ -0,0 +1,1 @@ +tag:yaml.org,2002:value Index: /pyyaml/tags/3.04/tests/data/spec-08-07.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-07.canonical (revision 136) +++ /pyyaml/tags/3.04/tests/data/spec-08-07.canonical (revision 136) @@ -0,0 +1,8 @@ +%YAML 1.1 +--- +!!seq [ + ! "12", + ! "12", +# ! "12", + ! "12", +] Index: /pyyaml/tags/3.04/tests/data/spec-02-24.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-24.tokens (revision 41) +++ /pyyaml/tags/3.04/tests/data/spec-02-24.tokens (revision 41) @@ -0,0 +1,20 @@ +% +--- ! +[[ +, ! + {{ + ? _ : & { ? _ : _ , ? _ : _ } + ? _ : _ + ]} +, ! + {{ + ? _ : * + ? _ : { ? _ : _ , ? _ : _ } + ]} +, ! + {{ + ? _ : * + ? _ : _ + ? _ : _ + ]} +]} Index: /pyyaml/tags/3.04/tests/data/spec-02-11.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-11.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-11.data (revision 38) @@ -0,0 +1,9 @@ +? - Detroit Tigers + - Chicago cubs +: + - 2001-07-23 + +? [ New York Yankees, + Atlanta Braves ] +: [ 2001-07-02, 2001-08-12, + 2001-08-14 ] Index: /pyyaml/tags/3.04/tests/data/recursive-tuple.recursive =================================================================== --- /pyyaml/tags/3.04/tests/data/recursive-tuple.recursive (revision 222) +++ /pyyaml/tags/3.04/tests/data/recursive-tuple.recursive (revision 222) @@ -0,0 +1,3 @@ +value = ([], []) +value[0].append(value) +value[1].append(value[0]) Index: /pyyaml/tags/3.04/tests/data/construct-python-str-utf8.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-str-utf8.data (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-str-utf8.data (revision 144) @@ -0,0 +1,1 @@ +--- !!python/str "ЭтП уМОкПЎМая стрПка" Index: /pyyaml/tags/3.04/tests/data/scan-line-break-bug.data =================================================================== --- /pyyaml/tags/3.04/tests/data/scan-line-break-bug.data (revision 60) +++ /pyyaml/tags/3.04/tests/data/scan-line-break-bug.data (revision 60) @@ -0,0 +1,3 @@ +foo: + bar + baz Index: /pyyaml/tags/3.04/tests/data/spec-09-19.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-19.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-19.data (revision 38) @@ -0,0 +1,4 @@ +- | + literal +- > + folded Index: /pyyaml/tags/3.04/tests/data/construct-python-complex.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-complex.data (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-complex.data (revision 144) @@ -0,0 +1,8 @@ +- !!python/complex 0.5+0j +- !!python/complex 0.5+0.5j +- !!python/complex 0.5j +- !!python/complex -0.5+0.5j +- !!python/complex -0.5+0j +- !!python/complex -0.5-0.5j +- !!python/complex -0.5j +- !!python/complex 0.5-0.5j Index: /pyyaml/tags/3.04/tests/data/spec-07-02.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-02.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-02.canonical (revision 38) @@ -0,0 +1,3 @@ +%YAML 1.1 +--- +!!str "foo" Index: /pyyaml/tags/3.04/tests/data/negative-float-bug.data =================================================================== --- /pyyaml/tags/3.04/tests/data/negative-float-bug.data (revision 171) +++ /pyyaml/tags/3.04/tests/data/negative-float-bug.data (revision 171) @@ -0,0 +1,1 @@ +-1.0 Index: /pyyaml/tags/3.04/tests/data/duplicate-tag-directive.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/duplicate-tag-directive.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/duplicate-tag-directive.loader-error (revision 140) @@ -0,0 +1,3 @@ +%TAG !foo! bar +%TAG !foo! baz +--- foo Index: /pyyaml/tags/3.04/tests/data/spec-09-09.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-09.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-09.canonical (revision 38) @@ -0,0 +1,7 @@ +%YAML 1.1 +--- +!!seq [ + !!str " last", + !!str " last", + !!str " \tfirst last", +] Index: /pyyaml/tags/3.04/tests/data/more-floats.data =================================================================== --- /pyyaml/tags/3.04/tests/data/more-floats.data (revision 174) +++ /pyyaml/tags/3.04/tests/data/more-floats.data (revision 174) @@ -0,0 +1,1 @@ +[0.0, +1.0, -1.0, +.inf, -.inf, .nan, .nan] Index: /pyyaml/tags/3.04/tests/data/invalid-tag-directive-handle.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-tag-directive-handle.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-tag-directive-handle.loader-error (revision 140) @@ -0,0 +1,2 @@ +%TAG !!! !!! +--- Index: /pyyaml/tags/3.04/tests/data/spec-02-20.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-20.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-20.data (revision 38) @@ -0,0 +1,6 @@ +canonical: 1.23015e+3 +exponential: 12.3015e+02 +sexagesimal: 20:30.15 +fixed: 1,230.15 +negative infinity: -.inf +not a number: .NaN Index: /pyyaml/tags/3.04/tests/data/invalid-python-name-module.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-python-name-module.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-python-name-module.loader-error (revision 140) @@ -0,0 +1,1 @@ +--- !!python/name:sys.modules.keys Index: /pyyaml/tags/3.04/tests/data/recursive-anchor.former-loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/recursive-anchor.former-loader-error (revision 222) +++ /pyyaml/tags/3.04/tests/data/recursive-anchor.former-loader-error (revision 222) @@ -0,0 +1,4 @@ +- &foo [1 + 2, + 3, + *foo] Index: /pyyaml/tags/3.04/tests/data/spec-05-04.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-04.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-04.data (revision 38) @@ -0,0 +1,2 @@ +sequence: [ one, two, ] +mapping: { sky: blue, sea: green } Index: /pyyaml/tags/3.04/tests/data/spec-09-04.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-04.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-04.data (revision 38) @@ -0,0 +1,4 @@ + "first + inner 1 + \ inner 2 \ + last" Index: /pyyaml/tags/3.04/tests/data/invalid-directive-name-1.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-directive-name-1.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-directive-name-1.loader-error (revision 140) @@ -0,0 +1,2 @@ +% # no name at all +--- Index: /pyyaml/tags/3.04/tests/data/no-alias-anchor.emitter-error =================================================================== --- /pyyaml/tags/3.04/tests/data/no-alias-anchor.emitter-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/no-alias-anchor.emitter-error (revision 141) @@ -0,0 +1,8 @@ +- !StreamStart +- !DocumentStart +- !SequenceStart +- !Scalar { anchor: A, value: data } +- !Alias { } +- !SequenceEnd +- !DocumentEnd +- !StreamEnd Index: /pyyaml/tags/3.04/tests/data/float.detect =================================================================== --- /pyyaml/tags/3.04/tests/data/float.detect (revision 55) +++ /pyyaml/tags/3.04/tests/data/float.detect (revision 55) @@ -0,0 +1,1 @@ +tag:yaml.org,2002:float Index: /pyyaml/tags/3.04/tests/data/spec-09-28.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-28.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-28.data (revision 38) @@ -0,0 +1,8 @@ +| + + + literal + + text + + # Comment Index: /pyyaml/tags/3.04/tests/data/unknown.dumper-error =================================================================== --- /pyyaml/tags/3.04/tests/data/unknown.dumper-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/unknown.dumper-error (revision 141) @@ -0,0 +1,1 @@ +safe_dump(object) Index: /pyyaml/tags/3.04/tests/data/construct-python-unicode-utf8.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-unicode-utf8.data (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-unicode-utf8.data (revision 144) @@ -0,0 +1,1 @@ +--- !!python/unicode "ЭтП уМОкПЎМая стрПка" Index: /pyyaml/tags/3.04/tests/data/spec-02-02.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-02.tokens (revision 39) +++ /pyyaml/tags/3.04/tests/data/spec-02-02.tokens (revision 39) @@ -0,0 +1,5 @@ +{{ +? _ : _ +? _ : _ +? _ : _ +]} Index: /pyyaml/tags/3.04/tests/data/spec-09-18.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-18.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-18.canonical (revision 38) @@ -0,0 +1,8 @@ +%YAML 1.1 +--- +!!seq [ + !!str "literal\n", + !!str " folded\n", + !!str "keep\n\n", + !!str " strip", +] Index: /pyyaml/tags/3.04/tests/data/spec-10-04.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-04.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-10-04.data (revision 38) @@ -0,0 +1,4 @@ +block: +- one +- + - two Index: /pyyaml/tags/3.04/tests/data/spec-07-01.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-01.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-01.data (revision 38) @@ -0,0 +1,3 @@ +%FOO bar baz # Should be ignored + # with a warning. +--- "foo" Index: /pyyaml/tags/3.04/tests/data/spec-05-13.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-13.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-13.data (revision 38) @@ -0,0 +1,3 @@ + "Text containing + both space and + tab characters" Index: /pyyaml/tags/3.04/tests/data/merge.data =================================================================== --- /pyyaml/tags/3.04/tests/data/merge.data (revision 55) +++ /pyyaml/tags/3.04/tests/data/merge.data (revision 55) @@ -0,0 +1,1 @@ +- << Index: /pyyaml/tags/3.04/tests/data/spec-02-09.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-09.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-09.data (revision 38) @@ -0,0 +1,8 @@ +--- +hr: # 1998 hr ranking + - Mark McGwire + - Sammy Sosa +rbi: + # 1998 rbi ranking + - Sammy Sosa + - Ken Griffey Index: /pyyaml/tags/3.04/tests/data/serializer-is-not-opened-1.dumper-error =================================================================== --- /pyyaml/tags/3.04/tests/data/serializer-is-not-opened-1.dumper-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/serializer-is-not-opened-1.dumper-error (revision 141) @@ -0,0 +1,2 @@ +dumper = Dumper(StringIO.StringIO()) +dumper.close() Index: /pyyaml/tags/3.04/tests/data/spec-09-13.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-13.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-13.data (revision 38) @@ -0,0 +1,6 @@ +simple key : { + also simple : value, + ? not a + simple key : any + value +} Index: /pyyaml/tags/3.04/tests/data/invalid-yaml-directive-version-2.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-yaml-directive-version-2.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-yaml-directive-version-2.loader-error (revision 140) @@ -0,0 +1,2 @@ +%YAML 1e-5 +--- Index: /pyyaml/tags/3.04/tests/data/spec-07-12a.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-12a.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-12a.canonical (revision 38) @@ -0,0 +1,6 @@ +%YAML 1.1 +--- +!!map { + ? !!str "foo" + : !!str "bar" +} Index: /pyyaml/tags/3.04/tests/data/invalid-tag-handle-1.emitter-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-tag-handle-1.emitter-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/invalid-tag-handle-1.emitter-error (revision 141) @@ -0,0 +1,5 @@ +- !StreamStart +- !DocumentStart { tags: { '!foo': 'bar' } } +- !Scalar { value: 'foo' } +- !DocumentEnd +- !StreamEnd Index: /pyyaml/tags/3.04/tests/data/construct-set.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-set.code (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-set.code (revision 58) @@ -0,0 +1,4 @@ +{ + "baseball players": set(["Mark McGwire", "Sammy Sosa", "Ken Griffey"]), + "baseball teams": set(["Boston Red Sox", "Detroit Tigers", "New York Yankees"]), +} Index: /pyyaml/tags/3.04/tests/data/spec-05-01-utf8.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-01-utf8.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-01-utf8.data (revision 38) @@ -0,0 +1,1 @@ +# Comment only. Index: /pyyaml/tags/3.04/tests/data/spec-08-13.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-13.canonical (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-08-13.canonical (revision 44) @@ -0,0 +1,10 @@ +%YAML 1.1 +--- +!!map { + ? !!str "foo" +# : !!str "", +# ? !!str "" + : !!null "", + ? !!null "" + : !!str "bar", +} Index: /pyyaml/tags/3.04/tests/data/spec-05-08.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-08.canonical (revision 51) +++ /pyyaml/tags/3.04/tests/data/spec-05-08.canonical (revision 51) @@ -0,0 +1,8 @@ +%YAML 1.1 +--- +!!map { + ? !!str "single" + : !!str "text", + ? !!str "double" + : !!str "text", +} Index: /pyyaml/tags/3.04/tests/data/spec-09-06.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-06.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-06.canonical (revision 38) @@ -0,0 +1,3 @@ +%YAML 1.1 +--- +!!str "here's to \"quotes\"" Index: /pyyaml/tags/3.04/tests/data/spec-09-14.error =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-14.error (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-14.error (revision 38) @@ -0,0 +1,6 @@ +ERROR: + The --- and ... document + start and end markers must + not be specified as the + first content line of a + non-indented plain scalar. Index: /pyyaml/tags/3.04/tests/data/spec-02-11.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-11.tokens (revision 41) +++ /pyyaml/tags/3.04/tests/data/spec-02-11.tokens (revision 41) @@ -0,0 +1,6 @@ +{{ +? [[ , _ , _ ]} +: [[ , _ ]} +? [ _ , _ ] +: [ _ , _ , _ ] +]} Index: /pyyaml/tags/3.04/tests/data/no-block-mapping-end-2.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/no-block-mapping-end-2.loader-error (revision 198) +++ /pyyaml/tags/3.04/tests/data/no-block-mapping-end-2.loader-error (revision 198) @@ -0,0 +1,3 @@ +? foo +: bar +: baz Index: /pyyaml/tags/3.04/tests/data/spec-09-27.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-27.canonical (revision 48) +++ /pyyaml/tags/3.04/tests/data/spec-09-27.canonical (revision 48) @@ -0,0 +1,3 @@ +%YAML 1.1 +--- +!!str "\n\nliteral\n\ntext\n" Index: /pyyaml/tags/3.04/tests/data/spec-02-08.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-08.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-08.structure (revision 44) @@ -0,0 +1,4 @@ +[ +[(True, True), (True, True), (True, True)], +[(True, True), (True, True), (True, True)], +] Index: /pyyaml/tags/3.04/tests/data/invalid-uri-escapes-1.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-uri-escapes-1.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-uri-escapes-1.loader-error (revision 140) @@ -0,0 +1,1 @@ +--- ! foo Index: /pyyaml/tags/3.04/tests/data/spec-10-13.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-13.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-10-13.data (revision 38) @@ -0,0 +1,5 @@ +? explicit key # implicit value +? | + block key +: - one # explicit in-line + - two # block value Index: /pyyaml/tags/3.04/tests/data/spec-07-10.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-10.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-10.data (revision 38) @@ -0,0 +1,11 @@ +"Root flow + scalar" +--- !!str > + Root block + scalar +--- +# Root collection: +foo : bar +... # Is optional. +--- +# Explicit document may be empty. Index: /pyyaml/tags/3.04/tests/data/invalid-starting-character.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-starting-character.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-starting-character.loader-error (revision 140) @@ -0,0 +1,1 @@ +@@@@@@@@@@@@@@@@@@@ Index: /pyyaml/tags/3.04/tests/data/construct-map.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-map.data (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-map.data (revision 58) @@ -0,0 +1,6 @@ +# Unordered set of key: value pairs. +Block style: !!map + Clark : Evans + Brian : Ingerson + Oren : Ben-Kiki +Flow style: !!map { Clark: Evans, Brian: Ingerson, Oren: Ben-Kiki } Index: /pyyaml/tags/3.04/tests/data/spec-02-18.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-18.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-18.data (revision 38) @@ -0,0 +1,6 @@ +plain: + This unquoted scalar + spans many lines. + +quoted: "So does this + quoted scalar.\n" Index: /pyyaml/tags/3.04/tests/data/spec-09-22.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-22.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-22.data (revision 38) @@ -0,0 +1,5 @@ +strip: |- + text
clip: | + text +keep: |+ + text‹ Index: /pyyaml/tags/3.04/tests/data/spec-08-06.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-06.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-08-06.data (revision 38) @@ -0,0 +1,5 @@ +%TAG !o! tag:ben-kiki.org,2000: +--- +- !$a!b foo +- !o! bar +- !h!type baz Index: /pyyaml/tags/3.04/tests/data/timestamp-bugs.code =================================================================== --- /pyyaml/tags/3.04/tests/data/timestamp-bugs.code (revision 225) +++ /pyyaml/tags/3.04/tests/data/timestamp-bugs.code (revision 225) @@ -0,0 +1,7 @@ +[ + datetime.datetime(2001, 12, 15, 3, 29, 43, 100000), + datetime.datetime(2001, 12, 14, 16, 29, 43, 100000), + datetime.datetime(2001, 12, 14, 21, 59, 43, 1010), + datetime.datetime(2001, 12, 14, 21, 59, 43, 0, FixedOffset(60, "+1")), + datetime.datetime(2001, 12, 14, 21, 59, 43, 0, FixedOffset(-90, "-1:30")), +] Index: /pyyaml/tags/3.04/tests/data/spec-08-01.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-01.canonical (revision 42) +++ /pyyaml/tags/3.04/tests/data/spec-08-01.canonical (revision 42) @@ -0,0 +1,8 @@ +%YAML 1.1 +--- +!!map { + ? &A1 !!str "foo" + : !!str "bar", + ? &A2 !!str "baz" + : *A1 +} Index: /pyyaml/tags/3.04/tests/data/spec-07-03.error =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-03.error (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-03.error (revision 38) @@ -0,0 +1,3 @@ +ERROR: +The YAML directive must only be +given at most once per document. Index: /pyyaml/tags/3.04/tests/data/construct-str-utf8.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-str-utf8.code (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-str-utf8.code (revision 144) @@ -0,0 +1,1 @@ +u'\u042d\u0442\u043e \u0443\u043d\u0438\u043a\u043e\u0434\u043d\u0430\u044f \u0441\u0442\u0440\u043e\u043a\u0430' Index: /pyyaml/tags/3.04/tests/data/spec-09-15.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-15.canonical (revision 42) +++ /pyyaml/tags/3.04/tests/data/spec-09-15.canonical (revision 42) @@ -0,0 +1,18 @@ +%YAML 1.1 +--- +!!map { + ? !!str "---" + : !!str "foo", + ? !!str "..." + : !!str "bar" +} +%YAML 1.1 +--- +!!seq [ + !!str "---", + !!str "...", + !!map { + ? !!str "---" + : !!str "..." + } +] Index: /pyyaml/tags/3.04/tests/data/construct-str-ascii.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-str-ascii.code (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-str-ascii.code (revision 144) @@ -0,0 +1,1 @@ +"ascii string" Index: /pyyaml/tags/3.04/tests/data/spec-02-20.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-20.tokens (revision 41) +++ /pyyaml/tags/3.04/tests/data/spec-02-20.tokens (revision 41) @@ -0,0 +1,8 @@ +{{ +? _ : _ +? _ : _ +? _ : _ +? _ : _ +? _ : _ +? _ : _ +]} Index: /pyyaml/tags/3.04/tests/data/spec-02-17.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-17.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-17.structure (revision 44) @@ -0,0 +1,1 @@ +[(True, True), (True, True), (True, True), (True, True), (True, True), (True, True)] Index: /pyyaml/tags/3.04/tests/data/spec-02-03.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-03.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-03.data (revision 38) @@ -0,0 +1,8 @@ +american: + - Boston Red Sox + - Detroit Tigers + - New York Yankees +national: + - New York Mets + - Chicago Cubs + - Atlanta Braves Index: /pyyaml/tags/3.04/tests/data/invalid-python-name-kind.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-python-name-kind.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-python-name-kind.loader-error (revision 140) @@ -0,0 +1,1 @@ +--- !!python/name:sys.modules {} Index: /pyyaml/tags/3.04/tests/data/construct-python-int.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-int.data (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-int.data (revision 144) @@ -0,0 +1,1 @@ +!!python/int 123 Index: /pyyaml/tags/3.04/tests/data/construct-python-bool.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-bool.code (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-bool.code (revision 144) @@ -0,0 +1,1 @@ +[ True, False ] Index: /pyyaml/tags/3.04/tests/data/spec-06-03.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-06-03.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-06-03.data (revision 38) @@ -0,0 +1,2 @@ +key: # Comment + value Index: /pyyaml/tags/3.04/tests/data/spec-02-27.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-27.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-27.data (revision 38) @@ -0,0 +1,29 @@ +--- ! +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. Index: /pyyaml/tags/3.04/tests/data/spec-07-12b.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-12b.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-12b.data (revision 38) @@ -0,0 +1,4 @@ +# Explicit document. Root +# scalar (literal) node. +--- | + Text content Index: /pyyaml/tags/3.04/tests/data/spec-09-31.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-31.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-31.data (revision 38) @@ -0,0 +1,14 @@ +> + folded + line + + next + line + + * bullet + * list + + last + line + +# Comment Index: /pyyaml/tags/3.04/tests/data/spec-08-15.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-15.data (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-08-15.data (revision 44) @@ -0,0 +1,5 @@ +- # Empty plain scalar +- ? foo + : + ? + : bar Index: /pyyaml/tags/3.04/tests/data/construct-python-object.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-object.code (revision 147) +++ /pyyaml/tags/3.04/tests/data/construct-python-object.code (revision 147) @@ -0,0 +1,23 @@ +[ +AnObject(1, 'two', [3,3,3]), +AnInstance(1, 'two', [3,3,3]), + +AnObject(1, 'two', [3,3,3]), +AnInstance(1, 'two', [3,3,3]), + +AState(1, 'two', [3,3,3]), +ACustomState(1, 'two', [3,3,3]), + +InitArgs(1, 'two', [3,3,3]), +InitArgsWithState(1, 'two', [3,3,3]), + +NewArgs(1, 'two', [3,3,3]), +NewArgsWithState(1, 'two', [3,3,3]), + +Reduce(1, 'two', [3,3,3]), +ReduceWithState(1, 'two', [3,3,3]), + +MyInt(3), +MyList(3), +MyDict(3), +] Index: /pyyaml/tags/3.04/tests/data/recursive.former-dumper-error =================================================================== --- /pyyaml/tags/3.04/tests/data/recursive.former-dumper-error (revision 222) +++ /pyyaml/tags/3.04/tests/data/recursive.former-dumper-error (revision 222) @@ -0,0 +1,3 @@ +data = [] +data.append(data) +dump(data) Index: /pyyaml/tags/3.04/tests/data/spec-08-10.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-10.canonical (revision 48) +++ /pyyaml/tags/3.04/tests/data/spec-08-10.canonical (revision 48) @@ -0,0 +1,23 @@ +%YAML 1.1 +--- +!!map { + ? !!str "block styles" : !!map { + ? !!str "scalars" : !!map { + ? !!str "literal" + : !!str "#!/usr/bin/perl\n\ + print \"Hello, + world!\\n\";\n", + ? !!str "folded" + : !!str "This sentence + is false.\n" + }, + ? !!str "collections" : !!map { + ? !!str "sequence" : !!seq [ + !!str "entry", + !!map { + ? !!str "key" : !!str "value" + } + ], + ? !!str "mapping" : !!map { + ? !!str "key" : !!str "value" +} } } } Index: /pyyaml/tags/3.04/tests/data/spec-09-03.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-03.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-03.canonical (revision 38) @@ -0,0 +1,7 @@ +%YAML 1.1 +--- +!!seq [ + !!str " last", + !!str " last", + !!str " \tfirst last", +] Index: /pyyaml/tags/3.04/tests/data/spec-05-15.error =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-15.error (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-15.error (revision 38) @@ -0,0 +1,3 @@ +ERROR: +- c is an invalid escaped character. +- q and - are invalid hex digits. Index: /pyyaml/tags/3.04/tests/data/spec-09-24.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-24.canonical (revision 42) +++ /pyyaml/tags/3.04/tests/data/spec-09-24.canonical (revision 42) @@ -0,0 +1,10 @@ +%YAML 1.1 +--- +!!map { + ? !!str "strip" + : !!str "", + ? !!str "clip" + : !!str "", + ? !!str "keep" + : !!str "\n", +} Index: /pyyaml/tags/3.04/tests/data/spec-02-05.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-05.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-05.structure (revision 44) @@ -0,0 +1,5 @@ +[ + [True, True, True], + [True, True, True], + [True, True, True], +] Index: /pyyaml/tags/3.04/tests/data/serializer-is-already-opened.dumper-error =================================================================== --- /pyyaml/tags/3.04/tests/data/serializer-is-already-opened.dumper-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/serializer-is-already-opened.dumper-error (revision 141) @@ -0,0 +1,3 @@ +dumper = Dumper(StringIO.StringIO()) +dumper.open() +dumper.open() Index: /pyyaml/tags/3.04/tests/data/scalars.events =================================================================== --- /pyyaml/tags/3.04/tests/data/scalars.events (revision 137) +++ /pyyaml/tags/3.04/tests/data/scalars.events (revision 137) @@ -0,0 +1,28 @@ +- !StreamStart + +- !DocumentStart +- !MappingStart +- !Scalar { implicit: [true,true], value: 'empty scalar' } +- !Scalar { implicit: [true,false], value: '' } +- !Scalar { implicit: [true,true], value: 'implicit scalar' } +- !Scalar { implicit: [true,true], value: 'data' } +- !Scalar { implicit: [true,true], value: 'quoted scalar' } +- !Scalar { value: 'data', style: '"' } +- !Scalar { implicit: [true,true], value: 'block scalar' } +- !Scalar { value: 'data', style: '|' } +- !Scalar { implicit: [true,true], value: 'empty scalar with tag' } +- !Scalar { implicit: [false,false], tag: '!mytag', value: '' } +- !Scalar { implicit: [true,true], value: 'implicit scalar with tag' } +- !Scalar { implicit: [false,false], tag: '!mytag', value: 'data' } +- !Scalar { implicit: [true,true], value: 'quoted scalar with tag' } +- !Scalar { value: 'data', style: '"', tag: '!mytag', implicit: [false,false] } +- !Scalar { implicit: [true,true], value: 'block scalar with tag' } +- !Scalar { value: 'data', style: '|', tag: '!mytag', implicit: [false,false] } +- !Scalar { implicit: [true,true], value: 'single character' } +- !Scalar { value: 'a', implicit: [true,true] } +- !Scalar { implicit: [true,true], value: 'single digit' } +- !Scalar { value: '1', implicit: [true,false] } +- !MappingEnd +- !DocumentEnd + +- !StreamEnd Index: /pyyaml/tags/3.04/tests/data/spec-02-26.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-26.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-26.structure (revision 44) @@ -0,0 +1,5 @@ +[ +[(True, True)], +[(True, True)], +[(True, True)], +] Index: /pyyaml/tags/3.04/tests/data/invalid-pairs-2.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-pairs-2.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-pairs-2.loader-error (revision 140) @@ -0,0 +1,3 @@ +--- !!pairs +- foo: bar +- baz Index: /pyyaml/tags/3.04/tests/data/spec-02-07.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-07.tokens (revision 39) +++ /pyyaml/tags/3.04/tests/data/spec-02-07.tokens (revision 39) @@ -0,0 +1,12 @@ +--- +[[ +, _ +, _ +, _ +]} + +--- +[[ +, _ +, _ +]} Index: /pyyaml/tags/3.04/tests/data/construct-float.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-float.code (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-float.code (revision 58) @@ -0,0 +1,8 @@ +{ + "canonical": 685230.15, + "exponential": 685230.15, + "fixed": 685230.15, + "sexagesimal": 685230.15, + "negative infinity": -1e300000, + "not a number": 1e300000/1e300000, +} Index: /pyyaml/tags/3.04/tests/data/spec-02-12.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-12.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-12.data (revision 38) @@ -0,0 +1,8 @@ +--- +# products purchased +- item : Super Hoop + quantity: 1 +- item : Basketball + quantity: 4 +- item : Big Shoes + quantity: 1 Index: /pyyaml/tags/3.04/tests/data/invalid-yaml-version.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-yaml-version.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-yaml-version.loader-error (revision 140) @@ -0,0 +1,2 @@ +%YAML 2.0 +--- foo Index: /pyyaml/tags/3.04/tests/data/serializer-is-closed-1.dumper-error =================================================================== --- /pyyaml/tags/3.04/tests/data/serializer-is-closed-1.dumper-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/serializer-is-closed-1.dumper-error (revision 141) @@ -0,0 +1,4 @@ +dumper = Dumper(StringIO.StringIO()) +dumper.open() +dumper.close() +dumper.open() Index: /pyyaml/tags/3.04/tests/data/spec-07-08.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-08.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-08.data (revision 38) @@ -0,0 +1,9 @@ +# Explicitly specify default settings: +%TAG ! ! +%TAG !! tag:yaml.org,2002: +# Named handles have no default: +%TAG !o! tag:ben-kiki.org,2000: +--- +- !foo "bar" +- !!str "string" +- !o!type "baz" Index: /pyyaml/tags/3.04/tests/data/invalid-base64-data.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-base64-data.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-base64-data.loader-error (revision 140) @@ -0,0 +1,2 @@ +--- !!binary + binary data encoded in base64 should be here. Index: /pyyaml/tags/3.04/tests/data/invalid-omap-2.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-omap-2.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-omap-2.loader-error (revision 140) @@ -0,0 +1,3 @@ +--- !!omap +- foo: bar +- baz Index: /pyyaml/tags/3.04/tests/data/spec-10-07.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-07.canonical (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-10-07.canonical (revision 44) @@ -0,0 +1,16 @@ +%YAML 1.1 +--- +!!map { + ? !!null "" + : !!str "value", + ? !!str "explicit key" + : !!str "value", + ? !!str "simple key" + : !!str "value", + ? !!seq [ + !!str "collection", + !!str "simple", + !!str "key" + ] + : !!str "value" +} Index: /pyyaml/tags/3.04/tests/data/invalid-tag-handle-2.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-tag-handle-2.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-tag-handle-2.loader-error (revision 140) @@ -0,0 +1,2 @@ +%TAG !foo bar +--- Index: /pyyaml/tags/3.04/tests/data/spec-05-14.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-14.canonical (revision 42) +++ /pyyaml/tags/3.04/tests/data/spec-05-14.canonical (revision 42) @@ -0,0 +1,7 @@ +%YAML 1.1 +--- +"Fun with \x5C + \x22 \x07 \x08 \x1B \x0C + \x0A \x0D \x09 \x0B \x00 + \x20 \xA0 \x85 \u2028 \u2029 + A A A" Index: /pyyaml/tags/3.04/tests/data/spec-09-12.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-12.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-12.canonical (revision 38) @@ -0,0 +1,12 @@ +%YAML 1.1 +--- +!!seq [ + !!str "::std::vector", + !!str "Up, up, and away!", + !!int "-123", + !!seq [ + !!str "::std::vector", + !!str "Up, up, and away!", + !!int "-123", + ] +] Index: /pyyaml/tags/3.04/tests/data/spec-06-07.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-06-07.canonical (revision 42) +++ /pyyaml/tags/3.04/tests/data/spec-06-07.canonical (revision 42) @@ -0,0 +1,6 @@ +%YAML 1.1 +--- +!!seq [ + !!str "foo\nbar", + !!str "foo\n\nbar" +] Index: /pyyaml/tags/3.04/tests/data/spec-09-33.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-33.canonical (revision 51) +++ /pyyaml/tags/3.04/tests/data/spec-09-33.canonical (revision 51) @@ -0,0 +1,7 @@ +%YAML 1.1 +--- +!!str "folded line\n\ + next line\n\n\ + \ * bullet\n\ + \ * list\n\n\ + last line\n" Index: /pyyaml/tags/3.04/tests/data/invalid-python-name-value.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-python-name-value.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-python-name-value.loader-error (revision 140) @@ -0,0 +1,1 @@ +--- !!python/name:sys.modules 5 Index: /pyyaml/tags/3.04/tests/data/spec-02-14.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-14.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-14.structure (revision 44) @@ -0,0 +1,1 @@ +True Index: /pyyaml/tags/3.04/tests/data/no-block-mapping-end.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/no-block-mapping-end.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/no-block-mapping-end.loader-error (revision 140) @@ -0,0 +1,1 @@ +foo: "bar" "baz" Index: /pyyaml/tags/3.04/tests/data/recursive-dict.recursive =================================================================== --- /pyyaml/tags/3.04/tests/data/recursive-dict.recursive (revision 222) +++ /pyyaml/tags/3.04/tests/data/recursive-dict.recursive (revision 222) @@ -0,0 +1,3 @@ +value = {} +instance = AnInstance(value, value) +value[instance] = instance Index: /pyyaml/tags/3.04/tests/data/spec-02-16.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-16.tokens (revision 41) +++ /pyyaml/tags/3.04/tests/data/spec-02-16.tokens (revision 41) @@ -0,0 +1,5 @@ +{{ +? _ : _ +? _ : _ +? _ : _ +]} Index: /pyyaml/tags/3.04/tests/data/invalid-simple-key.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-simple-key.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-simple-key.loader-error (revision 140) @@ -0,0 +1,3 @@ +key: value +invalid simple key +next key: next value Index: /pyyaml/tags/3.04/tests/data/spec-02-21.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-21.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-21.data (revision 38) @@ -0,0 +1,4 @@ +null: ~ +true: y +false: n +string: '12345' Index: /pyyaml/tags/3.04/tests/data/spec-05-05.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-05.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-05.data (revision 38) @@ -0,0 +1,1 @@ +# Comment only. Index: /pyyaml/tags/3.04/tests/data/sloppy-indentation.data =================================================================== --- /pyyaml/tags/3.04/tests/data/sloppy-indentation.data (revision 117) +++ /pyyaml/tags/3.04/tests/data/sloppy-indentation.data (revision 117) @@ -0,0 +1,17 @@ +--- +in the block context: + indentation should be kept: { + but in the flow context: [ +it may be violated] +} +--- +the parser does not require scalars +to be indented with at least one space +... +--- +"the parser does not require scalars +to be indented with at least one space" +--- +foo: + bar: 'quoted scalars +may not adhere indentation' Index: /pyyaml/tags/3.04/tests/data/resolver.data =================================================================== --- /pyyaml/tags/3.04/tests/data/resolver.data (revision 137) +++ /pyyaml/tags/3.04/tests/data/resolver.data (revision 137) @@ -0,0 +1,30 @@ +--- +"this scalar should be selected" +--- +key11: !foo + key12: + is: [selected] + key22: + key13: [not, selected] + key23: [not, selected] + key32: + key31: [not, selected] + key32: [not, selected] + key33: {not: selected} +key21: !bar + - not selected + - selected + - not selected +key31: !baz + key12: + key13: + key14: {selected} + key23: + key14: [not, selected] + key33: + key14: {selected} + key24: {not: selected} + key22: + - key14: {selected} + key24: {not: selected} + - key14: {selected} Index: /pyyaml/tags/3.04/tests/data/spec-09-05.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-05.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-05.data (revision 38) @@ -0,0 +1,8 @@ +- "first + " +- "first + + last" +- "first + inner + \ last" Index: /pyyaml/tags/3.04/tests/data/fetch-complex-value-bug.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/fetch-complex-value-bug.loader-error (revision 188) +++ /pyyaml/tags/3.04/tests/data/fetch-complex-value-bug.loader-error (revision 188) @@ -0,0 +1,2 @@ +? "foo" + : "bar" Index: /pyyaml/tags/3.04/tests/data/spec-09-29.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-29.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-29.data (revision 38) @@ -0,0 +1,4 @@ +> # Simple folded scalar + folded + text + lines Index: /pyyaml/tags/3.04/tests/data/spec-05-10.error =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-10.error (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-10.error (revision 38) @@ -0,0 +1,3 @@ +ERROR: + Reserved indicators can't + start a plain scalar. Index: /pyyaml/tags/3.04/tests/data/spec-02-02.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-02.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-02.structure (revision 44) @@ -0,0 +1,1 @@ +[(True, True), (True, True), (True, True)] Index: /pyyaml/tags/3.04/tests/data/spec-06-02.empty =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-06-02.empty (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-06-02.empty (revision 38) @@ -0,0 +1,2 @@ +# This stream contains no +# documents, only comments. Index: /pyyaml/tags/3.04/tests/data/spec-02-23.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-23.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-23.structure (revision 44) @@ -0,0 +1,1 @@ +[(True, True), (True, True), (True, True)] Index: /pyyaml/tags/3.04/tests/data/spec-07-09.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-09.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-09.canonical (revision 38) @@ -0,0 +1,9 @@ +%YAML 1.1 +--- +!!str "foo" +%YAML 1.1 +--- +!!str "bar" +%YAML 1.1 +--- +!!str "baz" Index: /pyyaml/tags/3.04/tests/data/duplicate-merge-key.former-loader-error.code =================================================================== --- /pyyaml/tags/3.04/tests/data/duplicate-merge-key.former-loader-error.code (revision 222) +++ /pyyaml/tags/3.04/tests/data/duplicate-merge-key.former-loader-error.code (revision 222) @@ -0,0 +1,1 @@ +{ 'x': 1, 'y': 2, 'foo': 'bar', 'z': 3, 't': 4 } Index: /pyyaml/tags/3.04/tests/data/scan-line-break-bug.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/scan-line-break-bug.canonical (revision 60) +++ /pyyaml/tags/3.04/tests/data/scan-line-break-bug.canonical (revision 60) @@ -0,0 +1,3 @@ +%YAML 1.1 +--- +!!map { ? !!str "foo" : !!str "bar baz" } Index: /pyyaml/tags/3.04/tests/data/spec-02-25.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-25.tokens (revision 41) +++ /pyyaml/tags/3.04/tests/data/spec-02-25.tokens (revision 41) @@ -0,0 +1,6 @@ +--- ! +{{ +? _ +? _ +? _ +]} Index: /pyyaml/tags/3.04/tests/data/spec-10-05.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-05.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-10-05.data (revision 38) @@ -0,0 +1,7 @@ +- # Empty +- | + block node +- - one # in-line + - two # sequence +- one: two # in-line + # mapping Index: /pyyaml/tags/3.04/tests/data/expected-sequence.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/expected-sequence.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/expected-sequence.loader-error (revision 140) @@ -0,0 +1,1 @@ +--- !!seq {foo, bar, baz} Index: /pyyaml/tags/3.04/tests/data/spec-07-02.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-02.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-02.data (revision 38) @@ -0,0 +1,4 @@ +%YAML 1.2 # Attempt parsing + # with a warning +--- +"foo" Index: /pyyaml/tags/3.04/tests/data/construct-custom.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-custom.code (revision 136) +++ /pyyaml/tags/3.04/tests/data/construct-custom.code (revision 136) @@ -0,0 +1,10 @@ +[ + MyTestClass1(x=1), + MyTestClass1(x=1, y=2, z=3), + MyTestClass2(x=10), + MyTestClass2(x=10, y=20, z=30), + MyTestClass3(x=1), + MyTestClass3(x=1, y=2, z=3), + MyTestClass3(x=1, y=2, z=3), + YAMLObject1(my_parameter='foo', my_another_parameter=[1,2,3]) +] Index: /pyyaml/tags/3.04/tests/data/spec-05-14.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-14.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-14.data (revision 38) @@ -0,0 +1,3 @@ +"Fun with \\ + \" \a \b \e \f \ + \n \r \t \v \0 \‹ \ \_ \N \L \P \
 \x41 \u0041 \U00000041" Index: /pyyaml/tags/3.04/tests/data/invalid-python-module-kind.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-python-module-kind.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-python-module-kind.loader-error (revision 140) @@ -0,0 +1,1 @@ +--- !!python/module:sys { must, be, scalar } Index: /pyyaml/tags/3.04/tests/data/spec-09-14.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-14.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-14.data (revision 38) @@ -0,0 +1,14 @@ +--- +--- ||| : foo +... >>>: bar +--- +[ +--- +, +... , +{ +--- : +... # Nested +} +] +... Index: /pyyaml/tags/3.04/tests/data/invalid-character.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-character.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-character.loader-error (revision 140) @@ -0,0 +1,18 @@ +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +Control character ('\x0'): <-- +------------------------------------------------------------------------------------------------------------------------------- Index: /pyyaml/tags/3.04/tests/data/duplicate-anchor-2.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/duplicate-anchor-2.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/duplicate-anchor-2.loader-error (revision 140) @@ -0,0 +1,1 @@ +&foo [1, 2, 3, &foo 4] Index: /pyyaml/tags/3.04/tests/data/spec-10-04.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-04.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-10-04.canonical (revision 38) @@ -0,0 +1,11 @@ +%YAML 1.1 +--- +!!map { + ? !!str "block" + : !!seq [ + !!str "one", + !!seq [ + !!str "two" + ] + ] +} Index: /pyyaml/tags/3.04/tests/data/emit-block-scalar-in-simple-key-context-bug.data =================================================================== --- /pyyaml/tags/3.04/tests/data/emit-block-scalar-in-simple-key-context-bug.data (revision 218) +++ /pyyaml/tags/3.04/tests/data/emit-block-scalar-in-simple-key-context-bug.data (revision 218) @@ -0,0 +1,4 @@ +? |- + foo +: |- + bar Index: /pyyaml/tags/3.04/tests/data/spec-05-11.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-11.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-11.canonical (revision 38) @@ -0,0 +1,6 @@ +%YAML 1.1 +--- !!str +"Generic line break (no glyph)\n\ + Generic line break (glyphed)\n\ + Line separator\u2028\ + Paragraph separator\u2029" Index: /pyyaml/tags/3.04/tests/data/invalid-single-quote-bug.data =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-single-quote-bug.data (revision 197) +++ /pyyaml/tags/3.04/tests/data/invalid-single-quote-bug.data (revision 197) @@ -0,0 +1,2 @@ +- "foo 'bar'" +- "foo\n'bar'" Index: /pyyaml/tags/3.04/tests/data/spec-06-04.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-06-04.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-06-04.canonical (revision 38) @@ -0,0 +1,6 @@ +%YAML 1.1 +--- +!!map { + ? !!str "key" + : !!str "value" +} Index: /pyyaml/tags/3.04/tests/data/spec-09-30.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-30.canonical (revision 51) +++ /pyyaml/tags/3.04/tests/data/spec-09-30.canonical (revision 51) @@ -0,0 +1,7 @@ +%YAML 1.1 +--- +!!str "folded line\n\ + next line\n\n\ + \ * bullet\n\ + \ * list\n\n\ + last line\n" Index: /pyyaml/tags/3.04/tests/data/construct-python-unicode-ascii.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-unicode-ascii.code (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-unicode-ascii.code (revision 144) @@ -0,0 +1,1 @@ +u"ascii string" Index: /pyyaml/tags/3.04/tests/data/scan-document-end-bug.data =================================================================== --- /pyyaml/tags/3.04/tests/data/scan-document-end-bug.data (revision 138) +++ /pyyaml/tags/3.04/tests/data/scan-document-end-bug.data (revision 138) @@ -0,0 +1,3 @@ +# Ticket #4 +--- +... Index: /pyyaml/tags/3.04/tests/data/spec-02-11.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-11.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-11.structure (revision 44) @@ -0,0 +1,4 @@ +[ +([True, True], [True]), +([True, True], [True, True, True]), +] Index: /pyyaml/tags/3.04/tests/data/invalid-tag-1.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-tag-1.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-tag-1.loader-error (revision 140) @@ -0,0 +1,1 @@ +- ! baz Index: /pyyaml/tags/3.04/tests/data/invalid-python-name-module-2.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-python-name-module-2.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-python-name-module-2.loader-error (revision 140) @@ -0,0 +1,1 @@ +--- !!python/name:xml.parsers Index: /pyyaml/tags/3.04/tests/data/spec-10-14.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-14.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-10-14.data (revision 38) @@ -0,0 +1,4 @@ +plain key: # empty value +"quoted key": +- one # explicit next-line +- two # block value Index: /pyyaml/tags/3.04/tests/data/spec-07-11.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-11.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-11.data (revision 38) @@ -0,0 +1,2 @@ +# A stream may contain +# no documents. Index: /pyyaml/tags/3.04/tests/data/spec-02-19.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-19.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-19.data (revision 38) @@ -0,0 +1,5 @@ +canonical: 12345 +decimal: +12,345 +sexagesimal: 3:25:45 +octal: 014 +hexadecimal: 0xC Index: /pyyaml/tags/3.04/tests/data/spec-09-23.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-23.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-23.data (revision 38) @@ -0,0 +1,15 @@ + # Strip + # Comments: +strip: |- + # text
 ‹ # Clip + # comments: + +clip: | + # text + 
 # Keep + # comments: + +keep: |+ + # text‹ + # Trail + # comments. Index: /pyyaml/tags/3.04/tests/data/spec-08-07.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-07.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-08-07.data (revision 38) @@ -0,0 +1,4 @@ +# Assuming conventional resolution: +- "12" +- 12 +- ! 12 Index: /pyyaml/tags/3.04/tests/data/construct-binary.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-binary.data (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-binary.data (revision 58) @@ -0,0 +1,12 @@ +canonical: !!binary "\ + R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5\ + OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+\ + +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC\ + AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=" +generic: !!binary | + R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5 + OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+ + +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC + AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs= +description: + The binary value above is a tiny arrow encoded as a gif image. Index: /pyyaml/tags/3.04/tests/data/spec-10-13.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-13.canonical (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-10-13.canonical (revision 44) @@ -0,0 +1,11 @@ +%YAML 1.1 +--- +!!map { + ? !!str "explicit key" + : !!null "", + ? !!str "block key\n" + : !!seq [ + !!str "one", + !!str "two", + ] +} Index: /pyyaml/tags/3.04/tests/data/expected-node-1.emitter-error =================================================================== --- /pyyaml/tags/3.04/tests/data/expected-node-1.emitter-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/expected-node-1.emitter-error (revision 141) @@ -0,0 +1,4 @@ +- !StreamStart +- !DocumentStart +- !DocumentEnd +- !StreamEnd Index: /pyyaml/tags/3.04/tests/data/spec-07-06.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-06.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-06.canonical (revision 38) @@ -0,0 +1,6 @@ +%YAML 1.1 +--- +!!seq [ + ! "baz", + ! "string" +] Index: /pyyaml/tags/3.04/tests/data/spec-02-20.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-20.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-20.structure (revision 44) @@ -0,0 +1,1 @@ +[(True, True), (True, True), (True, True), (True, True), (True, True), (True, True)] Index: /pyyaml/tags/3.04/tests/data/spec-02-03.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-03.tokens (revision 39) +++ /pyyaml/tags/3.04/tests/data/spec-02-03.tokens (revision 39) @@ -0,0 +1,4 @@ +{{ +? _ : [[ , _ , _ , _ ]} +? _ : [[ , _ , _ , _ ]} +]} Index: /pyyaml/tags/3.04/tests/data/recursive-state.recursive =================================================================== --- /pyyaml/tags/3.04/tests/data/recursive-state.recursive (revision 222) +++ /pyyaml/tags/3.04/tests/data/recursive-state.recursive (revision 222) @@ -0,0 +1,2 @@ +value = [] +value.append(AnInstanceWithState(value, value)) Index: /pyyaml/tags/3.04/tests/data/spec-02-04.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-04.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-04.data (revision 38) @@ -0,0 +1,8 @@ +- + name: Mark McGwire + hr: 65 + avg: 0.278 +- + name: Sammy Sosa + hr: 63 + avg: 0.288 Index: /pyyaml/tags/3.04/tests/data/construct-python-str-utf8.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-str-utf8.code (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-str-utf8.code (revision 144) @@ -0,0 +1,1 @@ +u'\u042d\u0442\u043e \u0443\u043d\u0438\u043a\u043e\u0434\u043d\u0430\u044f \u0441\u0442\u0440\u043e\u043a\u0430'.encode('utf-8') Index: /pyyaml/tags/3.04/tests/data/spec-06-04.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-06-04.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-06-04.data (revision 38) @@ -0,0 +1,4 @@ +key: # Comment + # lines + value + Index: /pyyaml/tags/3.04/tests/data/spec-02-28.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-28.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-28.data (revision 38) @@ -0,0 +1,26 @@ +--- +Time: 2001-11-23 15:01:42 -5 +User: ed +Warning: + This is an error message + for the log file +--- +Time: 2001-11-23 15:02:31 -5 +User: ed +Warning: + A slightly different error + message. +--- +Date: 2001-11-23 15:03:17 -5 +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 Index: /pyyaml/tags/3.04/tests/data/spec-09-32.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-32.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-32.data (revision 38) @@ -0,0 +1,14 @@ +> + folded + line + + next + line + + * bullet + * list + + last + line + +# Comment Index: /pyyaml/tags/3.04/tests/data/spec-10-01.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-01.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-10-01.canonical (revision 38) @@ -0,0 +1,12 @@ +%YAML 1.1 +--- +!!seq [ + !!seq [ + !!str "inner", + !!str "inner", + ], + !!seq [ + !!str "inner", + !!str "last", + ], +] Index: /pyyaml/tags/3.04/tests/data/spec-06-01.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-06-01.canonical (revision 51) +++ /pyyaml/tags/3.04/tests/data/spec-06-01.canonical (revision 51) @@ -0,0 +1,15 @@ +%YAML 1.1 +--- +!!map { + ? !!str "Not indented" + : !!map { + ? !!str "By one space" + : !!str "By four\n spaces\n", + ? !!str "Flow style" + : !!seq [ + !!str "By two", + !!str "Also by two", + !!str "Still by two", + ] + } +} Index: /pyyaml/tags/3.04/tests/data/construct-python-complex.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-complex.code (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-complex.code (revision 144) @@ -0,0 +1,1 @@ +[0.5+0j, 0.5+0.5j, 0.5j, -0.5+0.5j, -0.5+0j, -0.5-0.5j, -0.5j, 0.5-0.5j] Index: /pyyaml/tags/3.04/tests/data/duplicate-yaml-directive.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/duplicate-yaml-directive.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/duplicate-yaml-directive.loader-error (revision 140) @@ -0,0 +1,3 @@ +%YAML 1.1 +%YAML 1.1 +--- foo Index: /pyyaml/tags/3.04/tests/data/invalid-yaml-directive-version-5.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-yaml-directive-version-5.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-yaml-directive-version-5.loader-error (revision 140) @@ -0,0 +1,2 @@ +%YAML A.0 +--- Index: /pyyaml/tags/3.04/tests/data/construct-int.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-int.data (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-int.data (revision 58) @@ -0,0 +1,6 @@ +canonical: 685230 +decimal: +685_230 +octal: 02472256 +hexadecimal: 0x_0A_74_AE +binary: 0b1010_0111_0100_1010_1110 +sexagesimal: 190:20:30 Index: /pyyaml/tags/3.04/tests/data/expected-mapping.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/expected-mapping.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/expected-mapping.loader-error (revision 140) @@ -0,0 +1,1 @@ +--- !!map [not, a, map] Index: /pyyaml/tags/3.04/tests/data/negative-float-bug.code =================================================================== --- /pyyaml/tags/3.04/tests/data/negative-float-bug.code (revision 171) +++ /pyyaml/tags/3.04/tests/data/negative-float-bug.code (revision 171) @@ -0,0 +1,1 @@ +-1.0 Index: /pyyaml/tags/3.04/tests/data/no-node-1.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/no-node-1.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/no-node-1.loader-error (revision 140) @@ -0,0 +1,1 @@ +- !foo ] Index: /pyyaml/tags/3.04/tests/data/spec-08-08.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-08.canonical (revision 48) +++ /pyyaml/tags/3.04/tests/data/spec-08-08.canonical (revision 48) @@ -0,0 +1,15 @@ +%YAML 1.1 +--- +!!map { + ? !!str "foo" + : !!str "bar baz" +} +%YAML 1.1 +--- +!!str "foo bar" +%YAML 1.1 +--- +!!str "foo bar" +%YAML 1.1 +--- +!!str "foo\n" Index: /pyyaml/tags/3.04/tests/data/spec-02-12.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-12.tokens (revision 41) +++ /pyyaml/tags/3.04/tests/data/spec-02-12.tokens (revision 41) @@ -0,0 +1,6 @@ +--- +[[ +, {{ ? _ : _ ? _ : _ ]} +, {{ ? _ : _ ? _ : _ ]} +, {{ ? _ : _ ? _ : _ ]} +]} Index: /pyyaml/tags/3.04/tests/data/empty-tag-handle.emitter-error =================================================================== --- /pyyaml/tags/3.04/tests/data/empty-tag-handle.emitter-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/empty-tag-handle.emitter-error (revision 141) @@ -0,0 +1,5 @@ +- !StreamStart +- !DocumentStart { tags: { '': 'bar' } } +- !Scalar { value: 'foo' } +- !DocumentEnd +- !StreamEnd Index: /pyyaml/tags/3.04/tests/data/more-floats.code =================================================================== --- /pyyaml/tags/3.04/tests/data/more-floats.code (revision 177) +++ /pyyaml/tags/3.04/tests/data/more-floats.code (revision 177) @@ -0,0 +1,1 @@ +[0.0, +1.0, -1.0, +1e300000, -1e300000, 1e300000/1e300000, -(1e300000/1e300000)] # last two items are ind and qnan respectively. Index: /pyyaml/tags/3.04/tests/data/spec-02-13.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-13.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-13.data (revision 38) @@ -0,0 +1,4 @@ +# ASCII Art +--- | + \//||\/|| + // || ||__ Index: /pyyaml/tags/3.04/tests/data/construct-str.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-str.data (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-str.data (revision 58) @@ -0,0 +1,1 @@ +string: abcd Index: /pyyaml/tags/3.04/tests/data/construct-null.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-null.data (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-null.data (revision 58) @@ -0,0 +1,18 @@ +# A document may be null. +--- +--- +# This mapping has four keys, +# one has a value. +empty: +canonical: ~ +english: null +~: null key +--- +# This sequence has five +# entries, two have values. +sparse: + - ~ + - 2nd entry + - + - 4th entry + - Null Index: /pyyaml/tags/3.04/tests/data/spec-08-01.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-01.data (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-08-01.data (revision 44) @@ -0,0 +1,2 @@ +!!str &a1 "foo" : !!str bar +&a2 baz : *a1 Index: /pyyaml/tags/3.04/tests/data/emitting-unacceptable-unicode-character-bug.data =================================================================== --- /pyyaml/tags/3.04/tests/data/emitting-unacceptable-unicode-character-bug.data (revision 154) +++ /pyyaml/tags/3.04/tests/data/emitting-unacceptable-unicode-character-bug.data (revision 154) @@ -0,0 +1,1 @@ +"\udd00" Index: /pyyaml/tags/3.04/tests/data/merge.detect =================================================================== --- /pyyaml/tags/3.04/tests/data/merge.detect (revision 55) +++ /pyyaml/tags/3.04/tests/data/merge.detect (revision 55) @@ -0,0 +1,1 @@ +tag:yaml.org,2002:merge Index: /pyyaml/tags/3.04/tests/data/invalid-utf8-byte.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-utf8-byte.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-utf8-byte.loader-error (revision 140) @@ -0,0 +1,18 @@ +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +Invalid byte ('\xFF'): ÿ <-- +------------------------------------------------------------------------------------------------------------------------------- Index: /pyyaml/tags/3.04/tests/data/invalid-escape-character.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-escape-character.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-escape-character.loader-error (revision 140) @@ -0,0 +1,1 @@ +"some escape characters are \ncorrect, but this one \?\nis not\n" Index: /pyyaml/tags/3.04/tests/data/spec-07-09.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-09.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-09.data (revision 38) @@ -0,0 +1,11 @@ +--- +foo +... +# Repeated end marker. +... +--- +bar +# No end marker. +--- +baz +... Index: /pyyaml/tags/3.04/tests/data/spec-10-10.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-10.canonical (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-10-10.canonical (revision 44) @@ -0,0 +1,16 @@ +%YAML 1.1 +--- +!!map { + ? !!str "explicit key1" + : !!str "explicit value", + ? !!str "explicit key2" + : !!null "", + ? !!str "explicit key3" + : !!null "", + ? !!str "simple key1" + : !!str "explicit value", + ? !!str "simple key2" + : !!null "", + ? !!str "simple key3" + : !!null "", +} Index: /pyyaml/tags/3.04/tests/data/invalid-merge-2.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-merge-2.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-merge-2.loader-error (revision 140) @@ -0,0 +1,2 @@ +foo: bar +<<: [x: 1, y: 2, z, t: 4] Index: /pyyaml/tags/3.04/tests/data/construct-seq.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-seq.data (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-seq.data (revision 58) @@ -0,0 +1,15 @@ +# Ordered sequence of nodes +Block style: !!seq +- Mercury # Rotates - no light/dark sides. +- Venus # Deadliest. Aptly named. +- Earth # Mostly dirt. +- Mars # Seems empty. +- Jupiter # The king. +- Saturn # Pretty. +- Uranus # Where the sun hardly shines. +- Neptune # Boring. No rings. +- Pluto # You call this a planet? +Flow style: !!seq [ Mercury, Venus, Earth, Mars, # Rocks + Jupiter, Saturn, Uranus, Neptune, # Gas + Pluto ] # Overrated + Index: /pyyaml/tags/3.04/tests/data/construct-python-unicode-utf8.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-unicode-utf8.code (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-unicode-utf8.code (revision 144) @@ -0,0 +1,1 @@ +u'\u042d\u0442\u043e \u0443\u043d\u0438\u043a\u043e\u0434\u043d\u0430\u044f \u0441\u0442\u0440\u043e\u043a\u0430' Index: /pyyaml/tags/3.04/tests/data/aliases.events =================================================================== --- /pyyaml/tags/3.04/tests/data/aliases.events (revision 130) +++ /pyyaml/tags/3.04/tests/data/aliases.events (revision 130) @@ -0,0 +1,8 @@ +- !StreamStart +- !DocumentStart +- !SequenceStart +- !Scalar { anchor: 'myanchor', tag: '!mytag', value: 'data' } +- !Alias { anchor: 'myanchor' } +- !SequenceEnd +- !DocumentEnd +- !StreamEnd Index: /pyyaml/tags/3.04/tests/data/spec-02-21.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-21.tokens (revision 41) +++ /pyyaml/tags/3.04/tests/data/spec-02-21.tokens (revision 41) @@ -0,0 +1,6 @@ +{{ +? _ : _ +? _ : _ +? _ : _ +? _ : _ +]} Index: /pyyaml/tags/3.04/tests/data/resolver.path =================================================================== --- /pyyaml/tags/3.04/tests/data/resolver.path (revision 137) +++ /pyyaml/tags/3.04/tests/data/resolver.path (revision 137) @@ -0,0 +1,30 @@ +--- !root/scalar +"this scalar should be selected" +--- !root +key11: !foo + key12: !root/key11/key12/* + is: [selected] + key22: + key13: [not, selected] + key23: [not, selected] + key32: + key31: [not, selected] + key32: [not, selected] + key33: {not: selected} +key21: !bar + - not selected + - !root/key21/1/* selected + - not selected +key31: !baz + key12: + key13: + key14: !root/key31/*/*/key14/map {selected} + key23: + key14: [not, selected] + key33: + key14: !root/key31/*/*/key14/map {selected} + key24: {not: selected} + key22: + - key14: !root/key31/*/*/key14/map {selected} + key24: {not: selected} + - key14: !root/key31/*/*/key14/map {selected} Index: /pyyaml/tags/3.04/tests/data/spec-05-02-utf16be.error =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-02-utf16be.error (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-02-utf16be.error (revision 38) @@ -0,0 +1,3 @@ +ERROR: + A BOM must not appear + inside a document. Index: /pyyaml/tags/3.04/tests/data/spec-02-22.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-22.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-22.data (revision 38) @@ -0,0 +1,4 @@ +canonical: 2001-12-15T02:59:43.1Z +iso8601: 2001-12-14t21:59:43.10-05:00 +spaced: 2001-12-14 21:59:43.10 -5 +date: 2002-12-14 Index: /pyyaml/tags/3.04/tests/data/spec-08-10.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-10.data (revision 56) +++ /pyyaml/tags/3.04/tests/data/spec-08-10.data (revision 56) @@ -0,0 +1,15 @@ +block styles: + scalars: + literal: !!str | + #!/usr/bin/perl + print "Hello, world!\n"; + folded: > + This sentence + is false. + collections: !!map + sequence: !!seq # Entry: + - entry # Plain + # Mapping entry: + - key: value + mapping: + key: value Index: /pyyaml/tags/3.04/tests/data/spec-05-06.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-06.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-06.data (revision 38) @@ -0,0 +1,2 @@ +anchored: !local &anchor value +alias: *anchor Index: /pyyaml/tags/3.04/tests/data/spec-09-06.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-06.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-06.data (revision 38) @@ -0,0 +1,1 @@ + 'here''s to "quotes"' Index: /pyyaml/tags/3.04/tests/data/null.detect =================================================================== --- /pyyaml/tags/3.04/tests/data/null.detect (revision 55) +++ /pyyaml/tags/3.04/tests/data/null.detect (revision 55) @@ -0,0 +1,1 @@ +tag:yaml.org,2002:null Index: /pyyaml/tags/3.04/tests/data/float-representer-2.3-bug.data =================================================================== --- /pyyaml/tags/3.04/tests/data/float-representer-2.3-bug.data (revision 150) +++ /pyyaml/tags/3.04/tests/data/float-representer-2.3-bug.data (revision 150) @@ -0,0 +1,5 @@ +#0.0: # hash(0) == hash(nan) and 0 == nan in Python 2.3 +1.0: 1 ++.inf: 10 +-.inf: -10 +.nan: 100 Index: /pyyaml/tags/3.04/tests/data/duplicate-mapping-key.former-loader-error.data =================================================================== --- /pyyaml/tags/3.04/tests/data/duplicate-mapping-key.former-loader-error.data (revision 222) +++ /pyyaml/tags/3.04/tests/data/duplicate-mapping-key.former-loader-error.data (revision 222) @@ -0,0 +1,6 @@ +--- +&anchor foo: + foo: bar + *anchor: duplicate key + baz: bat + *anchor: duplicate key Index: /pyyaml/tags/3.04/tests/data/construct-omap.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-omap.data (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-omap.data (revision 58) @@ -0,0 +1,8 @@ +# Explicitly typed ordered map (dictionary). +Bestiary: !!omap + - aardvark: African pig-like ant eater. Ugly. + - anteater: South-American ant eater. Two species. + - anaconda: South-American constrictor snake. Scaly. + # Etc. +# Flow style +Numbers: !!omap [ one: 1, two: 2, three : 3 ] Index: /pyyaml/tags/3.04/tests/data/spec-08-05.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-05.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-08-05.canonical (revision 38) @@ -0,0 +1,7 @@ +%YAML 1.1 +--- +!!seq [ + ! "foo", + ! "bar", + ! "baz", +] Index: /pyyaml/tags/3.04/tests/data/invalid-anchor-1.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-anchor-1.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-anchor-1.loader-error (revision 140) @@ -0,0 +1,1 @@ +--- &? foo # we allow only ascii and numeric characters in anchor names. Index: /pyyaml/tags/3.04/tests/data/empty-python-module.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/empty-python-module.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/empty-python-module.loader-error (revision 140) @@ -0,0 +1,1 @@ +--- !!python:module: Index: /pyyaml/tags/3.04/tests/data/spec-09-19.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-19.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-19.canonical (revision 38) @@ -0,0 +1,6 @@ +%YAML 1.1 +--- +!!seq [ + !!str "literal\n", + !!str "folded\n", +] Index: /pyyaml/tags/3.04/tests/data/spec-02-08.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-08.tokens (revision 39) +++ /pyyaml/tags/3.04/tests/data/spec-02-08.tokens (revision 39) @@ -0,0 +1,15 @@ +--- +{{ +? _ : _ +? _ : _ +? _ : _ +]} +... + +--- +{{ +? _ : _ +? _ : _ +? _ : _ +]} +... Index: /pyyaml/tags/3.04/tests/data/spec-10-06.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-06.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-10-06.data (revision 38) @@ -0,0 +1,2 @@ +- { inner : entry , also: inner , } +- {inner: entry,last : entry} Index: /pyyaml/tags/3.04/tests/data/invalid-indentation-indicator-1.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-indentation-indicator-1.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-indentation-indicator-1.loader-error (revision 140) @@ -0,0 +1,2 @@ +--- >0 # not valid +data Index: /pyyaml/tags/3.04/tests/data/spec-07-03.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-03.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-03.data (revision 38) @@ -0,0 +1,3 @@ +%YAML 1.1 +%YAML 1.1 +foo Index: /pyyaml/tags/3.04/tests/data/construct-value.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-value.data (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-value.data (revision 58) @@ -0,0 +1,10 @@ +--- # Old schema +link with: + - library1.dll + - library2.dll +--- # New schema +link with: + - = : library1.dll + version: 1.2 + - = : library2.dll + version: 2.3 Index: /pyyaml/tags/3.04/tests/data/spec-05-15.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-15.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-15.data (revision 38) @@ -0,0 +1,3 @@ +Bad escapes: + "\c + \xq-" Index: /pyyaml/tags/3.04/tests/data/construct-map.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-map.code (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-map.code (revision 58) @@ -0,0 +1,6 @@ +{ + "Block style": + { "Clark" : "Evans", "Brian" : "Ingerson", "Oren" : "Ben-Kiki" }, + "Flow style": + { "Clark" : "Evans", "Brian" : "Ingerson", "Oren" : "Ben-Kiki" }, +} Index: /pyyaml/tags/3.04/tests/data/spec-09-15.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-15.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-15.data (revision 38) @@ -0,0 +1,13 @@ +--- +"---" : foo +...: bar +--- +[ +---, +..., +{ +? --- +: ... +} +] +... Index: /pyyaml/tags/3.04/tests/data/spec-10-08.error =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-08.error (revision 42) +++ /pyyaml/tags/3.04/tests/data/spec-10-08.error (revision 42) @@ -0,0 +1,5 @@ +ERROR: +- A simple key is restricted + to only one line. +- A simple key must not be + longer than 1024 characters. Index: /pyyaml/tags/3.04/tests/data/spec-07-12b.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-12b.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-12b.canonical (revision 38) @@ -0,0 +1,3 @@ +%YAML 1.1 +--- +!!str "Text content\n" Index: /pyyaml/tags/3.04/tests/data/spec-05-02-utf8.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-02-utf8.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-02-utf8.data (revision 38) @@ -0,0 +1,3 @@ +# Invalid use of BOM +# inside a +# document. Index: /pyyaml/tags/3.04/tests/data/spec-08-14.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-14.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-08-14.canonical (revision 38) @@ -0,0 +1,10 @@ +%YAML 1.1 +--- +!!seq [ + !!str "flow in block", + !!str "Block scalar\n", + !!map { + ? !!str "foo" + : !!str "bar" + } +] Index: /pyyaml/tags/3.04/tests/data/spec-05-09.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-09.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-09.canonical (revision 38) @@ -0,0 +1,3 @@ +%YAML 1.1 +--- +!!str "text" Index: /pyyaml/tags/3.04/tests/data/spec-09-07.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-07.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-07.canonical (revision 38) @@ -0,0 +1,11 @@ +%YAML 1.1 +--- +!!map { + ? !!str "simple key" + : !!map { + ? !!str "also simple" + : !!str "value", + ? !!str "not a simple key" + : !!str "any value" + } +} Index: /pyyaml/tags/3.04/tests/data/spec-09-28.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-28.canonical (revision 48) +++ /pyyaml/tags/3.04/tests/data/spec-09-28.canonical (revision 48) @@ -0,0 +1,3 @@ +%YAML 1.1 +--- +!!str "\n\nliteral\n\ntext\n" Index: /pyyaml/tags/3.04/tests/data/spec-02-09.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-09.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-09.structure (revision 44) @@ -0,0 +1,1 @@ +[(True, [True, True]), (True, [True, True])] Index: /pyyaml/tags/3.04/tests/data/sequences.events =================================================================== --- /pyyaml/tags/3.04/tests/data/sequences.events (revision 137) +++ /pyyaml/tags/3.04/tests/data/sequences.events (revision 137) @@ -0,0 +1,81 @@ +- !StreamStart + +- !DocumentStart +- !SequenceStart +- !SequenceEnd +- !DocumentEnd + +- !DocumentStart +- !SequenceStart { tag: '!mytag', implicit: false } +- !SequenceEnd +- !DocumentEnd + +- !DocumentStart +- !SequenceStart +- !SequenceStart +- !SequenceEnd +- !SequenceStart { tag: '!mytag', implicit: false } +- !SequenceEnd +- !SequenceStart +- !Scalar +- !Scalar { value: 'data' } +- !Scalar { tag: '!mytag', implicit: [false,false], value: 'data' } +- !SequenceEnd +- !SequenceStart +- !SequenceStart +- !SequenceStart +- !Scalar +- !SequenceEnd +- !SequenceEnd +- !SequenceEnd +- !SequenceStart +- !SequenceStart { tag: '!mytag', implicit: false } +- !SequenceStart +- !Scalar { value: 'data' } +- !SequenceEnd +- !SequenceEnd +- !SequenceEnd +- !SequenceEnd +- !DocumentEnd + +- !DocumentStart +- !SequenceStart +- !MappingStart +- !Scalar { value: 'key1' } +- !SequenceStart +- !Scalar { value: 'data1' } +- !Scalar { value: 'data2' } +- !SequenceEnd +- !Scalar { value: 'key2' } +- !SequenceStart { tag: '!mytag1', implicit: false } +- !Scalar { value: 'data3' } +- !SequenceStart +- !Scalar { value: 'data4' } +- !Scalar { value: 'data5' } +- !SequenceEnd +- !SequenceStart { tag: '!mytag2', implicit: false } +- !Scalar { value: 'data6' } +- !Scalar { value: 'data7' } +- !SequenceEnd +- !SequenceEnd +- !MappingEnd +- !SequenceEnd +- !DocumentEnd + +- !DocumentStart +- !SequenceStart +- !SequenceStart { flow_style: true } +- !SequenceStart +- !SequenceEnd +- !Scalar +- !Scalar { value: 'data' } +- !Scalar { tag: '!mytag', implicit: [false,false], value: 'data' } +- !SequenceStart { tag: '!mytag', implicit: false } +- !Scalar { value: 'data' } +- !Scalar { value: 'data' } +- !SequenceEnd +- !SequenceEnd +- !SequenceEnd +- !DocumentEnd + +- !StreamEnd Index: /pyyaml/tags/3.04/tests/data/spec-02-17.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-17.tokens (revision 41) +++ /pyyaml/tags/3.04/tests/data/spec-02-17.tokens (revision 41) @@ -0,0 +1,8 @@ +{{ +? _ : _ +? _ : _ +? _ : _ +? _ : _ +? _ : _ +? _ : _ +]} Index: /pyyaml/tags/3.04/tests/data/spec-10-15.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-15.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-10-15.data (revision 38) @@ -0,0 +1,3 @@ +- sun: yellow +- ? earth: blue + : moon: white Index: /pyyaml/tags/3.04/tests/data/construct-python-int.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-int.code (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-int.code (revision 144) @@ -0,0 +1,1 @@ +123 Index: /pyyaml/tags/3.04/tests/data/construct-python-long-short.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-long-short.data (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-long-short.data (revision 144) @@ -0,0 +1,1 @@ +!!python/long 123 Index: /pyyaml/tags/3.04/tests/data/yaml.detect =================================================================== --- /pyyaml/tags/3.04/tests/data/yaml.detect (revision 56) +++ /pyyaml/tags/3.04/tests/data/yaml.detect (revision 56) @@ -0,0 +1,1 @@ +tag:yaml.org,2002:yaml Index: /pyyaml/tags/3.04/tests/data/spec-09-24.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-24.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-24.data (revision 38) @@ -0,0 +1,6 @@ +strip: >- + +clip: > + +keep: |+ + Index: /pyyaml/tags/3.04/tests/data/spec-08-08.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-08.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-08-08.data (revision 38) @@ -0,0 +1,13 @@ +--- +foo: + "bar + baz" +--- +"foo + bar" +--- +foo + bar +--- | + foo +... Index: /pyyaml/tags/3.04/tests/data/float.data =================================================================== --- /pyyaml/tags/3.04/tests/data/float.data (revision 55) +++ /pyyaml/tags/3.04/tests/data/float.data (revision 55) @@ -0,0 +1,6 @@ +- 6.8523015e+5 +- 685.230_15e+03 +- 685_230.15 +- 190:20:30.15 +- -.inf +- .NaN Index: /pyyaml/tags/3.04/tests/data/forbidden-key.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/forbidden-key.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/forbidden-key.loader-error (revision 140) @@ -0,0 +1,2 @@ +test: ? foo + : bar Index: /pyyaml/tags/3.04/tests/data/null.data =================================================================== --- /pyyaml/tags/3.04/tests/data/null.data (revision 55) +++ /pyyaml/tags/3.04/tests/data/null.data (revision 55) @@ -0,0 +1,3 @@ +- +- ~ +- null Index: /pyyaml/tags/3.04/tests/data/spec-08-02.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-02.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-08-02.canonical (revision 38) @@ -0,0 +1,8 @@ +%YAML 1.1 +--- +!!map { + ? !!str "First occurrence" + : &A !!str "Value", + ? !!str "Second occurrence" + : *A +} Index: /pyyaml/tags/3.04/tests/data/spec-07-07a.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-07a.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-07a.canonical (revision 38) @@ -0,0 +1,3 @@ +%YAML 1.1 +--- +! "bar" Index: /pyyaml/tags/3.04/tests/data/spec-09-16.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-16.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-16.canonical (revision 38) @@ -0,0 +1,6 @@ +%YAML 1.1 +--- +!!str "as space \ + trimmed\n\ + specific\L\n\ + none" Index: /pyyaml/tags/3.04/tests/data/invalid-python-module-value.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-python-module-value.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-python-module-value.loader-error (revision 140) @@ -0,0 +1,1 @@ +--- !!python/module:sys "non-empty value" Index: /pyyaml/tags/3.04/tests/data/spec-02-18.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-18.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-18.structure (revision 44) @@ -0,0 +1,1 @@ +[(True, True), (True, True)] Index: /pyyaml/tags/3.04/tests/data/spec-02-26.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-26.tokens (revision 41) +++ /pyyaml/tags/3.04/tests/data/spec-02-26.tokens (revision 41) @@ -0,0 +1,6 @@ +--- ! +[[ +, {{ ? _ : _ ]} +, {{ ? _ : _ ]} +, {{ ? _ : _ ]} +]} Index: /pyyaml/tags/3.04/tests/data/invalid-character.stream-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-character.stream-error (revision 45) +++ /pyyaml/tags/3.04/tests/data/invalid-character.stream-error (revision 45) @@ -0,0 +1,18 @@ +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +Control character ('\x0'): <-- +------------------------------------------------------------------------------------------------------------------------------- Index: /pyyaml/tags/3.04/tests/data/invalid-tag-directive-prefix.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-tag-directive-prefix.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-tag-directive-prefix.loader-error (revision 140) @@ -0,0 +1,2 @@ +%TAG ! tag:zz.com/foo#bar # '#' is not allowed in URLs +--- Index: /pyyaml/tags/3.04/tests/data/spec-02-05.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-05.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-05.data (revision 38) @@ -0,0 +1,3 @@ +- [name , hr, avg ] +- [Mark McGwire, 65, 0.278] +- [Sammy Sosa , 63, 0.288] Index: /pyyaml/tags/3.04/tests/data/spec-06-05.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-06-05.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-06-05.data (revision 38) @@ -0,0 +1,6 @@ +{ first: Sammy, last: Sosa }: +# Statistics: + hr: # Home runs + 65 + avg: # Average + 0.278 Index: /pyyaml/tags/3.04/tests/data/spec-09-33.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-33.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-33.data (revision 38) @@ -0,0 +1,14 @@ +> + folded + line + + next + line + + * bullet + * list + + last + line + +# Comment Index: /pyyaml/tags/3.04/tests/data/invalid-directive-name-2.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-directive-name-2.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-directive-name-2.loader-error (revision 140) @@ -0,0 +1,2 @@ +%invalid-characters:in-directive name +--- Index: /pyyaml/tags/3.04/tests/data/document-separator-in-quoted-scalar.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/document-separator-in-quoted-scalar.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/document-separator-in-quoted-scalar.loader-error (revision 140) @@ -0,0 +1,11 @@ +--- +"this --- is correct" +--- +"this +...is also +correct" +--- +"a quoted scalar +cannot contain +--- +document separators" Index: /pyyaml/tags/3.04/tests/data/spec-08-11.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-11.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-08-11.canonical (revision 38) @@ -0,0 +1,8 @@ +%YAML 1.1 +--- +!!map { + ? !!str "First occurrence" + : &A !!str "Value", + ? !!str "Second occurrence" + : *A +} Index: /pyyaml/tags/3.04/tests/data/spec-05-06.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-06.canonical (revision 42) +++ /pyyaml/tags/3.04/tests/data/spec-05-06.canonical (revision 42) @@ -0,0 +1,8 @@ +%YAML 1.1 +--- +!!map { + ? !!str "anchored" + : &A1 !local "value", + ? !!str "alias" + : *A1, +} Index: /pyyaml/tags/3.04/tests/data/sloppy-indentation.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/sloppy-indentation.canonical (revision 137) +++ /pyyaml/tags/3.04/tests/data/sloppy-indentation.canonical (revision 137) @@ -0,0 +1,18 @@ +%YAML 1.1 +--- +!!map { + ? !!str "in the block context" + : !!map { + ? !!str "indentation should be kept" + : !!map { + ? !!str "but in the flow context" + : !!seq [ !!str "it may be violated" ] + } + } +} +--- !!str +"the parser does not require scalars to be indented with at least one space" +--- !!str +"the parser does not require scalars to be indented with at least one space" +--- !!map +{ ? !!str "foo": { ? !!str "bar" : !!str "quoted scalars may not adhere indentation" } } Index: /pyyaml/tags/3.04/tests/data/spec-09-04.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-04.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-04.canonical (revision 38) @@ -0,0 +1,6 @@ +%YAML 1.1 +--- +!!str "first \ + inner 1 \ + inner 2 \ + last" Index: /pyyaml/tags/3.04/tests/data/spec-09-25.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-25.canonical (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-09-25.canonical (revision 44) @@ -0,0 +1,4 @@ +%YAML 1.1 +--- +!!str "literal\n\ + \ttext\n" Index: /pyyaml/tags/3.04/tests/data/spec-02-06.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-06.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-06.structure (revision 44) @@ -0,0 +1,4 @@ +[ + (True, [(True, True), (True, True)]), + (True, [(True, True), (True, True)]), +] Index: /pyyaml/tags/3.04/tests/data/spec-02-27.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-27.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-27.structure (revision 44) @@ -0,0 +1,17 @@ +[ +(True, True), +(True, True), +(True, [ + (True, True), + (True, True), + (True, [(True, True), (True, True), (True, True), (True, True)]), + ]), +(True, '*'), +(True, [ + [(True, True), (True, True), (True, True), (True, True)], + [(True, True), (True, True), (True, True), (True, True)], + ]), +(True, True), +(True, True), +(True, True), +] Index: /pyyaml/tags/3.04/tests/data/spec-05-01-utf16be.empty =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-01-utf16be.empty (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-01-utf16be.empty (revision 38) @@ -0,0 +1,2 @@ +# This stream contains no +# documents, only comments. Index: /pyyaml/tags/3.04/tests/data/forbidden-value.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/forbidden-value.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/forbidden-value.loader-error (revision 140) @@ -0,0 +1,1 @@ +test: key: value Index: /pyyaml/tags/3.04/tests/data/spec-02-14.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-14.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-14.data (revision 38) @@ -0,0 +1,4 @@ +--- + Mark McGwire's + year was crippled + by a knee injury. Index: /pyyaml/tags/3.04/tests/data/spec-08-02.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-02.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-08-02.data (revision 38) @@ -0,0 +1,2 @@ +First occurrence: &anchor Value +Second occurrence: *anchor Index: /pyyaml/tags/3.04/tests/data/construct-python-str-ascii.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-str-ascii.data (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-str-ascii.data (revision 144) @@ -0,0 +1,1 @@ +--- !!python/str "ascii string" Index: /pyyaml/tags/3.04/tests/data/serializer-is-not-opened-2.dumper-error =================================================================== --- /pyyaml/tags/3.04/tests/data/serializer-is-not-opened-2.dumper-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/serializer-is-not-opened-2.dumper-error (revision 141) @@ -0,0 +1,2 @@ +dumper = Dumper(StringIO.StringIO()) +dumper.serialize(ScalarNode(tag='!foo', value='bar')) Index: /pyyaml/tags/3.04/tests/data/no-flow-mapping-end.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/no-flow-mapping-end.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/no-flow-mapping-end.loader-error (revision 140) @@ -0,0 +1,1 @@ +{ foo: bar ] Index: /pyyaml/tags/3.04/tests/data/timestamp.detect =================================================================== --- /pyyaml/tags/3.04/tests/data/timestamp.detect (revision 55) +++ /pyyaml/tags/3.04/tests/data/timestamp.detect (revision 55) @@ -0,0 +1,1 @@ +tag:yaml.org,2002:timestamp Index: /pyyaml/tags/3.04/tests/data/undefined-constructor.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/undefined-constructor.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/undefined-constructor.loader-error (revision 140) @@ -0,0 +1,1 @@ +--- !foo bar Index: /pyyaml/tags/3.04/tests/data/invalid-yaml-directive-version-3.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-yaml-directive-version-3.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-yaml-directive-version-3.loader-error (revision 140) @@ -0,0 +1,2 @@ +%YAML 1. +--- Index: /pyyaml/tags/3.04/tests/data/mappings.events =================================================================== --- /pyyaml/tags/3.04/tests/data/mappings.events (revision 137) +++ /pyyaml/tags/3.04/tests/data/mappings.events (revision 137) @@ -0,0 +1,44 @@ +- !StreamStart + +- !DocumentStart +- !MappingStart +- !Scalar { implicit: [true,true], value: 'key' } +- !Scalar { implicit: [true,true], value: 'value' } +- !Scalar { implicit: [true,true], value: 'empty mapping' } +- !MappingStart +- !MappingEnd +- !Scalar { implicit: [true,true], value: 'empty mapping with tag' } +- !MappingStart { tag: '!mytag', implicit: false } +- !MappingEnd +- !Scalar { implicit: [true,true], value: 'block mapping' } +- !MappingStart +- !MappingStart +- !Scalar { implicit: [true,true], value: 'complex' } +- !Scalar { implicit: [true,true], value: 'key' } +- !Scalar { implicit: [true,true], value: 'complex' } +- !Scalar { implicit: [true,true], value: 'key' } +- !MappingEnd +- !MappingStart +- !Scalar { implicit: [true,true], value: 'complex' } +- !Scalar { implicit: [true,true], value: 'key' } +- !MappingEnd +- !MappingEnd +- !Scalar { implicit: [true,true], value: 'flow mapping' } +- !MappingStart { flow_style: true } +- !Scalar { implicit: [true,true], value: 'key' } +- !Scalar { implicit: [true,true], value: 'value' } +- !MappingStart +- !Scalar { implicit: [true,true], value: 'complex' } +- !Scalar { implicit: [true,true], value: 'key' } +- !Scalar { implicit: [true,true], value: 'complex' } +- !Scalar { implicit: [true,true], value: 'key' } +- !MappingEnd +- !MappingStart +- !Scalar { implicit: [true,true], value: 'complex' } +- !Scalar { implicit: [true,true], value: 'key' } +- !MappingEnd +- !MappingEnd +- !MappingEnd +- !DocumentEnd + +- !StreamEnd Index: /pyyaml/tags/3.04/tests/data/spec-09-13.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-13.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-13.canonical (revision 38) @@ -0,0 +1,11 @@ +%YAML 1.1 +--- +!!map { + ? !!str "simple key" + : !!map { + ? !!str "also simple" + : !!str "value", + ? !!str "not a simple key" + : !!str "any value" + } +} Index: /pyyaml/tags/3.04/tests/data/spec-06-08.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-06-08.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-06-08.canonical (revision 38) @@ -0,0 +1,5 @@ +%YAML 1.1 +--- !!str +"specific\L\ + trimmed\n\n\n\ + as space" Index: /pyyaml/tags/3.04/tests/data/spec-07-05.error =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-05.error (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-05.error (revision 38) @@ -0,0 +1,4 @@ +ERROR: +The TAG directive must only +be given at most once per +handle in the same document. Index: /pyyaml/tags/3.04/tests/data/spec-02-15.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-15.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-15.structure (revision 44) @@ -0,0 +1,1 @@ +True Index: /pyyaml/tags/3.04/tests/data/spec-05-05.empty =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-05.empty (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-05.empty (revision 38) @@ -0,0 +1,2 @@ +# This stream contains no +# documents, only comments. Index: /pyyaml/tags/3.04/tests/data/spec-02-04.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-04.tokens (revision 39) +++ /pyyaml/tags/3.04/tests/data/spec-02-04.tokens (revision 39) @@ -0,0 +1,4 @@ +[[ +, {{ ? _ : _ ? _ : _ ? _ : _ ]} +, {{ ? _ : _ ? _ : _ ? _ : _ ]} +]} Index: /pyyaml/tags/3.04/tests/data/duplicate-key.former-loader-error.data =================================================================== --- /pyyaml/tags/3.04/tests/data/duplicate-key.former-loader-error.data (revision 222) +++ /pyyaml/tags/3.04/tests/data/duplicate-key.former-loader-error.data (revision 222) @@ -0,0 +1,3 @@ +--- +foo: bar +foo: baz Index: /pyyaml/tags/3.04/tests/data/invalid-uri-escapes-2.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-uri-escapes-2.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-uri-escapes-2.loader-error (revision 140) @@ -0,0 +1,1 @@ +--- !<%FF> foo Index: /pyyaml/tags/3.04/tests/data/spec-02-23.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-23.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-23.data (revision 38) @@ -0,0 +1,13 @@ +--- +not-date: !!str 2002-04-28 + +picture: !!binary | + R0lGODlhDAAMAIQAAP//9/X + 17unp5WZmZgAAAOfn515eXv + Pz7Y6OjuDg4J+fn5OTk6enp + 56enmleECcgggoBADs= + +application specific tag: !something | + The semantics of the tag + above may be different for + different documents. Index: /pyyaml/tags/3.04/tests/data/spec-08-11.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-11.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-08-11.data (revision 38) @@ -0,0 +1,2 @@ +First occurrence: &anchor Value +Second occurrence: *anchor Index: /pyyaml/tags/3.04/tests/data/spec-05-07.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-07.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-07.data (revision 38) @@ -0,0 +1,4 @@ +literal: | + text +folded: > + text Index: /pyyaml/tags/3.04/tests/data/unacceptable-key.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/unacceptable-key.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/unacceptable-key.loader-error (revision 140) @@ -0,0 +1,4 @@ +--- +? - foo + - bar +: baz Index: /pyyaml/tags/3.04/tests/data/spec-09-07.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-07.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-07.data (revision 38) @@ -0,0 +1,6 @@ +'simple key' : { + 'also simple' : value, + ? 'not a + simple key' : 'any + value' +} Index: /pyyaml/tags/3.04/tests/data/spec-05-03.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-03.canonical (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-05-03.canonical (revision 44) @@ -0,0 +1,14 @@ +%YAML 1.1 +--- +!!map { + ? !!str "sequence" + : !!seq [ + !!str "one", !!str "two" + ], + ? !!str "mapping" + : !!map { + ? !!str "sky" : !!str "blue", +# ? !!str "sea" : !!str "green", + ? !!map { ? !!str "sea" : !!str "green" } : !!null "", + } +} Index: /pyyaml/tags/3.04/tests/data/spec-09-01.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-01.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-01.canonical (revision 38) @@ -0,0 +1,11 @@ +%YAML 1.1 +--- +!!map { + ? !!str "simple key" + : !!map { + ? !!str "also simple" + : !!str "value", + ? !!str "not a simple key" + : !!str "any value" + } +} Index: /pyyaml/tags/3.04/tests/data/invalid-single-quote-bug.code =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-single-quote-bug.code (revision 197) +++ /pyyaml/tags/3.04/tests/data/invalid-single-quote-bug.code (revision 197) @@ -0,0 +1,1 @@ +["foo 'bar'", "foo\n'bar'"] Index: /pyyaml/tags/3.04/tests/data/invalid-tag-handle-2.emitter-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-tag-handle-2.emitter-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/invalid-tag-handle-2.emitter-error (revision 141) @@ -0,0 +1,5 @@ +- !StreamStart +- !DocumentStart { tags: { '!!!': 'bar' } } +- !Scalar { value: 'foo' } +- !DocumentEnd +- !StreamEnd Index: /pyyaml/tags/3.04/tests/data/forbidden-entry.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/forbidden-entry.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/forbidden-entry.loader-error (revision 140) @@ -0,0 +1,2 @@ +test: - foo + - bar Index: /pyyaml/tags/3.04/tests/data/spec-09-22.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-22.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-22.canonical (revision 38) @@ -0,0 +1,10 @@ +%YAML 1.1 +--- +!!map { + ? !!str "strip" + : !!str "text", + ? !!str "clip" + : !!str "text\n", + ? !!str "keep" + : !!str "text\L", +} Index: /pyyaml/tags/3.04/tests/data/no-flow-sequence-end.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/no-flow-sequence-end.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/no-flow-sequence-end.loader-error (revision 140) @@ -0,0 +1,1 @@ +[foo, bar} Index: /pyyaml/tags/3.04/tests/data/spec-02-03.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-03.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-03.structure (revision 44) @@ -0,0 +1,1 @@ +[(True, [True, True, True]), (True, [True, True, True])] Index: /pyyaml/tags/3.04/tests/data/construct-merge.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-merge.data (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-merge.data (revision 58) @@ -0,0 +1,27 @@ +--- +- &CENTER { x: 1, 'y': 2 } +- &LEFT { x: 0, 'y': 2 } +- &BIG { r: 10 } +- &SMALL { r: 1 } + +# All the following maps are equal: + +- # Explicit keys + x: 1 + 'y': 2 + r: 10 + label: center/big + +- # Merge one map + << : *CENTER + r: 10 + label: center/big + +- # Merge multiple maps + << : [ *CENTER, *BIG ] + label: center/big + +- # Override + << : [ *BIG, *LEFT, *SMALL ] + x: 1 + label: center/big Index: /pyyaml/tags/3.04/tests/data/spec-07-11.empty =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-11.empty (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-11.empty (revision 38) @@ -0,0 +1,2 @@ +# This stream contains no +# documents, only comments. Index: /pyyaml/tags/3.04/tests/data/spec-02-24.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-24.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-24.structure (revision 44) @@ -0,0 +1,5 @@ +[ +[(True, [(True, True), (True, True)]), (True, True)], +[(True, '*'), (True, [(True, True), (True, True)])], +[(True, '*'), (True, True), (True, True)], +] Index: /pyyaml/tags/3.04/tests/data/invalid-utf8-byte.stream-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-utf8-byte.stream-error (revision 45) +++ /pyyaml/tags/3.04/tests/data/invalid-utf8-byte.stream-error (revision 45) @@ -0,0 +1,18 @@ +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------------------------------------------- +Invalid byte ('\xFF'): ÿ <-- +------------------------------------------------------------------------------------------------------------------------------- Index: /pyyaml/tags/3.04/tests/data/spec-02-13.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-13.tokens (revision 41) +++ /pyyaml/tags/3.04/tests/data/spec-02-13.tokens (revision 41) @@ -0,0 +1,1 @@ +--- _ Index: /pyyaml/tags/3.04/tests/data/remove-possible-simple-key-bug.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/remove-possible-simple-key-bug.loader-error (revision 188) +++ /pyyaml/tags/3.04/tests/data/remove-possible-simple-key-bug.loader-error (revision 188) @@ -0,0 +1,3 @@ +foo: &A bar +*A ] # The ']' indicator triggers remove_possible_simple_key, + # which should raise an error. Index: /pyyaml/tags/3.04/tests/data/spec-10-07.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-07.data (revision 47) +++ /pyyaml/tags/3.04/tests/data/spec-10-07.data (revision 47) @@ -0,0 +1,7 @@ +{ +? : value, # Empty key +? explicit + key: value, +simple key : value, +[ collection, simple, key ]: value +} Index: /pyyaml/tags/3.04/tests/data/undefined-anchor.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/undefined-anchor.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/undefined-anchor.loader-error (revision 140) @@ -0,0 +1,3 @@ +- foo +- &bar baz +- *bat Index: /pyyaml/tags/3.04/tests/data/duplicate-value-key.former-loader-error.data =================================================================== --- /pyyaml/tags/3.04/tests/data/duplicate-value-key.former-loader-error.data (revision 222) +++ /pyyaml/tags/3.04/tests/data/duplicate-value-key.former-loader-error.data (revision 222) @@ -0,0 +1,4 @@ +--- +=: 1 +foo: bar +=: 2 Index: /pyyaml/tags/3.04/tests/data/spec-07-04.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-04.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-04.data (revision 38) @@ -0,0 +1,3 @@ +%TAG !yaml! tag:yaml.org,2002: +--- +!yaml!str "foo" Index: /pyyaml/tags/3.04/tests/data/spec-05-02-utf16le.error =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-02-utf16le.error (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-02-utf16le.error (revision 38) @@ -0,0 +1,3 @@ +ERROR: + A BOM must not appear + inside a document. Index: /pyyaml/tags/3.04/tests/data/spec-09-16.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-16.data (revision 48) +++ /pyyaml/tags/3.04/tests/data/spec-09-16.data (revision 48) @@ -0,0 +1,7 @@ +# Tabs are confusing: +# as space/trimmed/specific/none + as space  + trimmed  + + specific‹ + none Index: /pyyaml/tags/3.04/tests/data/construct-binary.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-binary.code (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-binary.code (revision 58) @@ -0,0 +1,7 @@ +{ + "canonical": + "GIF89a\x0c\x00\x0c\x00\x84\x00\x00\xff\xff\xf7\xf5\xf5\xee\xe9\xe9\xe5fff\x00\x00\x00\xe7\xe7\xe7^^^\xf3\xf3\xed\x8e\x8e\x8e\xe0\xe0\xe0\x9f\x9f\x9f\x93\x93\x93\xa7\xa7\xa7\x9e\x9e\x9eiiiccc\xa3\xa3\xa3\x84\x84\x84\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9!\xfe\x0eMade with GIMP\x00,\x00\x00\x00\x00\x0c\x00\x0c\x00\x00\x05, \x8e\x810\x9e\xe3@\x14\xe8i\x10\xc4\xd1\x8a\x08\x1c\xcf\x80M$z\xef\xff0\x85p\xb8\xb01f\r\x1b\xce\x01\xc3\x01\x1e\x10' \x82\n\x01\x00;", + "generic": + "GIF89a\x0c\x00\x0c\x00\x84\x00\x00\xff\xff\xf7\xf5\xf5\xee\xe9\xe9\xe5fff\x00\x00\x00\xe7\xe7\xe7^^^\xf3\xf3\xed\x8e\x8e\x8e\xe0\xe0\xe0\x9f\x9f\x9f\x93\x93\x93\xa7\xa7\xa7\x9e\x9e\x9eiiiccc\xa3\xa3\xa3\x84\x84\x84\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9\xff\xfe\xf9!\xfe\x0eMade with GIMP\x00,\x00\x00\x00\x00\x0c\x00\x0c\x00\x00\x05, \x8e\x810\x9e\xe3@\x14\xe8i\x10\xc4\xd1\x8a\x08\x1c\xcf\x80M$z\xef\xff0\x85p\xb8\xb01f\r\x1b\xce\x01\xc3\x01\x1e\x10' \x82\n\x01\x00;", + "description": "The binary value above is a tiny arrow encoded as a gif image.", +} Index: /pyyaml/tags/3.04/tests/data/spec-10-05.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-05.canonical (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-10-05.canonical (revision 44) @@ -0,0 +1,14 @@ +%YAML 1.1 +--- +!!seq [ + !!null "", + !!str "block node\n", + !!seq [ + !!str "one", + !!str "two", + ], + !!map { + ? !!str "one" + : !!str "two", + } +] Index: /pyyaml/tags/3.04/tests/data/spec-09-10.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-10.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-10.canonical (revision 38) @@ -0,0 +1,5 @@ +%YAML 1.1 +--- +!!str "first \ + inner \ + last" Index: /pyyaml/tags/3.04/tests/data/construct-bool.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-bool.data (revision 226) +++ /pyyaml/tags/3.04/tests/data/construct-bool.data (revision 226) @@ -0,0 +1,9 @@ +canonical: yes +answer: NO +logical: True +option: on + + +but: + y: is a string + n: is a string Index: /pyyaml/tags/3.04/tests/data/spec-06-05.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-06-05.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-06-05.canonical (revision 38) @@ -0,0 +1,16 @@ +%YAML 1.1 +--- +!!map { + ? !!map { + ? !!str "first" + : !!str "Sammy", + ? !!str "last" + : !!str "Sosa" + } + : !!map { + ? !!str "hr" + : !!int "65", + ? !!str "avg" + : !!float "0.278" + } +} Index: /pyyaml/tags/3.04/tests/data/spec-09-31.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-31.canonical (revision 51) +++ /pyyaml/tags/3.04/tests/data/spec-09-31.canonical (revision 51) @@ -0,0 +1,7 @@ +%YAML 1.1 +--- +!!str "folded line\n\ + next line\n\n\ + \ * bullet\n\ + \ * list\n\n\ + last line\n" Index: /pyyaml/tags/3.04/tests/data/empty-python-name.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/empty-python-name.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/empty-python-name.loader-error (revision 140) @@ -0,0 +1,1 @@ +--- !!python/name: empty Index: /pyyaml/tags/3.04/tests/data/spec-02-12.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-12.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-12.structure (revision 44) @@ -0,0 +1,5 @@ +[ +[(True, True), (True, True)], +[(True, True), (True, True)], +[(True, True), (True, True)], +] Index: /pyyaml/tags/3.04/tests/data/spec-02-22.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-22.tokens (revision 41) +++ /pyyaml/tags/3.04/tests/data/spec-02-22.tokens (revision 41) @@ -0,0 +1,6 @@ +{{ +? _ : _ +? _ : _ +? _ : _ +? _ : _ +]} Index: /pyyaml/tags/3.04/tests/data/invalid-pairs-3.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-pairs-3.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-pairs-3.loader-error (revision 140) @@ -0,0 +1,4 @@ +--- !!pairs +- foo: bar +- baz: bar + bar: bar Index: /pyyaml/tags/3.04/tests/data/expected-scalar.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/expected-scalar.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/expected-scalar.loader-error (revision 140) @@ -0,0 +1,1 @@ +--- !!str [not a scalar] Index: /pyyaml/tags/3.04/tests/data/spec-09-01.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-01.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-01.data (revision 38) @@ -0,0 +1,6 @@ +"simple key" : { + "also simple" : value, + ? "not a + simple key" : "any + value" +} Index: /pyyaml/tags/3.04/tests/data/spec-07-13.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-13.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-13.data (revision 38) @@ -0,0 +1,9 @@ +! "First document" +--- +!foo "No directives" +%TAG ! !foo +--- +!bar "With directives" +%YAML 1.1 +--- +!baz "Reset settings" Index: /pyyaml/tags/3.04/tests/data/construct-python-none.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-none.data (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-none.data (revision 144) @@ -0,0 +1,1 @@ +!!python/none Index: /pyyaml/tags/3.04/tests/data/serializer-is-closed-2.dumper-error =================================================================== --- /pyyaml/tags/3.04/tests/data/serializer-is-closed-2.dumper-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/serializer-is-closed-2.dumper-error (revision 141) @@ -0,0 +1,4 @@ +dumper = Dumper(StringIO.StringIO()) +dumper.open() +dumper.close() +dumper.serialize(ScalarNode(tag='!foo', value='bar')) Index: /pyyaml/tags/3.04/tests/data/spec-09-25.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-25.data (revision 48) +++ /pyyaml/tags/3.04/tests/data/spec-09-25.data (revision 48) @@ -0,0 +1,3 @@ +| # Simple block scalar + literal + text Index: /pyyaml/tags/3.04/tests/data/invalid-omap-3.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-omap-3.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-omap-3.loader-error (revision 140) @@ -0,0 +1,4 @@ +--- !!omap +- foo: bar +- baz: bar + bar: bar Index: /pyyaml/tags/3.04/tests/data/spec-08-09.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-09.data (revision 57) +++ /pyyaml/tags/3.04/tests/data/spec-08-09.data (revision 57) @@ -0,0 +1,11 @@ +--- +scalars: + plain: !!str some text + quoted: + single: 'some text' + double: "some text" +collections: + sequence: !!seq [ !!str entry, + # Mapping entry: + key: value ] + mapping: { key: value } Index: /pyyaml/tags/3.04/tests/data/spec-10-14.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-14.canonical (revision 48) +++ /pyyaml/tags/3.04/tests/data/spec-10-14.canonical (revision 48) @@ -0,0 +1,11 @@ +%YAML 1.1 +--- +!!map { + ? !!str "plain key" + : !!null "", + ? !!str "quoted key" + : !!seq [ + !!str "one", + !!str "two", + ] +} Index: /pyyaml/tags/3.04/tests/data/spec-05-12.error =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-12.error (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-12.error (revision 38) @@ -0,0 +1,8 @@ +ERROR: + Tabs may appear inside + comments and quoted or + block scalar content. + Tabs must not appear + elsewhere, such as + in indentation and + separation spaces. Index: /pyyaml/tags/3.04/tests/data/construct-int.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-int.code (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-int.code (revision 58) @@ -0,0 +1,8 @@ +{ + "canonical": 685230, + "decimal": 685230, + "octal": 685230, + "hexadecimal": 685230, + "binary": 685230, + "sexagesimal": 685230, +} Index: /pyyaml/tags/3.04/tests/data/spec-02-21.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-21.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-21.structure (revision 44) @@ -0,0 +1,1 @@ +[(True, True), (True, True), (True, True), (True, True)] Index: /pyyaml/tags/3.04/tests/data/spec-08-04.error =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-04.error (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-08-04.error (revision 38) @@ -0,0 +1,6 @@ +ERROR: +- Verbatim tags aren't resolved, + so ! is invalid. +- The $:? tag is neither a global + URI tag nor a local tag starting + with “!”. Index: /pyyaml/tags/3.04/tests/data/emit-block-scalar-in-simple-key-context-bug.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/emit-block-scalar-in-simple-key-context-bug.canonical (revision 218) +++ /pyyaml/tags/3.04/tests/data/emit-block-scalar-in-simple-key-context-bug.canonical (revision 218) @@ -0,0 +1,6 @@ +%YAML 1.1 +--- !!map +{ + ? !!str "foo" + : !!str "bar" +} Index: /pyyaml/tags/3.04/tests/data/spec-10-01.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-01.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-10-01.data (revision 38) @@ -0,0 +1,2 @@ +- [ inner, inner, ] +- [inner,last] Index: /pyyaml/tags/3.04/tests/data/spec-02-09.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-09.tokens (revision 39) +++ /pyyaml/tags/3.04/tests/data/spec-02-09.tokens (revision 39) @@ -0,0 +1,5 @@ +--- +{{ +? _ : [[ , _ , _ ]} +? _ : [[ , _ , _ ]} +]} Index: /pyyaml/tags/3.04/tests/data/spec-05-10.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-10.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-10.data (revision 38) @@ -0,0 +1,2 @@ +commercial-at: @text +grave-accent: `text Index: /pyyaml/tags/3.04/tests/data/construct-str.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-str.code (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-str.code (revision 58) @@ -0,0 +1,1 @@ +{ "string": "abcd" } Index: /pyyaml/tags/3.04/tests/data/spec-02-06.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-06.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-06.data (revision 38) @@ -0,0 +1,5 @@ +Mark McGwire: {hr: 65, avg: 0.278} +Sammy Sosa: { + hr: 63, + avg: 0.288 + } Index: /pyyaml/tags/3.04/tests/data/construct-null.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-null.code (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-null.code (revision 58) @@ -0,0 +1,13 @@ +[ + None, + { "empty": None, "canonical": None, "english": None, None: "null key" }, + { + "sparse": [ + None, + "2nd entry", + None, + "4th entry", + None, + ], + }, +] Index: /pyyaml/tags/3.04/tests/data/spec-09-10.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-10.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-10.data (revision 38) @@ -0,0 +1,3 @@ + 'first + inner + last' Index: /pyyaml/tags/3.04/tests/data/emitting-unacceptable-unicode-character-bug.code =================================================================== --- /pyyaml/tags/3.04/tests/data/emitting-unacceptable-unicode-character-bug.code (revision 153) +++ /pyyaml/tags/3.04/tests/data/emitting-unacceptable-unicode-character-bug.code (revision 153) @@ -0,0 +1,1 @@ +u"\udd00" Index: /pyyaml/tags/3.04/tests/data/spec-06-06.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-06-06.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-06-06.data (revision 38) @@ -0,0 +1,7 @@ +plain: text + lines +quoted: "text + lines" +block: | + text + lines Index: /pyyaml/tags/3.04/tests/data/spec-10-02.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-02.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-10-02.canonical (revision 38) @@ -0,0 +1,14 @@ +%YAML 1.1 +--- +!!seq [ + !!str "double quoted", + !!str "single quoted", + !!str "plain text", + !!seq [ + !!str "nested", + ], + !!map { + ? !!str "single" + : !!str "pair" + } +] Index: /pyyaml/tags/3.04/tests/data/invalid-uri.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-uri.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-uri.loader-error (revision 140) @@ -0,0 +1,1 @@ +--- !foo! bar Index: /pyyaml/tags/3.04/tests/data/construct-seq.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-seq.code (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-seq.code (revision 58) @@ -0,0 +1,4 @@ +{ + "Block style": ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune", "Pluto"], + "Flow style": ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune", "Pluto"], +} Index: /pyyaml/tags/3.04/tests/data/spec-08-09.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-09.canonical (revision 42) +++ /pyyaml/tags/3.04/tests/data/spec-08-09.canonical (revision 42) @@ -0,0 +1,21 @@ +%YAML 1.1 +--- !!map { + ? !!str "scalars" : !!map { + ? !!str "plain" + : !!str "some text", + ? !!str "quoted" + : !!map { + ? !!str "single" + : !!str "some text", + ? !!str "double" + : !!str "some text" + } }, + ? !!str "collections" : !!map { + ? !!str "sequence" : !!seq [ + !!str "entry", + !!map { + ? !!str "key" : !!str "value" + } ], + ? !!str "mapping" : !!map { + ? !!str "key" : !!str "value" +} } } Index: /pyyaml/tags/3.04/tests/data/construct-python-tuple-list-dict.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-tuple-list-dict.data (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-tuple-list-dict.data (revision 144) @@ -0,0 +1,8 @@ +- !!python/list [1, 2, 3, 4] +- !!python/tuple [1, 2, 3, 4] +- !!python/dict {1: 2, 3: 4} +- !!python/dict + !!python/tuple [0,0]: 0 + !!python/tuple [0,1]: 1 + !!python/tuple [1,0]: 1 + !!python/tuple [1,1]: 0 Index: /pyyaml/tags/3.04/tests/data/invalid-anchor.emitter-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-anchor.emitter-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/invalid-anchor.emitter-error (revision 141) @@ -0,0 +1,5 @@ +- !StreamStart +- !DocumentStart +- !Scalar { anchor: '5*5=25', value: 'foo' } +- !DocumentEnd +- !StreamEnd Index: /pyyaml/tags/3.04/tests/data/spec-10-10.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-10.data (revision 48) +++ /pyyaml/tags/3.04/tests/data/spec-10-10.data (revision 48) @@ -0,0 +1,8 @@ +{ +? explicit key1 : explicit value, +? explicit key2 : , # Explicit empty +? explicit key3, # Empty value +simple key1 : explicit value, +simple key2 : , # Explicit empty +simple key3, # Empty value +} Index: /pyyaml/tags/3.04/tests/data/spec-02-18.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-18.tokens (revision 41) +++ /pyyaml/tags/3.04/tests/data/spec-02-18.tokens (revision 41) @@ -0,0 +1,4 @@ +{{ +? _ : _ +? _ : _ +]} Index: /pyyaml/tags/3.04/tests/data/spec-02-15.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-15.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-15.data (revision 38) @@ -0,0 +1,8 @@ +> + Sammy Sosa completed another + fine season with great stats. + + 63 Home Runs + 0.288 Batting Average + + What a year! Index: /pyyaml/tags/3.04/tests/data/spec-08-03.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-03.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-08-03.data (revision 38) @@ -0,0 +1,2 @@ +! foo : + ! baz Index: /pyyaml/tags/3.04/tests/data/expected-document-start.emitter-error =================================================================== --- /pyyaml/tags/3.04/tests/data/expected-document-start.emitter-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/expected-document-start.emitter-error (revision 141) @@ -0,0 +1,4 @@ +- !StreamStart +- !MappingStart +- !MappingEnd +- !StreamEnd Index: /pyyaml/tags/3.04/tests/data/unsupported-version.emitter-error =================================================================== --- /pyyaml/tags/3.04/tests/data/unsupported-version.emitter-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/unsupported-version.emitter-error (revision 141) @@ -0,0 +1,5 @@ +- !StreamStart +- !DocumentStart { version: [5,6] } +- !Scalar { value: foo } +- !DocumentEnd +- !StreamEnd Index: /pyyaml/tags/3.04/tests/data/spec-10-11.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-11.canonical (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-10-11.canonical (revision 44) @@ -0,0 +1,24 @@ +%YAML 1.1 +--- +!!seq [ + !!map { + ? !!str "explicit key1" + : !!str "explicit value", + }, + !!map { + ? !!str "explicit key2" + : !!null "", + }, + !!map { + ? !!str "explicit key3" + : !!null "", + }, + !!map { + ? !!str "simple key1" + : !!str "explicit value", + }, + !!map { + ? !!str "simple key2" + : !!null "", + }, +] Index: /pyyaml/tags/3.04/tests/data/construct-python-float.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-float.data (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-float.data (revision 144) @@ -0,0 +1,1 @@ +!!python/float 123.456 Index: /pyyaml/tags/3.04/tests/data/float-representer-2.3-bug.code =================================================================== --- /pyyaml/tags/3.04/tests/data/float-representer-2.3-bug.code (revision 150) +++ /pyyaml/tags/3.04/tests/data/float-representer-2.3-bug.code (revision 150) @@ -0,0 +1,7 @@ +{ +# 0.0: 0, + 1.0: 1, + 1e300000: +10, + -1e300000: -10, + 1e300000/1e300000: 100, +} Index: /pyyaml/tags/3.04/tests/data/spec-07-04.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-04.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-04.canonical (revision 38) @@ -0,0 +1,3 @@ +%YAML 1.1 +--- +!!str "foo" Index: /pyyaml/tags/3.04/tests/data/duplicate-mapping-key.former-loader-error.code =================================================================== --- /pyyaml/tags/3.04/tests/data/duplicate-mapping-key.former-loader-error.code (revision 222) +++ /pyyaml/tags/3.04/tests/data/duplicate-mapping-key.former-loader-error.code (revision 222) @@ -0,0 +1,1 @@ +{ 'foo': { 'baz': 'bat', 'foo': 'duplicate key' } } Index: /pyyaml/tags/3.04/tests/data/construct-omap.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-omap.code (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-omap.code (revision 58) @@ -0,0 +1,8 @@ +{ + "Bestiary": [ + ("aardvark", "African pig-like ant eater. Ugly."), + ("anteater", "South-American ant eater. Two species."), + ("anaconda", "South-American constrictor snake. Scaly."), + ], + "Numbers": [ ("one", 1), ("two", 2), ("three", 3) ], +} Index: /pyyaml/tags/3.04/tests/data/invalid-tag-2.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-tag-2.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-tag-2.loader-error (revision 140) @@ -0,0 +1,1 @@ +- !prefix!foo#bar baz Index: /pyyaml/tags/3.04/tests/data/no-block-collection-end.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/no-block-collection-end.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/no-block-collection-end.loader-error (revision 140) @@ -0,0 +1,3 @@ +- foo +- bar +baz: bar Index: /pyyaml/tags/3.04/tests/data/spec-02-27.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-27.tokens (revision 41) +++ /pyyaml/tags/3.04/tests/data/spec-02-27.tokens (revision 41) @@ -0,0 +1,20 @@ +--- ! +{{ +? _ : _ +? _ : _ +? _ : & + {{ + ? _ : _ + ? _ : _ + ? _ : {{ ? _ : _ ? _ : _ ? _ : _ ? _ : _ ]} + ]} +? _ : * +? _ : + [[ + , {{ ? _ : _ ? _ : _ ? _ : _ ? _ : _ ]} + , {{ ? _ : _ ? _ : _ ? _ : _ ? _ : _ ]} + ]} +? _ : _ +? _ : _ +? _ : _ +]} Index: /pyyaml/tags/3.04/tests/data/bool.detect =================================================================== --- /pyyaml/tags/3.04/tests/data/bool.detect (revision 55) +++ /pyyaml/tags/3.04/tests/data/bool.detect (revision 55) @@ -0,0 +1,1 @@ +tag:yaml.org,2002:bool Index: /pyyaml/tags/3.04/tests/data/bool.data =================================================================== --- /pyyaml/tags/3.04/tests/data/bool.data (revision 59) +++ /pyyaml/tags/3.04/tests/data/bool.data (revision 59) @@ -0,0 +1,4 @@ +- yes +- NO +- True +- on Index: /pyyaml/tags/3.04/tests/data/spec-02-24.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-24.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-24.data (revision 38) @@ -0,0 +1,14 @@ +%TAG ! tag:clarkevans.com,2002: +--- !shape + # Use the ! handle for presenting + # tag:clarkevans.com,2002:circle +- !circle + center: &ORIGIN {x: 73, y: 129} + radius: 7 +- !line + start: *ORIGIN + finish: { x: 89, y: 102 } +- !label + start: *ORIGIN + color: 0xFFEEBB + text: Pretty vector drawing. Index: /pyyaml/tags/3.04/tests/data/spec-05-02-utf8.error =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-02-utf8.error (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-02-utf8.error (revision 38) @@ -0,0 +1,3 @@ +ERROR: + A BOM must not appear + inside a document. Index: /pyyaml/tags/3.04/tests/data/spec-08-12.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-12.data (revision 130) +++ /pyyaml/tags/3.04/tests/data/spec-08-12.data (revision 130) @@ -0,0 +1,8 @@ +[ + Without properties, + &anchor "Anchored", + !!str 'Tagged', + *anchor, # Alias node + !!str , # Empty plain scalar + '', # Empty plain scalar +] Index: /pyyaml/tags/3.04/tests/data/construct-value.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-value.code (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-value.code (revision 58) @@ -0,0 +1,9 @@ +[ + { "link with": [ "library1.dll", "library2.dll" ] }, + { + "link with": [ + { "=": "library1.dll", "version": 1.2 }, + { "=": "library2.dll", "version": 2.3 }, + ], + }, +] Index: /pyyaml/tags/3.04/tests/data/construct-pairs.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-pairs.data (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-pairs.data (revision 58) @@ -0,0 +1,7 @@ +# Explicitly typed pairs. +Block tasks: !!pairs + - meeting: with team. + - meeting: with boss. + - break: lunch. + - meeting: with client. +Flow tasks: !!pairs [ meeting: with team, meeting: with boss ] Index: /pyyaml/tags/3.04/tests/data/spec-05-08.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-08.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-08.data (revision 38) @@ -0,0 +1,2 @@ +single: 'text' +double: "text" Index: /pyyaml/tags/3.04/tests/data/spec-05-01-utf16le.empty =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-01-utf16le.empty (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-01-utf16le.empty (revision 38) @@ -0,0 +1,2 @@ +# This stream contains no +# documents, only comments. Index: /pyyaml/tags/3.04/tests/data/spec-09-08.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-08.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-08.data (revision 38) @@ -0,0 +1,5 @@ + 'as space  + trimmed  + + specific‹ + none' Index: /pyyaml/tags/3.04/tests/data/invalid-yaml-directive-version-1.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-yaml-directive-version-1.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-yaml-directive-version-1.loader-error (revision 140) @@ -0,0 +1,3 @@ +# No version at all. +%YAML +--- Index: /pyyaml/tags/3.04/tests/data/expected-stream-start.emitter-error =================================================================== --- /pyyaml/tags/3.04/tests/data/expected-stream-start.emitter-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/expected-stream-start.emitter-error (revision 141) @@ -0,0 +1,2 @@ +- !DocumentStart +- !DocumentEnd Index: /pyyaml/tags/3.04/tests/data/spec-07-13.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-13.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-13.canonical (revision 38) @@ -0,0 +1,9 @@ +%YAML 1.1 +--- +!!str "First document" +--- +! "No directives" +--- +! "With directives" +--- +! "Reset settings" Index: /pyyaml/tags/3.04/tests/data/construct-timestamp.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-timestamp.data (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-timestamp.data (revision 58) @@ -0,0 +1,5 @@ +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 -5 +no time zone (Z): 2001-12-15 2:59:43.10 +date (00:00:00Z): 2002-12-14 Index: /pyyaml/tags/3.04/tests/data/undefined-tag-handle.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/undefined-tag-handle.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/undefined-tag-handle.loader-error (revision 140) @@ -0,0 +1,1 @@ +--- !foo!bar baz Index: /pyyaml/tags/3.04/tests/data/expected-nothing.emitter-error =================================================================== --- /pyyaml/tags/3.04/tests/data/expected-nothing.emitter-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/expected-nothing.emitter-error (revision 141) @@ -0,0 +1,4 @@ +- !StreamStart +- !StreamEnd +- !StreamStart +- !StreamEnd Index: /pyyaml/tags/3.04/tests/data/spec-10-08.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-08.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-10-08.data (revision 38) @@ -0,0 +1,5 @@ +{ +multi-line + simple key : value, +very long ...................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................(>1KB)................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................... key: value +} Index: /pyyaml/tags/3.04/tests/data/construct-python-long-short.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-long-short.code (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-long-short.code (revision 144) @@ -0,0 +1,1 @@ +123L Index: /pyyaml/tags/3.04/tests/data/spec-07-05.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-05.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-05.data (revision 38) @@ -0,0 +1,3 @@ +%TAG ! !foo +%TAG ! !foo +bar Index: /pyyaml/tags/3.04/tests/data/spec-07-07a.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-07a.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-07a.data (revision 38) @@ -0,0 +1,2 @@ +# Private application: +!foo "bar" Index: /pyyaml/tags/3.04/tests/data/construct-python-name-module.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-name-module.data (revision 146) +++ /pyyaml/tags/3.04/tests/data/construct-python-name-module.data (revision 146) @@ -0,0 +1,5 @@ +- !!python/name:file +- !!python/name:yaml.Loader +- !!python/name:yaml.dump +- !!python/name:abs +- !!python/module:yaml.tokens Index: /pyyaml/tags/3.04/tests/data/spec-09-17.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-17.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-17.data (revision 38) @@ -0,0 +1,3 @@ + first line + + more line Index: /pyyaml/tags/3.04/tests/data/expected-node-2.emitter-error =================================================================== --- /pyyaml/tags/3.04/tests/data/expected-node-2.emitter-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/expected-node-2.emitter-error (revision 141) @@ -0,0 +1,7 @@ +- !StreamStart +- !DocumentStart +- !MappingStart +- !Scalar { value: 'key' } +- !MappingEnd +- !DocumentEnd +- !StreamEnd Index: /pyyaml/tags/3.04/tests/data/spec-07-01.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-01.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-01.canonical (revision 38) @@ -0,0 +1,3 @@ +%YAML 1.1 +--- !!str +"foo" Index: /pyyaml/tags/3.04/tests/data/invalid-yaml-directive-version-6.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-yaml-directive-version-6.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-yaml-directive-version-6.loader-error (revision 140) @@ -0,0 +1,2 @@ +%YAML 123.C +--- Index: /pyyaml/tags/3.04/tests/data/spec-08-15.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-15.canonical (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-08-15.canonical (revision 44) @@ -0,0 +1,11 @@ +%YAML 1.1 +--- +!!seq [ + !!null "", + !!map { + ? !!str "foo" + : !!null "", + ? !!null "" + : !!str "bar", + } +] Index: /pyyaml/tags/3.04/tests/data/invalid-escape-numbers.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-escape-numbers.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-escape-numbers.loader-error (revision 140) @@ -0,0 +1,1 @@ +"hm.... \u123?" Index: /pyyaml/tags/3.04/tests/data/no-node-2.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/no-node-2.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/no-node-2.loader-error (revision 140) @@ -0,0 +1,1 @@ +- [ !foo } ] Index: /pyyaml/tags/3.04/tests/data/spec-09-08.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-08.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-08.canonical (revision 38) @@ -0,0 +1,6 @@ +%YAML 1.1 +--- +!!str "as space \ + trimmed\n\ + specific\L\n\ + none" Index: /pyyaml/tags/3.04/tests/data/spec-02-05.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-05.tokens (revision 39) +++ /pyyaml/tags/3.04/tests/data/spec-02-05.tokens (revision 39) @@ -0,0 +1,5 @@ +[[ +, [ _ , _ , _ ] +, [ _ , _ , _ ] +, [ _ , _ , _ ] +]} Index: /pyyaml/tags/3.04/tests/data/spec-09-29.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-29.canonical (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-09-29.canonical (revision 44) @@ -0,0 +1,4 @@ +%YAML 1.1 +--- +!!str "folded text\n\ + \tlines\n" Index: /pyyaml/tags/3.04/tests/data/empty-anchor.emitter-error =================================================================== --- /pyyaml/tags/3.04/tests/data/empty-anchor.emitter-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/empty-anchor.emitter-error (revision 141) @@ -0,0 +1,5 @@ +- !StreamStart +- !DocumentStart +- !Scalar { anchor: '', value: 'foo' } +- !DocumentEnd +- !StreamEnd Index: /pyyaml/tags/3.04/tests/data/spec-09-02.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-02.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-02.data (revision 38) @@ -0,0 +1,6 @@ + "as space + trimmed + + specific‹ + escaped \
 + none" Index: /pyyaml/tags/3.04/tests/data/spec-09-26.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-26.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-26.data (revision 38) @@ -0,0 +1,8 @@ +| + + + literal + + text + + # Comment Index: /pyyaml/tags/3.04/tests/data/no-document-start.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/no-document-start.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/no-document-start.loader-error (revision 140) @@ -0,0 +1,3 @@ +%YAML 1.1 +# no --- +foo: bar Index: /pyyaml/tags/3.04/tests/data/spec-07-10.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-10.canonical (revision 48) +++ /pyyaml/tags/3.04/tests/data/spec-07-10.canonical (revision 48) @@ -0,0 +1,15 @@ +%YAML 1.1 +--- +!!str "Root flow scalar" +%YAML 1.1 +--- +!!str "Root block scalar\n" +%YAML 1.1 +--- +!!map { + ? !!str "foo" + : !!str "bar" +} +--- +#!!str "" +!!null "" Index: /pyyaml/tags/3.04/tests/data/spec-08-03.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-03.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-08-03.canonical (revision 38) @@ -0,0 +1,6 @@ +%YAML 1.1 +--- +!!map { + ? ! "foo" + : ! "baz" +} Index: /pyyaml/tags/3.04/tests/data/spec-09-21.error =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-21.error (revision 42) +++ /pyyaml/tags/3.04/tests/data/spec-09-21.error (revision 42) @@ -0,0 +1,7 @@ +ERROR: +- A leading all-space line must + not have too many spaces. +- A following text line must + not be less indented. +- The text is less indented + than the indicated level. Index: /pyyaml/tags/3.04/tests/data/spec-07-07b.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-07b.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-07b.canonical (revision 38) @@ -0,0 +1,3 @@ +%YAML 1.1 +--- +! "bar" Index: /pyyaml/tags/3.04/tests/data/spec-09-17.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-17.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-17.canonical (revision 38) @@ -0,0 +1,4 @@ +%YAML 1.1 +--- +!!str "first line\n\ + more line" Index: /pyyaml/tags/3.04/tests/data/invalid-pairs-1.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-pairs-1.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-pairs-1.loader-error (revision 140) @@ -0,0 +1,3 @@ +--- !!pairs +foo: bar +baz: bat Index: /pyyaml/tags/3.04/tests/data/spec-02-14.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-14.tokens (revision 41) +++ /pyyaml/tags/3.04/tests/data/spec-02-14.tokens (revision 41) @@ -0,0 +1,1 @@ +--- _ Index: /pyyaml/tags/3.04/tests/data/spec-02-19.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-19.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-19.structure (revision 44) @@ -0,0 +1,1 @@ +[(True, True), (True, True), (True, True), (True, True), (True, True)] Index: /pyyaml/tags/3.04/tests/data/spec-10-02.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-02.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-10-02.data (revision 38) @@ -0,0 +1,8 @@ +[ +"double + quoted", 'single + quoted', +plain + text, [ nested ], +single: pair , +] Index: /pyyaml/tags/3.04/tests/data/spec-05-11.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-11.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-11.data (revision 38) @@ -0,0 +1,4 @@ +| + Generic line break (no glyph) + Generic line break (glyphed) + Line separator‹ Paragraph separator
 Index: /pyyaml/tags/3.04/tests/data/spec-02-07.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-07.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-07.data (revision 38) @@ -0,0 +1,10 @@ +# Ranking of 1998 home runs +--- +- Mark McGwire +- Sammy Sosa +- Ken Griffey + +# Team ranking +--- +- Chicago Cubs +- St Louis Cardinals Index: /pyyaml/tags/3.04/tests/data/spec-09-11.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-11.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-11.data (revision 38) @@ -0,0 +1,5 @@ +- 'first + ' +- 'first + + last' Index: /pyyaml/tags/3.04/tests/data/construct-python-str-ascii.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-str-ascii.code (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-str-ascii.code (revision 144) @@ -0,0 +1,1 @@ +"ascii string" Index: /pyyaml/tags/3.04/tests/data/spec-06-07.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-06-07.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-06-07.data (revision 38) @@ -0,0 +1,8 @@ +- foo + + bar +- |- + foo + + bar + Index: /pyyaml/tags/3.04/tests/data/invalid-omap-1.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-omap-1.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-omap-1.loader-error (revision 140) @@ -0,0 +1,3 @@ +--- !!omap +foo: bar +baz: bat Index: /pyyaml/tags/3.04/tests/data/invalid-tag-handle-1.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-tag-handle-1.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-tag-handle-1.loader-error (revision 140) @@ -0,0 +1,2 @@ +%TAG foo bar +--- Index: /pyyaml/tags/3.04/tests/data/invalid-python-module.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-python-module.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-python-module.loader-error (revision 140) @@ -0,0 +1,1 @@ +--- !!python/module:no.such.module Index: /pyyaml/tags/3.04/tests/data/spec-08-12.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-12.canonical (revision 130) +++ /pyyaml/tags/3.04/tests/data/spec-08-12.canonical (revision 130) @@ -0,0 +1,10 @@ +%YAML 1.1 +--- +!!seq [ + !!str "Without properties", + &A !!str "Anchored", + !!str "Tagged", + *A, + !!str "", + !!str "", +] Index: /pyyaml/tags/3.04/tests/data/spec-05-07.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-07.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-07.canonical (revision 38) @@ -0,0 +1,8 @@ +%YAML 1.1 +--- +!!map { + ? !!str "literal" + : !!str "text\n", + ? !!str "folded" + : !!str "text\n", +} Index: /pyyaml/tags/3.04/tests/data/spec-09-05.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-05.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-05.canonical (revision 38) @@ -0,0 +1,7 @@ +%YAML 1.1 +--- +!!seq [ + !!str "first ", + !!str "first\nlast", + !!str "first inner \tlast", +] Index: /pyyaml/tags/3.04/tests/data/invalid-anchor-2.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-anchor-2.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-anchor-2.loader-error (revision 140) @@ -0,0 +1,8 @@ +--- +- [ + &correct foo, + *correct, + *correct] # still correct +- *correct: still correct +- &correct-or-not[foo, bar] + Index: /pyyaml/tags/3.04/tests/data/spec-09-26.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-26.canonical (revision 48) +++ /pyyaml/tags/3.04/tests/data/spec-09-26.canonical (revision 48) @@ -0,0 +1,3 @@ +%YAML 1.1 +--- +!!str "\n\nliteral\n\ntext\n" Index: /pyyaml/tags/3.04/tests/data/spec-02-07.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-07.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-07.structure (revision 44) @@ -0,0 +1,4 @@ +[ +[True, True, True], +[True, True], +] Index: /pyyaml/tags/3.04/tests/data/duplicate-key.former-loader-error.code =================================================================== --- /pyyaml/tags/3.04/tests/data/duplicate-key.former-loader-error.code (revision 222) +++ /pyyaml/tags/3.04/tests/data/duplicate-key.former-loader-error.code (revision 222) @@ -0,0 +1,1 @@ +{ 'foo': 'baz' } Index: /pyyaml/tags/3.04/tests/data/spec-02-23.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-23.tokens (revision 41) +++ /pyyaml/tags/3.04/tests/data/spec-02-23.tokens (revision 41) @@ -0,0 +1,6 @@ +--- +{{ +? _ : ! _ +? _ : ! _ +? _ : ! _ +]} Index: /pyyaml/tags/3.04/tests/data/spec-02-28.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-28.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-28.structure (revision 44) @@ -0,0 +1,10 @@ +[ +[(True, True), (True, True), (True, True)], +[(True, True), (True, True), (True, True)], +[(True, True), (True, True), (True, True), +(True, [ + [(True, True), (True, True), (True, True)], + [(True, True), (True, True), (True, True)], + ]), +] +] Index: /pyyaml/tags/3.04/tests/data/spec-10-11.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-11.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-10-11.data (revision 38) @@ -0,0 +1,7 @@ +[ +? explicit key1 : explicit value, +? explicit key2 : , # Explicit empty +? explicit key3, # Implicit empty +simple key1 : explicit value, +simple key2 : , # Explicit empty +] Index: /pyyaml/tags/3.04/tests/data/empty-tag-prefix.emitter-error =================================================================== --- /pyyaml/tags/3.04/tests/data/empty-tag-prefix.emitter-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/empty-tag-prefix.emitter-error (revision 141) @@ -0,0 +1,5 @@ +- !StreamStart +- !DocumentStart { tags: { '!': '' } } +- !Scalar { value: 'foo' } +- !DocumentEnd +- !StreamEnd Index: /pyyaml/tags/3.04/tests/data/invalid-indentation-indicator-2.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-indentation-indicator-2.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-indentation-indicator-2.loader-error (revision 140) @@ -0,0 +1,2 @@ +--- >-0 +data Index: /pyyaml/tags/3.04/tests/data/spec-02-16.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-16.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-16.data (revision 38) @@ -0,0 +1,7 @@ +name: Mark McGwire +accomplishment: > + Mark set a major league + home run record in 1998. +stats: | + 65 Home Runs + 0.278 Batting Average Index: /pyyaml/tags/3.04/tests/data/spec-09-20.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-20.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-20.data (revision 38) @@ -0,0 +1,11 @@ +- | + detected +- > + + + # detected +- |1 + explicit +- > + + detected Index: /pyyaml/tags/3.04/tests/data/spec-08-04.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-04.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-08-04.data (revision 38) @@ -0,0 +1,2 @@ +- ! foo +- !<$:?> bar Index: /pyyaml/tags/3.04/tests/data/str.detect =================================================================== --- /pyyaml/tags/3.04/tests/data/str.detect (revision 55) +++ /pyyaml/tags/3.04/tests/data/str.detect (revision 55) @@ -0,0 +1,1 @@ +tag:yaml.org,2002:str Index: /pyyaml/tags/3.04/tests/data/invalid-directive-line.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-directive-line.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-directive-line.loader-error (revision 140) @@ -0,0 +1,2 @@ +%YAML 1.1 ? # extra symbol +--- Index: /pyyaml/tags/3.04/tests/data/no-tag.emitter-error =================================================================== --- /pyyaml/tags/3.04/tests/data/no-tag.emitter-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/no-tag.emitter-error (revision 141) @@ -0,0 +1,5 @@ +- !StreamStart +- !DocumentStart +- !Scalar { value: 'foo', implicit: [false,false] } +- !DocumentEnd +- !StreamEnd Index: /pyyaml/tags/3.04/tests/data/spec-10-09.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-09.canonical (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-10-09.canonical (revision 44) @@ -0,0 +1,8 @@ +%YAML 1.1 +--- +!!map { + ? !!str "key" + : !!str "value", + ? !!str "empty" + : !!null "", +} Index: /pyyaml/tags/3.04/tests/data/construct-set.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-set.data (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-set.data (revision 58) @@ -0,0 +1,7 @@ +# Explicitly typed set. +baseball players: !!set + ? Mark McGwire + ? Sammy Sosa + ? Ken Griffey +# Flow style +baseball teams: !!set { Boston Red Sox, Detroit Tigers, New York Yankees } Index: /pyyaml/tags/3.04/tests/data/construct-merge.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-merge.code (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-merge.code (revision 58) @@ -0,0 +1,10 @@ +[ + { "x": 1, "y": 2 }, + { "x": 0, "y": 2 }, + { "r": 10 }, + { "r": 1 }, + { "x": 1, "y": 2, "r": 10, "label": "center/big" }, + { "x": 1, "y": 2, "r": 10, "label": "center/big" }, + { "x": 1, "y": 2, "r": 10, "label": "center/big" }, + { "x": 1, "y": 2, "r": 10, "label": "center/big" }, +] Index: /pyyaml/tags/3.04/tests/data/spec-02-16.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-16.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-16.structure (revision 44) @@ -0,0 +1,1 @@ +[(True, True), (True, True), (True, True)] Index: /pyyaml/tags/3.04/tests/data/spec-02-01.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-01.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-01.data (revision 38) @@ -0,0 +1,3 @@ +- Mark McGwire +- Sammy Sosa +- Ken Griffey Index: /pyyaml/tags/3.04/tests/data/spec-06-01.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-06-01.data (revision 48) +++ /pyyaml/tags/3.04/tests/data/spec-06-01.data (revision 48) @@ -0,0 +1,14 @@ + # Leading comment line spaces are + # neither content nor indentation. + +Not indented: + By one space: | + By four + spaces + Flow style: [ # Leading spaces + By two, # in flow style + Also by two, # are neither +# Tabs are not allowed: +# Still by two # content nor + Still by two # content nor + ] # indentation. Index: /pyyaml/tags/3.04/tests/data/spec-02-25.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-25.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-25.data (revision 38) @@ -0,0 +1,7 @@ +# sets are represented as a +# mapping where each key is +# associated with the empty string +--- !!set +? Mark McGwire +? Sammy Sosa +? Ken Griff Index: /pyyaml/tags/3.04/tests/data/empty-tag.emitter-error =================================================================== --- /pyyaml/tags/3.04/tests/data/empty-tag.emitter-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/empty-tag.emitter-error (revision 141) @@ -0,0 +1,5 @@ +- !StreamStart +- !DocumentStart +- !Scalar { tag: '', value: 'key', implicit: [false,false] } +- !DocumentEnd +- !StreamEnd Index: /pyyaml/tags/3.04/tests/data/duplicate-value-key.former-loader-error.code =================================================================== --- /pyyaml/tags/3.04/tests/data/duplicate-value-key.former-loader-error.code (revision 222) +++ /pyyaml/tags/3.04/tests/data/duplicate-value-key.former-loader-error.code (revision 222) @@ -0,0 +1,1 @@ +{ 'foo': 'bar', '=': 2 } Index: /pyyaml/tags/3.04/tests/data/spec-08-13.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-08-13.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-08-13.data (revision 38) @@ -0,0 +1,4 @@ +{ + ? foo :, + ? : bar, +} Index: /pyyaml/tags/3.04/tests/data/timestamp-bugs.data =================================================================== --- /pyyaml/tags/3.04/tests/data/timestamp-bugs.data (revision 225) +++ /pyyaml/tags/3.04/tests/data/timestamp-bugs.data (revision 225) @@ -0,0 +1,5 @@ +- 2001-12-14 21:59:43.10 -5:30 +- 2001-12-14 21:59:43.10 +5:30 +- 2001-12-14 21:59:43.00101 +- 2001-12-14 21:59:43+1 +- 2001-12-14 21:59:43-1:30 Index: /pyyaml/tags/3.04/tests/data/unclosed-quoted-scalar.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/unclosed-quoted-scalar.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/unclosed-quoted-scalar.loader-error (revision 140) @@ -0,0 +1,2 @@ +'foo + bar Index: /pyyaml/tags/3.04/tests/data/spec-05-09.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-09.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-09.data (revision 38) @@ -0,0 +1,2 @@ +%YAML 1.1 +--- text Index: /pyyaml/tags/3.04/tests/data/duplicate-anchor-1.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/duplicate-anchor-1.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/duplicate-anchor-1.loader-error (revision 140) @@ -0,0 +1,3 @@ +- &foo bar +- &bar bar +- &foo bar Index: /pyyaml/tags/3.04/tests/data/spec-09-09.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-09.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-09.data (revision 38) @@ -0,0 +1,6 @@ +- ' + last' +- ' + last' +- ' first + last' Index: /pyyaml/tags/3.04/tests/data/expected-document-end.emitter-error =================================================================== --- /pyyaml/tags/3.04/tests/data/expected-document-end.emitter-error (revision 141) +++ /pyyaml/tags/3.04/tests/data/expected-document-end.emitter-error (revision 141) @@ -0,0 +1,6 @@ +- !StreamStart +- !DocumentStart +- !Scalar { value: 'data 1' } +- !Scalar { value: 'data 2' } +- !DocumentEnd +- !StreamEnd Index: /pyyaml/tags/3.04/tests/data/spec-05-04.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-04.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-04.canonical (revision 38) @@ -0,0 +1,13 @@ +%YAML 1.1 +--- +!!map { + ? !!str "sequence" + : !!seq [ + !!str "one", !!str "two" + ], + ? !!str "mapping" + : !!map { + ? !!str "sky" : !!str "blue", + ? !!str "sea" : !!str "green", + } +} Index: /pyyaml/tags/3.04/tests/data/spec-09-02.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-02.canonical (revision 48) +++ /pyyaml/tags/3.04/tests/data/spec-09-02.canonical (revision 48) @@ -0,0 +1,7 @@ +%YAML 1.1 +--- +!!str "as space \ + trimmed\n\ + specific\L\n\ + escaped\t\n\ + none" Index: /pyyaml/tags/3.04/tests/data/construct-str-utf8.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-str-utf8.data (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-str-utf8.data (revision 144) @@ -0,0 +1,1 @@ +--- !!str "ЭтП уМОкПЎМая стрПка" Index: /pyyaml/tags/3.04/tests/data/construct-bool.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-bool.code (revision 226) +++ /pyyaml/tags/3.04/tests/data/construct-bool.code (revision 226) @@ -0,0 +1,7 @@ +{ + "canonical": True, + "answer": False, + "logical": True, + "option": True, + "but": { "y": "is a string", "n": "is a string" }, +} Index: /pyyaml/tags/3.04/tests/data/spec-09-23.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-23.canonical (revision 42) +++ /pyyaml/tags/3.04/tests/data/spec-09-23.canonical (revision 42) @@ -0,0 +1,10 @@ +%YAML 1.1 +--- +!!map { + ? !!str "strip" + : !!str "# text", + ? !!str "clip" + : !!str "# text\n", + ? !!str "keep" + : !!str "# text\L\n", +} Index: /pyyaml/tags/3.04/tests/data/construct-str-ascii.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-str-ascii.data (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-str-ascii.data (revision 144) @@ -0,0 +1,1 @@ +--- !!str "ascii string" Index: /pyyaml/tags/3.04/tests/data/spec-02-04.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-04.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-04.structure (revision 44) @@ -0,0 +1,4 @@ +[ + [(True, True), (True, True), (True, True)], + [(True, True), (True, True), (True, True)], +] Index: /pyyaml/tags/3.04/tests/data/spec-02-01.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-01.tokens (revision 39) +++ /pyyaml/tags/3.04/tests/data/spec-02-01.tokens (revision 39) @@ -0,0 +1,1 @@ +[[ , _ , _ , _ ]} Index: /pyyaml/tags/3.04/tests/data/spec-02-25.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-25.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-25.structure (revision 44) @@ -0,0 +1,1 @@ +[(True, None), (True, None), (True, None)] Index: /pyyaml/tags/3.04/tests/data/spec-02-10.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-10.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-10.data (revision 38) @@ -0,0 +1,8 @@ +--- +hr: + - Mark McGwire + # Following node labeled SS + - &SS Sammy Sosa +rbi: + - *SS # Subsequent occurrence + - Ken Griffey Index: /pyyaml/tags/3.04/tests/data/spec-02-19.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-19.tokens (revision 41) +++ /pyyaml/tags/3.04/tests/data/spec-02-19.tokens (revision 41) @@ -0,0 +1,7 @@ +{{ +? _ : _ +? _ : _ +? _ : _ +? _ : _ +? _ : _ +]} Index: /pyyaml/tags/3.04/tests/data/documents.events =================================================================== --- /pyyaml/tags/3.04/tests/data/documents.events (revision 137) +++ /pyyaml/tags/3.04/tests/data/documents.events (revision 137) @@ -0,0 +1,11 @@ +- !StreamStart +- !DocumentStart { explicit: false } +- !Scalar { implicit: [true,false], value: 'data' } +- !DocumentEnd +- !DocumentStart +- !Scalar { implicit: [true,false] } +- !DocumentEnd +- !DocumentStart { version: [1,1], tags: { '!': '!foo', '!yaml!': 'tag:yaml.org,2002:', '!ugly!': '!!!!!!!' } } +- !Scalar { implicit: [true,false] } +- !DocumentEnd +- !StreamEnd Index: /pyyaml/tags/3.04/tests/data/construct-python-bool.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-bool.data (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-bool.data (revision 144) @@ -0,0 +1,1 @@ +[ !!python/bool True, !!python/bool False ] Index: /pyyaml/tags/3.04/tests/data/scan-document-end-bug.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/scan-document-end-bug.canonical (revision 138) +++ /pyyaml/tags/3.04/tests/data/scan-document-end-bug.canonical (revision 138) @@ -0,0 +1,3 @@ +%YAML 1.1 +--- +!!null "" Index: /pyyaml/tags/3.04/tests/data/test_mark.marks =================================================================== --- /pyyaml/tags/3.04/tests/data/test_mark.marks (revision 116) +++ /pyyaml/tags/3.04/tests/data/test_mark.marks (revision 116) @@ -0,0 +1,38 @@ +--- +*The first line. +The last line. +--- +The first*line. +The last line. +--- +The first line.* +The last line. +--- +The first line. +*The last line. +--- +The first line. +The last*line. +--- +The first line. +The last line.* +--- +The first line. +*The selected line. +The last line. +--- +The first line. +The selected*line. +The last line. +--- +The first line. +The selected line.* +The last line. +--- +*The only line. +--- +The only*line. +--- +The only line.* +--- +Loooooooooooooooooooooooooooooooooooooooooooooong*Liiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiine Index: /pyyaml/tags/3.04/tests/data/spec-10-09.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-09.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-10-09.data (revision 38) @@ -0,0 +1,4 @@ +{ +key : value, +empty: # empty value↓ +} Index: /pyyaml/tags/3.04/tests/data/spec-07-06.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-06.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-06.data (revision 38) @@ -0,0 +1,5 @@ +%TAG ! !foo +%TAG !yaml! tag:yaml.org,2002: +--- +- !bar "baz" +- !yaml!str "string" Index: /pyyaml/tags/3.04/tests/data/construct-python-none.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-none.code (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-none.code (revision 144) @@ -0,0 +1,1 @@ +None Index: /pyyaml/tags/3.04/tests/data/spec-07-07b.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-07b.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-07-07b.data (revision 38) @@ -0,0 +1,4 @@ +# Migrated to global: +%TAG ! tag:ben-kiki.org,2000:app/ +--- +!foo "bar" Index: /pyyaml/tags/3.04/tests/data/spec-09-18.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-18.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-18.data (revision 38) @@ -0,0 +1,9 @@ +- | # Just the style + literal +- >1 # Indentation indicator + folded +- |+ # Chomping indicator + keep + +- >-1 # Both indicators + strip Index: /pyyaml/tags/3.04/tests/data/construct-python-object.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-object.data (revision 147) +++ /pyyaml/tags/3.04/tests/data/construct-python-object.data (revision 147) @@ -0,0 +1,21 @@ +- !!python/object:test_constructor.AnObject { foo: 1, bar: two, baz: [3,3,3] } +- !!python/object:test_constructor.AnInstance { foo: 1, bar: two, baz: [3,3,3] } + +- !!python/object/new:test_constructor.AnObject { args: [1, two], kwds: {baz: [3,3,3]} } +- !!python/object/apply:test_constructor.AnInstance { args: [1, two], kwds: {baz: [3,3,3]} } + +- !!python/object:test_constructor.AState { _foo: 1, _bar: two, _baz: [3,3,3] } +- !!python/object/new:test_constructor.ACustomState { state: !!python/tuple [1, two, [3,3,3]] } + +- !!python/object/new:test_constructor.InitArgs [1, two, [3,3,3]] +- !!python/object/new:test_constructor.InitArgsWithState { args: [1, two], state: [3,3,3] } + +- !!python/object/new:test_constructor.NewArgs [1, two, [3,3,3]] +- !!python/object/new:test_constructor.NewArgsWithState { args: [1, two], state: [3,3,3] } + +- !!python/object/apply:test_constructor.Reduce [1, two, [3,3,3]] +- !!python/object/apply:test_constructor.ReduceWithState { args: [1, two], state: [3,3,3] } + +- !!python/object/new:test_constructor.MyInt [3] +- !!python/object/new:test_constructor.MyList { listitems: [~, ~, ~] } +- !!python/object/new:test_constructor.MyDict { dictitems: {0, 1, 2} } Index: /pyyaml/tags/3.04/tests/data/spec-10-06.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-06.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-10-06.canonical (revision 38) @@ -0,0 +1,16 @@ +%YAML 1.1 +--- +!!seq [ + !!map { + ? !!str "inner" + : !!str "entry", + ? !!str "also" + : !!str "inner" + }, + !!map { + ? !!str "inner" + : !!str "entry", + ? !!str "last" + : !!str "entry" + } +] Index: /pyyaml/tags/3.04/tests/data/spec-05-13.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-13.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-13.canonical (revision 38) @@ -0,0 +1,5 @@ +%YAML 1.1 +--- !!str +"Text containing \ + both space and \ + tab characters" Index: /pyyaml/tags/3.04/tests/data/spec-09-11.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-11.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-11.canonical (revision 38) @@ -0,0 +1,6 @@ +%YAML 1.1 +--- +!!seq [ + !!str "first ", + !!str "first\nlast", +] Index: /pyyaml/tags/3.04/tests/data/spec-06-06.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-06-06.canonical (revision 48) +++ /pyyaml/tags/3.04/tests/data/spec-06-06.canonical (revision 48) @@ -0,0 +1,10 @@ +%YAML 1.1 +--- +!!map { + ? !!str "plain" + : !!str "text lines", + ? !!str "quoted" + : !!str "text lines", + ? !!str "block" + : !!str "text\n lines\n" +} Index: /pyyaml/tags/3.04/tests/data/invalid-block-scalar-indicator.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-block-scalar-indicator.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-block-scalar-indicator.loader-error (revision 140) @@ -0,0 +1,2 @@ +--- > what is this? # a comment +data Index: /pyyaml/tags/3.04/tests/data/spec-09-32.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-32.canonical (revision 51) +++ /pyyaml/tags/3.04/tests/data/spec-09-32.canonical (revision 51) @@ -0,0 +1,7 @@ +%YAML 1.1 +--- +!!str "folded line\n\ + next line\n\n\ + \ * bullet\n\ + \ * list\n\n\ + last line\n" Index: /pyyaml/tags/3.04/tests/data/spec-02-13.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-13.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-13.structure (revision 44) @@ -0,0 +1,1 @@ +True Index: /pyyaml/tags/3.04/tests/data/spec-02-10.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-10.tokens (revision 39) +++ /pyyaml/tags/3.04/tests/data/spec-02-10.tokens (revision 39) @@ -0,0 +1,5 @@ +--- +{{ +? _ : [[ , _ , & _ ]} +? _ : [[ , * , _ ]} +]} Index: /pyyaml/tags/3.04/tests/data/construct-float.data =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-float.data (revision 58) +++ /pyyaml/tags/3.04/tests/data/construct-float.data (revision 58) @@ -0,0 +1,6 @@ +canonical: 6.8523015e+5 +exponential: 685.230_15e+03 +fixed: 685_230.15 +sexagesimal: 190:20:30.15 +negative infinity: -.inf +not a number: .NaN Index: /pyyaml/tags/3.04/tests/data/tags.events =================================================================== --- /pyyaml/tags/3.04/tests/data/tags.events (revision 136) +++ /pyyaml/tags/3.04/tests/data/tags.events (revision 136) @@ -0,0 +1,12 @@ +- !StreamStart +- !DocumentStart +- !SequenceStart +- !Scalar { value: 'data' } +#- !Scalar { tag: '!', value: 'data' } +- !Scalar { tag: 'tag:yaml.org,2002:str', value: 'data' } +- !Scalar { tag: '!myfunnytag', value: 'data' } +- !Scalar { tag: '!my!ugly!tag', value: 'data' } +- !Scalar { tag: 'tag:my.domain.org,2002:data!? #', value: 'data' } +- !SequenceEnd +- !DocumentEnd +- !StreamEnd Index: /pyyaml/tags/3.04/tests/data/spec-02-28.tokens =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-28.tokens (revision 41) +++ /pyyaml/tags/3.04/tests/data/spec-02-28.tokens (revision 41) @@ -0,0 +1,23 @@ +--- +{{ +? _ : _ +? _ : _ +? _ : _ +]} +--- +{{ +? _ : _ +? _ : _ +? _ : _ +]} +--- +{{ +? _ : _ +? _ : _ +? _ : _ +? _ : + [[ + , {{ ? _ : _ ? _ : _ ? _ : _ ]} + , {{ ? _ : _ ? _ : _ ? _ : _ ]} + ]} +]} Index: /pyyaml/tags/3.04/tests/data/spec-05-03.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-03.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-03.data (revision 38) @@ -0,0 +1,7 @@ +sequence: +- one +- two +mapping: + ? sky + : blue + ? sea : green Index: /pyyaml/tags/3.04/tests/data/spec-09-03.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-03.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-03.data (revision 38) @@ -0,0 +1,6 @@ +- " + last" +- " + last" +- " first + last" Index: /pyyaml/tags/3.04/tests/data/spec-05-01-utf8.empty =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-01-utf8.empty (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-01-utf8.empty (revision 38) @@ -0,0 +1,2 @@ +# This stream contains no +# documents, only comments. Index: /pyyaml/tags/3.04/tests/data/spec-09-27.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-27.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-09-27.data (revision 38) @@ -0,0 +1,8 @@ +| + + + literal + + text + + # Comment Index: /pyyaml/tags/3.04/tests/data/unclosed-bracket.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/unclosed-bracket.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/unclosed-bracket.loader-error (revision 140) @@ -0,0 +1,6 @@ +test: + - [ foo: bar +# comment the rest of the stream to let the scanner detect the problem. +# - baz +#"we could have detected the unclosed bracket on the above line, but this would forbid such syntax as": { +#} Index: /pyyaml/tags/3.04/tests/data/spec-10-15.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-15.canonical (revision 42) +++ /pyyaml/tags/3.04/tests/data/spec-10-15.canonical (revision 42) @@ -0,0 +1,18 @@ +%YAML 1.1 +--- +!!seq [ + !!map { + ? !!str "sun" + : !!str "yellow" + }, + !!map { + ? !!map { + ? !!str "earth" + : !!str "blue" + } + : !!map { + ? !!str "moon" + : !!str "white" + } + } +] Index: /pyyaml/tags/3.04/tests/data/invalid-yaml-directive-version-4.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-yaml-directive-version-4.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-yaml-directive-version-4.loader-error (revision 140) @@ -0,0 +1,2 @@ +%YAML 1.132.435 +--- Index: /pyyaml/tags/3.04/tests/data/invalid-python-name-object.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-python-name-object.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-python-name-object.loader-error (revision 140) @@ -0,0 +1,1 @@ +--- !!python/name:os.path.rm_rf Index: /pyyaml/tags/3.04/tests/data/spec-09-20.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-20.canonical (revision 51) +++ /pyyaml/tags/3.04/tests/data/spec-09-20.canonical (revision 51) @@ -0,0 +1,8 @@ +%YAML 1.1 +--- +!!seq [ + !!str "detected\n", + !!str "\n\n# detected\n", + !!str " explicit\n", + !!str "\t\ndetected\n", +] Index: /pyyaml/tags/3.04/tests/data/spec-02-01.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-01.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-01.structure (revision 44) @@ -0,0 +1,1 @@ +[True, True, True] Index: /pyyaml/tags/3.04/tests/data/spec-02-22.structure =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-22.structure (revision 44) +++ /pyyaml/tags/3.04/tests/data/spec-02-22.structure (revision 44) @@ -0,0 +1,1 @@ +[(True, True), (True, True), (True, True), (True, True)] Index: /pyyaml/tags/3.04/tests/data/spec-07-08.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-07-08.canonical (revision 42) +++ /pyyaml/tags/3.04/tests/data/spec-07-08.canonical (revision 42) @@ -0,0 +1,7 @@ +%YAML 1.1 +--- +!!seq [ + ! "bar", + ! "string", + ! "baz" +] Index: /pyyaml/tags/3.04/tests/data/construct-python-tuple-list-dict.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-tuple-list-dict.code (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-tuple-list-dict.code (revision 144) @@ -0,0 +1,6 @@ +[ + [1, 2, 3, 4], + (1, 2, 3, 4), + {1: 2, 3: 4}, + {(0,0): 0, (0,1): 1, (1,0): 1, (1,1): 0}, +] Index: /pyyaml/tags/3.04/tests/data/invalid-uri-escapes-3.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-uri-escapes-3.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-uri-escapes-3.loader-error (revision 140) @@ -0,0 +1,1 @@ +--- ! baz Index: /pyyaml/tags/3.04/tests/data/spec-10-03.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-03.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-10-03.data (revision 38) @@ -0,0 +1,4 @@ +block: # Block + # sequence +- one +- two : three Index: /pyyaml/tags/3.04/tests/data/int.detect =================================================================== --- /pyyaml/tags/3.04/tests/data/int.detect (revision 55) +++ /pyyaml/tags/3.04/tests/data/int.detect (revision 55) @@ -0,0 +1,1 @@ +tag:yaml.org,2002:int Index: /pyyaml/tags/3.04/tests/data/colon-in-flow-context.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/colon-in-flow-context.loader-error (revision 149) +++ /pyyaml/tags/3.04/tests/data/colon-in-flow-context.loader-error (revision 149) @@ -0,0 +1,1 @@ +{ foo:bar } Index: /pyyaml/tags/3.04/tests/data/spec-05-12.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-05-12.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-05-12.data (revision 38) @@ -0,0 +1,9 @@ +# Tabs do's and don'ts: +# comment: +quoted: "Quoted " +block: | + void main() { + printf("Hello, world!\n"); + } +elsewhere: # separation + indentation, in plain scalar Index: /pyyaml/tags/3.04/tests/data/recursive-set.recursive =================================================================== --- /pyyaml/tags/3.04/tests/data/recursive-set.recursive (revision 228) +++ /pyyaml/tags/3.04/tests/data/recursive-set.recursive (revision 228) @@ -0,0 +1,7 @@ +try: + set +except NameError: + from sets import Set as set +value = set() +value.add(AnInstance(foo=value, bar=value)) +value.add(AnInstance(foo=value, bar=value)) Index: /pyyaml/tags/3.04/tests/data/spec-02-08.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-02-08.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-02-08.data (revision 38) @@ -0,0 +1,10 @@ +--- +time: 20:03:20 +player: Sammy Sosa +action: strike (miss) +... +--- +time: 20:03:47 +player: Sammy Sosa +action: grand slam +... Index: /pyyaml/tags/3.04/tests/data/spec-09-12.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-09-12.data (revision 48) +++ /pyyaml/tags/3.04/tests/data/spec-09-12.data (revision 48) @@ -0,0 +1,8 @@ +# Outside flow collection: +- ::std::vector +- Up, up, and away! +- -123 +# Inside flow collection: +- [ '::std::vector', + "Up, up, and away!", + -123 ] Index: /pyyaml/tags/3.04/tests/data/spec-06-08.data =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-06-08.data (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-06-08.data (revision 38) @@ -0,0 +1,7 @@ +>- + specific‹ trimmed +  +  + + as + space Index: /pyyaml/tags/3.04/tests/data/invalid-merge-1.loader-error =================================================================== --- /pyyaml/tags/3.04/tests/data/invalid-merge-1.loader-error (revision 140) +++ /pyyaml/tags/3.04/tests/data/invalid-merge-1.loader-error (revision 140) @@ -0,0 +1,2 @@ +foo: bar +<<: baz Index: /pyyaml/tags/3.04/tests/data/spec-10-03.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-10-03.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-10-03.canonical (revision 38) @@ -0,0 +1,12 @@ +%YAML 1.1 +--- +!!map { + ? !!str "block" + : !!seq [ + !!str "one", + !!map { + ? !!str "two" + : !!str "three" + } + ] +} Index: /pyyaml/tags/3.04/tests/data/construct-python-float.code =================================================================== --- /pyyaml/tags/3.04/tests/data/construct-python-float.code (revision 144) +++ /pyyaml/tags/3.04/tests/data/construct-python-float.code (revision 144) @@ -0,0 +1,1 @@ +123.456 Index: /pyyaml/tags/3.04/tests/data/spec-06-03.canonical =================================================================== --- /pyyaml/tags/3.04/tests/data/spec-06-03.canonical (revision 38) +++ /pyyaml/tags/3.04/tests/data/spec-06-03.canonical (revision 38) @@ -0,0 +1,6 @@ +%YAML 1.1 +--- +!!map { + ? !!str "key" + : !!str "value" +} Index: /pyyaml/tags/3.04/tests/test_constructor.py =================================================================== --- /pyyaml/tags/3.04/tests/test_constructor.py (revision 225) +++ /pyyaml/tags/3.04/tests/test_constructor.py (revision 225) @@ -0,0 +1,309 @@ + +import test_appliance + +import datetime +try: + set +except NameError: + from sets import Set as set + +from yaml import * + +import yaml.tokens + +class MyLoader(Loader): + pass +class MyDumper(Dumper): + pass + +class MyTestClass1: + + def __init__(self, x, y=0, z=0): + self.x = x + self.y = y + self.z = z + + def __eq__(self, other): + if isinstance(other, MyTestClass1): + return self.__class__, self.__dict__ == other.__class__, other.__dict__ + else: + return False + +def construct1(constructor, node): + mapping = constructor.construct_mapping(node) + return MyTestClass1(**mapping) +def represent1(representer, native): + return representer.represent_mapping("!tag1", native.__dict__) + +add_constructor("!tag1", construct1, Loader=MyLoader) +add_representer(MyTestClass1, represent1, Dumper=MyDumper) + +class MyTestClass2(MyTestClass1, YAMLObject): + + yaml_loader = MyLoader + yaml_dumper = MyDumper + yaml_tag = "!tag2" + + def from_yaml(cls, constructor, node): + x = constructor.construct_yaml_int(node) + return cls(x=x) + from_yaml = classmethod(from_yaml) + + def to_yaml(cls, representer, native): + return representer.represent_scalar(cls.yaml_tag, str(native.x)) + to_yaml = classmethod(to_yaml) + +class MyTestClass3(MyTestClass2): + + yaml_tag = "!tag3" + + def from_yaml(cls, constructor, node): + mapping = constructor.construct_mapping(node) + if '=' in mapping: + x = mapping['='] + del mapping['='] + mapping['x'] = x + return cls(**mapping) + from_yaml = classmethod(from_yaml) + + def to_yaml(cls, representer, native): + return representer.represent_mapping(cls.yaml_tag, native.__dict__) + to_yaml = classmethod(to_yaml) + +class YAMLObject1(YAMLObject): + + yaml_loader = MyLoader + yaml_dumper = MyDumper + yaml_tag = '!foo' + + def __init__(self, my_parameter=None, my_another_parameter=None): + self.my_parameter = my_parameter + self.my_another_parameter = my_another_parameter + + def __eq__(self, other): + if isinstance(other, YAMLObject1): + return self.__class__, self.__dict__ == other.__class__, other.__dict__ + else: + return False + +class YAMLObject2(YAMLObject): + + yaml_loader = MyLoader + yaml_dumper = MyDumper + yaml_tag = '!bar' + + def __init__(self, foo=1, bar=2, baz=3): + self.foo = foo + self.bar = bar + self.baz = baz + + def __getstate__(self): + return {1: self.foo, 2: self.bar, 3: self.baz} + + def __setstate__(self, state): + self.foo = state[1] + self.bar = state[2] + self.baz = state[3] + + def __eq__(self, other): + if isinstance(other, YAMLObject2): + return self.__class__, self.__dict__ == other.__class__, other.__dict__ + else: + return False + +class AnObject(object): + + def __new__(cls, foo=None, bar=None, baz=None): + self = object.__new__(cls) + self.foo = foo + self.bar = bar + self.baz = baz + return self + + def __cmp__(self, other): + return cmp((type(self), self.foo, self.bar, self.baz), + (type(other), other.foo, other.bar, other.baz)) + + def __eq__(self, other): + return type(self) is type(other) and \ + (self.foo, self.bar, self.baz) == (other.foo, other.bar, other.baz) + +class AnInstance: + + def __init__(self, foo=None, bar=None, baz=None): + self.foo = foo + self.bar = bar + self.baz = baz + + def __cmp__(self, other): + return cmp((type(self), self.foo, self.bar, self.baz), + (type(other), other.foo, other.bar, other.baz)) + + def __eq__(self, other): + return type(self) is type(other) and \ + (self.foo, self.bar, self.baz) == (other.foo, other.bar, other.baz) + +class AState(AnInstance): + + def __getstate__(self): + return { + '_foo': self.foo, + '_bar': self.bar, + '_baz': self.baz, + } + + def __setstate__(self, state): + self.foo = state['_foo'] + self.bar = state['_bar'] + self.baz = state['_baz'] + +class ACustomState(AnInstance): + + def __getstate__(self): + return (self.foo, self.bar, self.baz) + + def __setstate__(self, state): + self.foo, self.bar, self.baz = state + +class InitArgs(AnInstance): + + def __getinitargs__(self): + return (self.foo, self.bar, self.baz) + + def __getstate__(self): + return {} + +class InitArgsWithState(AnInstance): + + def __getinitargs__(self): + return (self.foo, self.bar) + + def __getstate__(self): + return self.baz + + def __setstate__(self, state): + self.baz = state + +class NewArgs(AnObject): + + def __getnewargs__(self): + return (self.foo, self.bar, self.baz) + + def __getstate__(self): + return {} + +class NewArgsWithState(AnObject): + + def __getnewargs__(self): + return (self.foo, self.bar) + + def __getstate__(self): + return self.baz + + def __setstate__(self, state): + self.baz = state + +class Reduce(AnObject): + + def __reduce__(self): + return self.__class__, (self.foo, self.bar, self.baz) + +class ReduceWithState(AnObject): + + def __reduce__(self): + return self.__class__, (self.foo, self.bar), self.baz + + def __setstate__(self, state): + self.baz = state + +class MyInt(int): + + def __eq__(self, other): + return type(self) is type(other) and int(self) == int(other) + +class MyList(list): + + def __init__(self, n=1): + self.extend([None]*n) + + def __eq__(self, other): + return type(self) is type(other) and list(self) == list(other) + +class MyDict(dict): + + def __init__(self, n=1): + for k in range(n): + self[k] = None + + def __eq__(self, other): + return type(self) is type(other) and dict(self) == dict(other) + +class FixedOffset(datetime.tzinfo): + + def __init__(self, offset, name): + self.__offset = datetime.timedelta(minutes=offset) + self.__name = name + + def utcoffset(self, dt): + return self.__offset + + def tzname(self, dt): + return self.__name + + def dst(self, dt): + return datetime.timedelta(0) + + +def execute(code): + exec code + return value + +class TestConstructorTypes(test_appliance.TestAppliance): + + def _testTypes(self, test_name, data_filename, code_filename): + data1 = None + data2 = None + try: + data1 = list(load_all(file(data_filename, 'rb'), Loader=MyLoader)) + if len(data1) == 1: + data1 = data1[0] + data2 = eval(file(code_filename, 'rb').read()) + self.failUnlessEqual(type(data1), type(data2)) + try: + self.failUnlessEqual(data1, data2) + except (AssertionError, TypeError): + if isinstance(data1, dict): + data1 = [(repr(key), value) for key, value in data1.items()] + data1.sort() + data1 = repr(data1) + data2 = [(repr(key), value) for key, value in data2.items()] + data2.sort() + data2 = repr(data2) + if data1 != data2: + raise + elif isinstance(data1, list): + self.failUnlessEqual(type(data1), type(data2)) + self.failUnlessEqual(len(data1), len(data2)) + for item1, item2 in zip(data1, data2): + if (item1 != item1 or (item1 == 0.0 and item1 == 1.0)) and \ + (item2 != item2 or (item2 == 0.0 and item2 == 1.0)): + continue + if isinstance(item1, datetime.datetime): + item1 = item1.utctimetuple() + if isinstance(item2, datetime.datetime): + item2 = item2.utctimetuple() + self.failUnlessEqual(item1, item2) + else: + raise + except: + print + print "DATA:" + print file(data_filename, 'rb').read() + print "CODE:" + print file(code_filename, 'rb').read() + print "NATIVES1:", data1 + print "NATIVES2:", data2 + raise + +TestConstructorTypes.add_tests('testTypes', '.data', '.code') + Index: /pyyaml/tags/3.04/tests/test_canonical.py =================================================================== --- /pyyaml/tags/3.04/tests/test_canonical.py (revision 136) +++ /pyyaml/tags/3.04/tests/test_canonical.py (revision 136) @@ -0,0 +1,20 @@ + +import test_appliance + +class TestCanonicalAppliance(test_appliance.TestAppliance): + + def _testCanonicalScanner(self, test_name, canonical_filename): + data = file(canonical_filename, 'rb').read() + tokens = list(test_appliance.canonical_scan(data)) + #for token in tokens: + # print token + + def _testCanonicalParser(self, test_name, canonical_filename): + data = file(canonical_filename, 'rb').read() + event = list(test_appliance.canonical_parse(data)) + #for event in events: + # print event + +TestCanonicalAppliance.add_tests('testCanonicalScanner', '.canonical') +TestCanonicalAppliance.add_tests('testCanonicalParser', '.canonical') + Index: /pyyaml/tags/3.04/tests/test_mark.py =================================================================== --- /pyyaml/tags/3.04/tests/test_mark.py (revision 120) +++ /pyyaml/tags/3.04/tests/test_mark.py (revision 120) @@ -0,0 +1,34 @@ + +import test_appliance + +from yaml.reader import Mark + +class TestMark(test_appliance.TestAppliance): + + def _testMarks(self, test_name, marks_filename): + inputs = file(marks_filename, 'rb').read().split('---\n')[1:] + for input in inputs: + index = 0 + line = 0 + column = 0 + while input[index] != '*': + if input[index] == '\n': + line += 1 + column = 0 + else: + column += 1 + index += 1 + mark = Mark(test_name, index, line, column, unicode(input), index) + snippet = mark.get_snippet(indent=2, max_length=79) + #print "INPUT:" + #print input + #print "SNIPPET:" + #print snippet + self.failUnless(isinstance(snippet, str)) + self.failUnlessEqual(snippet.count('\n'), 1) + data, pointer = snippet.split('\n') + self.failUnless(len(data) < 82) + self.failUnlessEqual(data[len(pointer)-1], '*') + +TestMark.add_tests('testMarks', '.marks') + Index: /pyyaml/tags/3.04/tests/test_appliance.py =================================================================== --- /pyyaml/tags/3.04/tests/test_appliance.py (revision 150) +++ /pyyaml/tags/3.04/tests/test_appliance.py (revision 150) @@ -0,0 +1,355 @@ + +import unittest, os + +from yaml import * +from yaml.composer import * +from yaml.constructor import * +from yaml.resolver import * + +class TestAppliance(unittest.TestCase): + + DATA = 'tests/data' + + all_tests = {} + for filename in os.listdir(DATA): + if os.path.isfile(os.path.join(DATA, filename)): + root, ext = os.path.splitext(filename) + all_tests.setdefault(root, []).append(ext) + + def add_tests(cls, method_name, *extensions): + for test in cls.all_tests: + available_extensions = cls.all_tests[test] + for ext in extensions: + if ext not in available_extensions: + break + else: + filenames = [os.path.join(cls.DATA, test+ext) for ext in extensions] + def test_method(self, test=test, filenames=filenames): + getattr(self, '_'+method_name)(test, *filenames) + test = test.replace('-', '_').replace('.', '_') + try: + test_method.__name__ = '%s_%s' % (method_name, test) + except TypeError: + import new + test_method = new.function(test_method.func_code, test_method.func_globals, + '%s_%s' % (method_name, test), test_method.func_defaults, + test_method.func_closure) + setattr(cls, test_method.__name__, test_method) + add_tests = classmethod(add_tests) + +class Error(Exception): + pass + +class CanonicalScanner: + + def __init__(self, data): + self.data = unicode(data, 'utf-8')+u'\0' + self.index = 0 + self.scan() + + def check_token(self, *choices): + if self.tokens: + if not choices: + return True + for choice in choices: + if isinstance(self.tokens[0], choice): + return True + return False + + def peek_token(self): + if self.tokens: + return self.tokens[0] + + def get_token(self, choice=None): + token = self.tokens.pop(0) + if choice and not isinstance(token, choice): + raise Error("unexpected token "+repr(token)) + return token + + def get_token_value(self): + token = self.get_token() + return token.value + + def scan(self): + self.tokens = [] + self.tokens.append(StreamStartToken(None, None)) + while True: + self.find_token() + ch = self.data[self.index] + if ch == u'\0': + self.tokens.append(StreamEndToken(None, None)) + break + elif ch == u'%': + self.tokens.append(self.scan_directive()) + elif ch == u'-' and self.data[self.index:self.index+3] == u'---': + self.index += 3 + self.tokens.append(DocumentStartToken(None, None)) + elif ch == u'[': + self.index += 1 + self.tokens.append(FlowSequenceStartToken(None, None)) + elif ch == u'{': + self.index += 1 + self.tokens.append(FlowMappingStartToken(None, None)) + elif ch == u']': + self.index += 1 + self.tokens.append(FlowSequenceEndToken(None, None)) + elif ch == u'}': + self.index += 1 + self.tokens.append(FlowMappingEndToken(None, None)) + elif ch == u'?': + self.index += 1 + self.tokens.append(KeyToken(None, None)) + elif ch == u':': + self.index += 1 + self.tokens.append(ValueToken(None, None)) + elif ch == u',': + self.index += 1 + self.tokens.append(FlowEntryToken(None, None)) + elif ch == u'*' or ch == u'&': + self.tokens.append(self.scan_alias()) + elif ch == u'!': + self.tokens.append(self.scan_tag()) + elif ch == u'"': + self.tokens.append(self.scan_scalar()) + else: + raise Error("invalid token") + + DIRECTIVE = u'%YAML 1.1' + + def scan_directive(self): + if self.data[self.index:self.index+len(self.DIRECTIVE)] == self.DIRECTIVE and \ + self.data[self.index+len(self.DIRECTIVE)] in u' \n\0': + self.index += len(self.DIRECTIVE) + return DirectiveToken('YAML', (1, 1), None, None) + + def scan_alias(self): + if self.data[self.index] == u'*': + TokenClass = AliasToken + else: + TokenClass = AnchorToken + self.index += 1 + start = self.index + while self.data[self.index] not in u', \n\0': + self.index += 1 + value = self.data[start:self.index] + return TokenClass(value, None, None) + + def scan_tag(self): + self.index += 1 + start = self.index + while self.data[self.index] not in u' \n\0': + self.index += 1 + value = self.data[start:self.index] + if value[0] == u'!': + value = 'tag:yaml.org,2002:'+value[1:] + elif value[0] == u'<' and value[-1] == u'>': + value = value[1:-1] + else: + value = u'!'+value + return TagToken(value, None, None) + + QUOTE_CODES = { + 'x': 2, + 'u': 4, + 'U': 8, + } + + QUOTE_REPLACES = { + u'\\': u'\\', + u'\"': u'\"', + u' ': u' ', + u'a': u'\x07', + u'b': u'\x08', + u'e': u'\x1B', + u'f': u'\x0C', + u'n': u'\x0A', + u'r': u'\x0D', + u't': u'\x09', + u'v': u'\x0B', + u'N': u'\u0085', + u'L': u'\u2028', + u'P': u'\u2029', + u'_': u'_', + u'0': u'\x00', + + } + + def scan_scalar(self): + self.index += 1 + chunks = [] + start = self.index + ignore_spaces = False + while self.data[self.index] != u'"': + if self.data[self.index] == u'\\': + ignore_spaces = False + chunks.append(self.data[start:self.index]) + self.index += 1 + ch = self.data[self.index] + self.index += 1 + if ch == u'\n': + ignore_spaces = True + elif ch in self.QUOTE_CODES: + length = self.QUOTE_CODES[ch] + code = int(self.data[self.index:self.index+length], 16) + chunks.append(unichr(code)) + self.index += length + else: + chunks.append(self.QUOTE_REPLACES[ch]) + start = self.index + elif self.data[self.index] == u'\n': + chunks.append(self.data[start:self.index]) + chunks.append(u' ') + self.index += 1 + start = self.index + ignore_spaces = True + elif ignore_spaces and self.data[self.index] == u' ': + self.index += 1 + start = self.index + else: + ignore_spaces = False + self.index += 1 + chunks.append(self.data[start:self.index]) + self.index += 1 + return ScalarToken(u''.join(chunks), False, None, None) + + def find_token(self): + found = False + while not found: + while self.data[self.index] in u' \t': + self.index += 1 + if self.data[self.index] == u'#': + while self.data[self.index] != u'\n': + self.index += 1 + if self.data[self.index] == u'\n': + self.index += 1 + else: + found = True + +class CanonicalParser: + + def __init__(self): + self.events = [] + self.parse() + + # stream: STREAM-START document* STREAM-END + def parse_stream(self): + self.get_token(StreamStartToken) + self.events.append(StreamStartEvent(None, None)) + while not self.check_token(StreamEndToken): + if self.check_token(DirectiveToken, DocumentStartToken): + self.parse_document() + else: + raise Error("document is expected, got "+repr(self.tokens[self.index])) + self.get_token(StreamEndToken) + self.events.append(StreamEndEvent(None, None)) + + # document: DIRECTIVE? DOCUMENT-START node + def parse_document(self): + node = None + if self.check_token(DirectiveToken): + self.get_token(DirectiveToken) + self.get_token(DocumentStartToken) + self.events.append(DocumentStartEvent(None, None)) + self.parse_node() + self.events.append(DocumentEndEvent(None, None)) + + # node: ALIAS | ANCHOR? TAG? (SCALAR|sequence|mapping) + def parse_node(self): + if self.check_token(AliasToken): + self.events.append(AliasEvent(self.get_token_value(), None, None)) + else: + anchor = None + if self.check_token(AnchorToken): + anchor = self.get_token_value() + tag = None + if self.check_token(TagToken): + tag = self.get_token_value() + if self.check_token(ScalarToken): + self.events.append(ScalarEvent(anchor, tag, (False, False), self.get_token_value(), None, None)) + elif self.check_token(FlowSequenceStartToken): + self.events.append(SequenceStartEvent(anchor, tag, None, None)) + self.parse_sequence() + elif self.check_token(FlowMappingStartToken): + self.events.append(MappingStartEvent(anchor, tag, None, None)) + self.parse_mapping() + else: + raise Error("SCALAR, '[', or '{' is expected, got "+repr(self.tokens[self.index])) + + # sequence: SEQUENCE-START (node (ENTRY node)*)? ENTRY? SEQUENCE-END + def parse_sequence(self): + self.get_token(FlowSequenceStartToken) + if not self.check_token(FlowSequenceEndToken): + self.parse_node() + while not self.check_token(FlowSequenceEndToken): + self.get_token(FlowEntryToken) + if not self.check_token(FlowSequenceEndToken): + self.parse_node() + self.get_token(FlowSequenceEndToken) + self.events.append(SequenceEndEvent(None, None)) + + # mapping: MAPPING-START (map_entry (ENTRY map_entry)*)? ENTRY? MAPPING-END + def parse_mapping(self): + self.get_token(FlowMappingStartToken) + if not self.check_token(FlowMappingEndToken): + self.parse_map_entry() + while not self.check_token(FlowMappingEndToken): + self.get_token(FlowEntryToken) + if not self.check_token(FlowMappingEndToken): + self.parse_map_entry() + self.get_token(FlowMappingEndToken) + self.events.append(MappingEndEvent(None, None)) + + # map_entry: KEY node VALUE node + def parse_map_entry(self): + self.get_token(KeyToken) + self.parse_node() + self.get_token(ValueToken) + self.parse_node() + + def parse(self): + self.parse_stream() + + def get_event(self): + return self.events.pop(0) + + def check_event(self, *choices): + if self.events: + if not choices: + return True + for choice in choices: + if isinstance(self.events[0], choice): + return True + return False + + def peek_event(self): + return self.events[0] + +class CanonicalLoader(CanonicalScanner, CanonicalParser, Composer, Constructor, Resolver): + + def __init__(self, stream): + if hasattr(stream, 'read'): + stream = stream.read() + CanonicalScanner.__init__(self, stream) + CanonicalParser.__init__(self) + Composer.__init__(self) + Constructor.__init__(self) + Resolver.__init__(self) + +def canonical_scan(stream): + return scan(stream, Loader=CanonicalLoader) + +def canonical_parse(stream): + return parse(stream, Loader=CanonicalLoader) + +def canonical_compose(stream): + return compose(stream, Loader=CanonicalLoader) + +def canonical_compose_all(stream): + return compose_all(stream, Loader=CanonicalLoader) + +def canonical_load(stream): + return load(stream, Loader=CanonicalLoader) + +def canonical_load_all(stream): + return load_all(stream, Loader=CanonicalLoader) + Index: /pyyaml/tags/3.04/tests/test_representer.py =================================================================== --- /pyyaml/tags/3.04/tests/test_representer.py (revision 225) +++ /pyyaml/tags/3.04/tests/test_representer.py (revision 225) @@ -0,0 +1,56 @@ + +import test_appliance +from test_constructor import * + +from yaml import * + +class TestRepresenterTypes(test_appliance.TestAppliance): + + def _testTypesUnicode(self, test_name, data_filename, code_filename): + return self._testTypes(test_name, data_filename, code_filename, allow_unicode=True) + + def _testTypes(self, test_name, data_filename, code_filename, allow_unicode=False): + data1 = eval(file(code_filename, 'rb').read()) + data2 = None + output = None + try: + output = dump(data1, Dumper=MyDumper, allow_unicode=allow_unicode) + data2 = load(output, Loader=MyLoader) + self.failUnlessEqual(type(data1), type(data2)) + try: + self.failUnlessEqual(data1, data2) + except (AssertionError, TypeError): + if isinstance(data1, dict): + data1 = [(repr(key), value) for key, value in data1.items()] + data1.sort() + data1 = repr(data1) + data2 = [(repr(key), value) for key, value in data2.items()] + data2.sort() + data2 = repr(data2) + if data1 != data2: + raise + elif isinstance(data1, list): + self.failUnlessEqual(type(data1), type(data2)) + self.failUnlessEqual(len(data1), len(data2)) + for item1, item2 in zip(data1, data2): + if (item1 != item1 or (item1 == 0.0 and item1 == 1.0)) and \ + (item2 != item2 or (item2 == 0.0 and item2 == 1.0)): + continue + if isinstance(item1, datetime.datetime): + item1 = item1.utctimetuple() + if isinstance(item2, datetime.datetime): + item2 = item2.utctimetuple() + self.failUnlessEqual(item1, item2) + else: + raise + except: + print + print "OUTPUT:" + print output + print "NATIVES1:", data1 + print "NATIVES2:", data2 + raise + +TestRepresenterTypes.add_tests('testTypes', '.data', '.code') +TestRepresenterTypes.add_tests('testTypesUnicode', '.data', '.code') + Index: /pyyaml/tags/3.04/tests/test_build.py =================================================================== --- /pyyaml/tags/3.04/tests/test_build.py (revision 39) +++ /pyyaml/tags/3.04/tests/test_build.py (revision 39) @@ -0,0 +1,12 @@ + +def main(): + import sys, os, distutils.util + #build_lib = os.path.join('build', 'lib.%s-%s' % (distutils.util.get_platform(), sys.version[0:3])) + build_lib = 'build/lib' + sys.path.insert(0, build_lib) + import test_yaml + test_yaml.main('test_yaml') + +if __name__ == '__main__': + main() + Index: /pyyaml/tags/3.04/tests/test_structure.py =================================================================== --- /pyyaml/tags/3.04/tests/test_structure.py (revision 222) +++ /pyyaml/tags/3.04/tests/test_structure.py (revision 222) @@ -0,0 +1,228 @@ + +import test_appliance + +from yaml import * + +class TestStructure(test_appliance.TestAppliance): + + def _testStructure(self, test_name, data_filename, structure_filename): + node1 = None + node2 = eval(file(structure_filename, 'rb').read()) + try: + loader = Loader(file(data_filename, 'rb')) + node1 = [] + while not loader.check_event(StreamEndEvent): + if not loader.check_event(StreamStartEvent, DocumentStartEvent, DocumentEndEvent): + node1.append(self._convert(loader)) + else: + loader.get_event() + loader.get_event() + if len(node1) == 1: + node1 = node1[0] + self.failUnlessEqual(node1, node2) + except: + print + print "DATA:" + print file(data_filename, 'rb').read() + print "NODE1:", node1 + print "NODE2:", node2 + raise + + def _convert(self, loader): + if loader.check_event(ScalarEvent): + event = loader.get_event() + if event.tag or event.anchor or event.value: + return True + else: + return None + elif loader.check_event(SequenceStartEvent): + loader.get_event() + sequence = [] + while not loader.check_event(SequenceEndEvent): + sequence.append(self._convert(loader)) + loader.get_event() + return sequence + elif loader.check_event(MappingStartEvent): + loader.get_event() + mapping = [] + while not loader.check_event(MappingEndEvent): + key = self._convert(loader) + value = self._convert(loader) + mapping.append((key, value)) + loader.get_event() + return mapping + elif loader.check_event(AliasEvent): + loader.get_event() + return '*' + else: + loader.get_event() + return '?' + +TestStructure.add_tests('testStructure', '.data', '.structure') + +class TestParser(test_appliance.TestAppliance): + + def _testParser(self, test_name, data_filename, canonical_filename): + events1 = None + events2 = None + try: + events1 = list(parse(file(data_filename, 'rb'))) + events2 = list(test_appliance.canonical_parse(file(canonical_filename, 'rb'))) + self._compare(events1, events2) + except: + print + print "DATA1:" + print file(data_filename, 'rb').read() + print "DATA2:" + print file(canonical_filename, 'rb').read() + print "EVENTS1:", events1 + print "EVENTS2:", events2 + raise + + def _compare(self, events1, events2): + self.failUnlessEqual(len(events1), len(events2)) + for event1, event2 in zip(events1, events2): + self.failUnlessEqual(event1.__class__, event2.__class__) + if isinstance(event1, AliasEvent): + #self.failUnlessEqual(event1.name, event2.name) + pass + elif isinstance(event1, ScalarEvent): + #self.failUnlessEqual(event1.anchor, event2.anchor) + #self.failUnlessEqual(event1.tag, event2.tag) + self.failUnlessEqual(event1.value, event2.value) + if isinstance(event1, CollectionStartEvent): + #self.failUnlessEqual(event1.anchor, event2.anchor) + #self.failUnlessEqual(event1.tag, event2.tag) + pass + +TestParser.add_tests('testParser', '.data', '.canonical') + +class TestResolver(test_appliance.TestAppliance): + + def _testResolver(self, test_name, data_filename, canonical_filename): + nodes1 = None + nodes2 = None + try: + nodes1 = list(compose_all(file(data_filename, 'rb'))) + nodes2 = list(test_appliance.canonical_compose_all(file(canonical_filename, 'rb'))) + self.failUnlessEqual(len(nodes1), len(nodes2)) + for node1, node2 in zip(nodes1, nodes2): + self._compare(node1, node2) + except: + print + print "DATA1:" + print file(data_filename, 'rb').read() + print "DATA2:" + print file(canonical_filename, 'rb').read() + print "NODES1:", nodes1 + print "NODES2:", nodes2 + raise + + def _compare(self, node1, node2): + self.failUnlessEqual(node1.__class__, node2.__class__) + if isinstance(node1, ScalarNode): + #self.failUnlessEqual(node1.tag, node2.tag) + self.failUnlessEqual(node1.value, node2.value) + elif isinstance(node1, SequenceNode): + self.failUnlessEqual(len(node1.value), len(node2.value)) + for item1, item2 in zip(node1.value, node2.value): + self._compare(item1, item2) + elif isinstance(node1, MappingNode): + self.failUnlessEqual(len(node1.value), len(node2.value)) + items1 = node1.value.items() + items1.sort(lambda (k1,v1), (k2,v2): cmp((k1.tag,k1.value,v1.tag,v1.value), + (k2.tag,k2.value,v2.tag,v2.value))) + items2 = node2.value.items() + items2.sort(lambda (k1,v1), (k2,v2): cmp((k1.tag,k1.value,v1.tag,v1.value), + (k2.tag,k2.value,v2.tag,v2.value))) + for (key1, value1), (key2, value2) in zip(items1, items2): + self._compare(key1, key2) + self._compare(value1, value2) + +TestResolver.add_tests('testResolver', '.data', '.canonical') + +class MyLoader(Loader): + def construct_sequence(self, node): + return tuple(Loader.construct_sequence(self, node)) + + def construct_mapping(self, node): + pairs = self.construct_pairs(node) + pairs.sort() + return pairs + + def construct_undefined(self, node): + return self.construct_scalar(node) + +MyLoader.add_constructor(u'tag:yaml.org,2002:map', MyLoader.construct_mapping) +MyLoader.add_constructor(None, MyLoader.construct_undefined) + +class MyCanonicalLoader(test_appliance.CanonicalLoader): + + def construct_sequence(self, node): + return tuple(test_appliance.CanonicalLoader.construct_sequence(self, node)) + + def construct_mapping(self, node): + pairs = self.construct_pairs(node) + pairs.sort() + return pairs + + def construct_undefined(self, node): + return self.construct_scalar(node) + +MyCanonicalLoader.add_constructor(u'tag:yaml.org,2002:map', MyCanonicalLoader.construct_mapping) +MyCanonicalLoader.add_constructor(None, MyCanonicalLoader.construct_undefined) + +class TestConstructor(test_appliance.TestAppliance): + + def _testConstructor(self, test_name, data_filename, canonical_filename): + data1 = None + data2 = None + try: + data1 = list(load_all(file(data_filename, 'rb'), Loader=MyLoader)) + data2 = list(load_all(file(canonical_filename, 'rb'), Loader=MyCanonicalLoader)) + self.failUnlessEqual(data1, data2) + except: + print + print "DATA1:" + print file(data_filename, 'rb').read() + print "DATA2:" + print file(canonical_filename, 'rb').read() + print "NATIVES1:", data1 + print "NATIVES2:", data2 + raise + +TestConstructor.add_tests('testConstructor', '.data', '.canonical') + +class TestParserOnCanonical(test_appliance.TestAppliance): + + def _testParserOnCanonical(self, test_name, canonical_filename): + events1 = None + events2 = None + try: + events1 = list(parse(file(canonical_filename, 'rb'))) + events2 = list(test_appliance.canonical_parse(file(canonical_filename, 'rb'))) + self._compare(events1, events2) + except: + print + print "DATA:" + print file(canonical_filename, 'rb').read() + print "EVENTS1:", events1 + print "EVENTS2:", events2 + raise + + def _compare(self, events1, events2): + self.failUnlessEqual(len(events1), len(events2)) + for event1, event2 in zip(events1, events2): + self.failUnlessEqual(event1.__class__, event2.__class__) + if isinstance(event1, AliasEvent): + self.failUnlessEqual(event1.anchor, event2.anchor) + elif isinstance(event1, ScalarEvent): + self.failUnlessEqual(event1.anchor, event2.anchor) + self.failUnlessEqual(event1.tag, event2.tag) + self.failUnlessEqual(event1.value, event2.value) + if isinstance(event1, CollectionStartEvent): + self.failUnlessEqual(event1.anchor, event2.anchor) + self.failUnlessEqual(event1.tag, event2.tag) + +TestParserOnCanonical.add_tests('testParserOnCanonical', '.canonical') + Index: /pyyaml/tags/3.04/tests/test_resolver.py =================================================================== --- /pyyaml/tags/3.04/tests/test_resolver.py (revision 222) +++ /pyyaml/tags/3.04/tests/test_resolver.py (revision 222) @@ -0,0 +1,83 @@ + +import test_appliance + +from yaml import * + +class MyLoader(Loader): + pass + +class MyDumper(Dumper): + pass + +add_path_resolver(u'!root', [], + Loader=MyLoader, Dumper=MyDumper) + +add_path_resolver(u'!root/scalar', [], str, + Loader=MyLoader, Dumper=MyDumper) + +add_path_resolver(u'!root/key11/key12/*', ['key11', 'key12'], + Loader=MyLoader, Dumper=MyDumper) + +add_path_resolver(u'!root/key21/1/*', ['key21', 1], + Loader=MyLoader, Dumper=MyDumper) + +add_path_resolver(u'!root/key31/*/*/key14/map', ['key31', None, None, 'key14'], dict, + Loader=MyLoader, Dumper=MyDumper) + +class TestResolver(test_appliance.TestAppliance): + + def _testImplicitResolver(self, test_name, data_filename, detect_filename): + node = None + correct_tag = None + try: + correct_tag = file(detect_filename, 'rb').read().strip() + node = compose(file(data_filename, 'rb')) + self.failUnless(isinstance(node, SequenceNode)) + for scalar in node.value: + self.failUnless(isinstance(scalar, ScalarNode)) + self.failUnlessEqual(scalar.tag, correct_tag) + except: + print + print "DATA:" + print file(data_filename, 'rb').read() + print "CORRECT_TAG:" + print file(detect_filename, 'rb').read() + print "ROOT NODE:", node + print "SCALAR NODES:", node.value + raise + + def _testPathResolverLoader(self, test_name, data_filename, path_filename): + #print serialize_all(compose_all(file(data_filename, 'rb').read(), Loader=MyLoader)) + nodes1 = compose_all(file(data_filename, 'rb').read(), Loader=MyLoader) + nodes2 = compose_all(file(path_filename, 'rb').read()) + for node1, node2 in zip(nodes1, nodes2): + self.failUnlessEqual(self._convert(node1), self._convert(node2)) + + def _testPathResolverDumper(self, test_name, data_filename, path_filename): + for filename in [data_filename, path_filename]: + output = serialize_all(compose_all(file(filename, 'rb').read()), Dumper=MyDumper) + #print output + nodes1 = compose_all(output) + nodes2 = compose_all(file(data_filename, 'rb').read()) + for node1, node2 in zip(nodes1, nodes2): + self.failUnlessEqual(self._convert(node1), self._convert(node2)) + + def _convert(self, node): + if isinstance(node, ScalarNode): + return node.tag, node.value + elif isinstance(node, SequenceNode): + value = [] + for item in node.value: + value.append(self._convert(item)) + return node.tag, value + elif isinstance(node, MappingNode): + value = [] + for key, item in node.value: + value.append((self._convert(key), self._convert(item))) + value.sort() + return node.tag, value + +TestResolver.add_tests('testImplicitResolver', '.data', '.detect') +TestResolver.add_tests('testPathResolverLoader', '.data', '.path') +TestResolver.add_tests('testPathResolverDumper', '.data', '.path') + Index: /pyyaml/tags/3.04/tests/test_reader.py =================================================================== --- /pyyaml/tags/3.04/tests/test_reader.py (revision 46) +++ /pyyaml/tags/3.04/tests/test_reader.py (revision 46) @@ -0,0 +1,44 @@ + +import test_appliance +from yaml.reader import Reader, ReaderError + +import codecs + +class TestReaderErrors(test_appliance.TestAppliance): + + def _testReaderUnicodeErrors(self, test_name, stream_filename): + for encoding in ['utf-8', 'utf-16-le', 'utf-16-be']: + try: + data = unicode(file(stream_filename, 'rb').read(), encoding) + break + except: + pass + else: + return + #self._load(data) + self.failUnlessRaises(ReaderError, + lambda: self._load(data)) + #self._load(codecs.open(stream_filename, encoding=encoding)) + self.failUnlessRaises(ReaderError, + lambda: self._load(codecs.open(stream_filename, encoding=encoding))) + + def _testReaderStringErrors(self, test_name, stream_filename): + data = file(stream_filename, 'rb').read() + #self._load(data) + self.failUnlessRaises(ReaderError, lambda: self._load(data)) + + def _testReaderFileErrors(self, test_name, stream_filename): + data = file(stream_filename, 'rb') + #self._load(data) + self.failUnlessRaises(ReaderError, lambda: self._load(data)) + + def _load(self, data): + stream = Reader(data) + while stream.peek() != u'\0': + stream.forward() + +TestReaderErrors.add_tests('testReaderUnicodeErrors', '.stream-error') +TestReaderErrors.add_tests('testReaderStringErrors', '.stream-error') +TestReaderErrors.add_tests('testReaderFileErrors', '.stream-error') + + Index: /pyyaml/tags/3.04/tests/test_yaml.py =================================================================== --- /pyyaml/tags/3.04/tests/test_yaml.py (revision 142) +++ /pyyaml/tags/3.04/tests/test_yaml.py (revision 142) @@ -0,0 +1,22 @@ + +import unittest + +from test_mark import * +from test_reader import * +from test_canonical import * +from test_tokens import * +from test_structure import * +from test_errors import * +from test_resolver import * +from test_constructor import * +from test_emitter import * +from test_representer import * +from test_recursive import * +from test_syck import * + +def main(module='__main__'): + unittest.main(module) + +if __name__ == '__main__': + main() + Index: /pyyaml/tags/3.04/tests/test_tokens.py =================================================================== --- /pyyaml/tags/3.04/tests/test_tokens.py (revision 136) +++ /pyyaml/tags/3.04/tests/test_tokens.py (revision 136) @@ -0,0 +1,86 @@ + +import test_appliance + +from yaml import * + +class TestTokens(test_appliance.TestAppliance): + + # Tokens mnemonic: + # directive: % + # document_start: --- + # document_end: ... + # alias: * + # anchor: & + # tag: ! + # scalar _ + # block_sequence_start: [[ + # block_mapping_start: {{ + # block_end: ]} + # flow_sequence_start: [ + # flow_sequence_end: ] + # flow_mapping_start: { + # flow_mapping_end: } + # entry: , + # key: ? + # value: : + + replaces = { + DirectiveToken: '%', + DocumentStartToken: '---', + DocumentEndToken: '...', + AliasToken: '*', + AnchorToken: '&', + TagToken: '!', + ScalarToken: '_', + BlockSequenceStartToken: '[[', + BlockMappingStartToken: '{{', + BlockEndToken: ']}', + FlowSequenceStartToken: '[', + FlowSequenceEndToken: ']', + FlowMappingStartToken: '{', + FlowMappingEndToken: '}', + BlockEntryToken: ',', + FlowEntryToken: ',', + KeyToken: '?', + ValueToken: ':', + } + + def _testTokens(self, test_name, data_filename, tokens_filename): + tokens1 = None + tokens2 = file(tokens_filename, 'rb').read().split() + try: + tokens1 = [] + for token in scan(file(data_filename, 'rb')): + if not isinstance(token, (StreamStartToken, StreamEndToken)): + tokens1.append(token) + tokens1 = [self.replaces[t.__class__] for t in tokens1] + self.failUnlessEqual(tokens1, tokens2) + except: + print + print "DATA:" + print file(data_filename, 'rb').read() + print "TOKENS1:", tokens1 + print "TOKENS2:", tokens2 + raise + +TestTokens.add_tests('testTokens', '.data', '.tokens') + +class TestScanner(test_appliance.TestAppliance): + + def _testScanner(self, test_name, data_filename, canonical_filename): + for filename in [canonical_filename, data_filename]: + tokens = None + try: + tokens = [] + for token in scan(file(filename, 'rb')): + if not isinstance(token, (StreamStartToken, StreamEndToken)): + tokens.append(token.__class__.__name__) + except: + print + print "DATA:" + print file(data_filename, 'rb').read() + print "TOKENS:", tokens + raise + +TestScanner.add_tests('testScanner', '.data', '.canonical') + Index: /pyyaml/tags/3.04/tests/test_recursive.py =================================================================== --- /pyyaml/tags/3.04/tests/test_recursive.py (revision 222) +++ /pyyaml/tags/3.04/tests/test_recursive.py (revision 222) @@ -0,0 +1,52 @@ + +import test_appliance + +from yaml import * + +class AnInstance: + + def __init__(self, foo, bar): + self.foo = foo + self.bar = bar + + def __repr__(self): + try: + return "%s(foo=%r, bar=%r)" % (self.__class__.__name__, + self.foo, self.bar) + except RuntimeError: + return "%s(foo=..., bar=...)" % self.__class__.__name__ + +class AnInstanceWithState(AnInstance): + + def __getstate__(self): + return {'attributes': [self.foo, self.bar]} + + def __setstate__(self, state): + self.foo, self.bar = state['attributes'] + +class TestRecursive(test_appliance.TestAppliance): + + def _testRecursive(self, test_name, recursive_filename): + exec file(recursive_filename, 'r').read() + value1 = value + output1 = None + value2 = None + output2 = None + try: + output1 = dump(value1) + #print "OUTPUT %s:" % test_name + #print output1 + value2 = load(output1) + output2 = dump(value2) + self.failUnlessEqual(output1, output2) + except: + print "VALUE1:", value1 + print "VALUE2:", value2 + print "OUTPUT1:" + print output1 + print "OUTPUT2:" + print output2 + raise + +TestRecursive.add_tests('testRecursive', '.recursive') + Index: /pyyaml/tags/3.04/tests/test_emitter.py =================================================================== --- /pyyaml/tags/3.04/tests/test_emitter.py (revision 137) +++ /pyyaml/tags/3.04/tests/test_emitter.py (revision 137) @@ -0,0 +1,101 @@ + +import test_appliance, sys, StringIO + +from yaml import * +import yaml + +class TestEmitter(test_appliance.TestAppliance): + + def _testEmitterOnData(self, test_name, canonical_filename, data_filename): + self._testEmitter(test_name, data_filename) + + def _testEmitterOnCanonicalNormally(self, test_name, canonical_filename): + self._testEmitter(test_name, canonical_filename, False) + + def _testEmitterOnCanonicalCanonically(self, test_name, canonical_filename): + self._testEmitter(test_name, canonical_filename, True) + + def _testEmitter(self, test_name, filename, canonical=None): + events = list(parse(file(filename, 'rb'))) + #self._dump(filename, events, canonical) + stream = StringIO.StringIO() + emit(events, stream, canonical=canonical) + data = stream.getvalue() + new_events = list(parse(data)) + for event, new_event in zip(events, new_events): + self.failUnlessEqual(event.__class__, new_event.__class__) + if isinstance(event, NodeEvent): + self.failUnlessEqual(event.anchor, new_event.anchor) + if isinstance(event, CollectionStartEvent): + self.failUnlessEqual(event.tag, new_event.tag) + if isinstance(event, ScalarEvent): + #self.failUnlessEqual(event.implicit, new_event.implicit) + if True not in event.implicit+new_event.implicit: + self.failUnlessEqual(event.tag, new_event.tag) + self.failUnlessEqual(event.value, new_event.value) + + def _dump(self, filename, events, canonical): + print "="*30 + print "ORIGINAL DOCUMENT:" + print file(filename, 'rb').read() + print '-'*30 + print "EMITTED DOCUMENT:" + emit(events, sys.stdout, canonical=canonical) + +TestEmitter.add_tests('testEmitterOnData', '.canonical', '.data') +TestEmitter.add_tests('testEmitterOnCanonicalNormally', '.canonical') +TestEmitter.add_tests('testEmitterOnCanonicalCanonically', '.canonical') + +class EventsLoader(Loader): + + def construct_event(self, node): + if isinstance(node, ScalarNode): + mapping = {} + else: + mapping = self.construct_mapping(node) + class_name = str(node.tag[1:])+'Event' + if class_name in ['AliasEvent', 'ScalarEvent', 'SequenceStartEvent', 'MappingStartEvent']: + mapping.setdefault('anchor', None) + if class_name in ['ScalarEvent', 'SequenceStartEvent', 'MappingStartEvent']: + mapping.setdefault('tag', None) + if class_name in ['SequenceStartEvent', 'MappingStartEvent']: + mapping.setdefault('implicit', True) + if class_name == 'ScalarEvent': + mapping.setdefault('implicit', (False, True)) + mapping.setdefault('value', '') + value = getattr(yaml, class_name)(**mapping) + return value + +EventsLoader.add_constructor(None, EventsLoader.construct_event) + +class TestEmitterEvents(test_appliance.TestAppliance): + + def _testEmitterEvents(self, test_name, events_filename): + events = list(load(file(events_filename, 'rb'), Loader=EventsLoader)) + #self._dump(events_filename, events) + stream = StringIO.StringIO() + emit(events, stream) + data = stream.getvalue() + new_events = list(parse(data)) + self.failUnlessEqual(len(events), len(new_events)) + for event, new_event in zip(events, new_events): + self.failUnlessEqual(event.__class__, new_event.__class__) + if isinstance(event, NodeEvent): + self.failUnlessEqual(event.anchor, new_event.anchor) + if isinstance(event, CollectionStartEvent): + self.failUnlessEqual(event.tag, new_event.tag) + if isinstance(event, ScalarEvent): + self.failUnless(event.implicit == new_event.implicit + or event.tag == new_event.tag) + self.failUnlessEqual(event.value, new_event.value) + + def _dump(self, events_filename, events): + print "="*30 + print "EVENTS:" + print file(events_filename, 'rb').read() + print '-'*30 + print "OUTPUT:" + emit(events, sys.stdout) + +TestEmitterEvents.add_tests('testEmitterEvents', '.events') + Index: /pyyaml/tags/3.04/tests/test_syck.py =================================================================== --- /pyyaml/tags/3.04/tests/test_syck.py (revision 52) +++ /pyyaml/tags/3.04/tests/test_syck.py (revision 52) @@ -0,0 +1,30 @@ + +import test_appliance + +class TestSyck(test_appliance.TestAppliance): + + def _testSyckOnTokenTests(self, test_name, data_filename, tokens_filename): + try: + syck.parse(file(data_filename, 'rb')) + except: + print + print "DATA:" + print file(data_filename, 'rb').read() + raise + + def _testSyckOnCanonicalTests(self, test_name, data_filename, canonical_filename): + try: + syck.parse(file(data_filename, 'rb')) + except: + print + print "DATA:" + print file(data_filename, 'rb').read() + raise + +try: + import syck + #TestSyck.add_tests('testSyckOnTokenTests', '.data', '.tokens') + #TestSyck.add_tests('testSyckOnCanonicalTests', '.data', '.canonical') +except ImportError: + pass + Index: /pyyaml/tags/3.04/tests/test_errors.py =================================================================== --- /pyyaml/tags/3.04/tests/test_errors.py (revision 146) +++ /pyyaml/tags/3.04/tests/test_errors.py (revision 146) @@ -0,0 +1,73 @@ + +import test_appliance +import test_emitter + +import StringIO + +from yaml import * + +class TestErrors(test_appliance.TestAppliance): + + def _testLoaderErrors(self, test_name, invalid_filename): + #self._load(invalid_filename) + self.failUnlessRaises(YAMLError, lambda: self._load(invalid_filename)) + + def _testLoaderStringErrors(self, test_name, invalid_filename): + #self._load_string(invalid_filename) + self.failUnlessRaises(YAMLError, lambda: self._load_string(invalid_filename)) + + def _testEmitterErrors(self, test_name, invalid_filename): + events = list(load(file(invalid_filename, 'rb').read(), + Loader=test_emitter.EventsLoader)) + self.failUnlessRaises(YAMLError, lambda: self._emit(events)) + + def _testDumperErrors(self, test_name, invalid_filename): + code = file(invalid_filename, 'rb').read() + self.failUnlessRaises(YAMLError, lambda: self._dump(code)) + + def _dump(self, code): + try: + exec code + except YAMLError, exc: + #print '.'*70 + #print "%s:" % exc.__class__.__name__, exc + raise + + def _emit(self, events): + try: + emit(events) + except YAMLError, exc: + #print '.'*70 + #print "%s:" % exc.__class__.__name__, exc + raise + + def _load(self, filename): + try: + return list(load_all(file(filename, 'rb'))) + except YAMLError, exc: + #except ScannerError, exc: + #except ParserError, exc: + #except ComposerError, exc: + #except ConstructorError, exc: + #print '.'*70 + #print "%s:" % exc.__class__.__name__, exc + raise + + def _load_string(self, filename): + try: + return list(load_all(file(filename, 'rb').read())) + except YAMLError, exc: + #except ScannerError, exc: + #except ParserError, exc: + #except ComposerError, exc: + #except ConstructorError, exc: + #print '.'*70 + #print "%s:" % filename + #print "%s:" % exc.__class__.__name__, exc + raise + +TestErrors.add_tests('testLoaderErrors', '.loader-error') +TestErrors.add_tests('testLoaderStringErrors', '.loader-error') +TestErrors.add_tests('testEmitterErrors', '.emitter-error') +TestErrors.add_tests('testDumperErrors', '.dumper-error') + Index: /pyyaml/tags/3.04/lib/yaml/constructor.py =================================================================== --- /pyyaml/tags/3.04/lib/yaml/constructor.py (revision 225) +++ /pyyaml/tags/3.04/lib/yaml/constructor.py (revision 225) @@ -0,0 +1,679 @@ + +__all__ = ['BaseConstructor', 'SafeConstructor', 'Constructor', + 'ConstructorError'] + +from error import * +from nodes import * + +import datetime + +try: + set +except NameError: + from sets import Set as set + +import binascii, re, sys + +class ConstructorError(MarkedYAMLError): + pass + +class BaseConstructor(object): + + yaml_constructors = {} + yaml_multi_constructors = {} + + def __init__(self): + self.constructed_objects = {} + self.recursive_objects = {} + self.state_generators = [] + self.deep_construct = False + + def check_data(self): + # If there are more documents available? + return self.check_node() + + def get_data(self): + # Construct and return the next document. + if self.check_node(): + return self.construct_document(self.get_node()) + + def g(): yield None + generator_type = type(g()) + del g + + def construct_document(self, node): + data = self.construct_object(node) + while self.state_generators: + state_generators = self.state_generators + self.state_generators = [] + for generator in state_generators: + for dummy in generator: + pass + self.constructed_objects = {} + self.recursive_objects = {} + self.deep_construct = False + return data + + def construct_object(self, node, deep=False): + if deep: + old_deep = self.deep_construct + self.deep_construct = True + if node in self.constructed_objects: + return self.constructed_objects[node] + if node in self.recursive_objects: + raise ConstructorError(None, None, + "found unconstructable recursive node", node.start_mark) + self.recursive_objects[node] = None + constructor = None + state_constructor = None + tag_suffix = None + if node.tag in self.yaml_constructors: + constructor = self.yaml_constructors[node.tag] + else: + for tag_prefix in self.yaml_multi_constructors: + if node.tag.startswith(tag_prefix): + tag_suffix = node.tag[len(tag_prefix):] + constructor = self.yaml_multi_constructors[tag_prefix] + break + else: + if None in self.yaml_multi_constructors: + tag_suffix = node.tag + constructor = self.yaml_multi_constructors[None] + elif None in self.yaml_constructors: + constructor = self.yaml_constructors[None] + elif isinstance(node, ScalarNode): + constructor = self.__class__.construct_scalar + elif isinstance(node, SequenceNode): + constructor = self.__class__.construct_sequence + elif isinstance(node, MappingNode): + constructor = self.__class__.construct_mapping + if tag_suffix is None: + data = constructor(self, node) + else: + data = constructor(self, tag_suffix, node) + if isinstance(data, self.generator_type): + generator = data + data = generator.next() + if self.deep_construct: + for dummy in generator: + pass + else: + self.state_generators.append(generator) + self.constructed_objects[node] = data + del self.recursive_objects[node] + if deep: + self.deep_construct = old_deep + return data + + def construct_scalar(self, node): + if not isinstance(node, ScalarNode): + raise ConstructorError(None, None, + "expected a scalar node, but found %s" % node.id, + node.start_mark) + return node.value + + def construct_sequence(self, node, deep=False): + if not isinstance(node, SequenceNode): + raise ConstructorError(None, None, + "expected a sequence node, but found %s" % node.id, + node.start_mark) + return [self.construct_object(child, deep=deep) + for child in node.value] + + def construct_mapping(self, node, deep=False): + if not isinstance(node, MappingNode): + raise ConstructorError(None, None, + "expected a mapping node, but found %s" % node.id, + node.start_mark) + mapping = {} + for key_node, value_node in node.value: + key = self.construct_object(key_node, deep=deep) + try: + hash(key) + except TypeError, exc: + raise ConstructorError("while constructing a mapping", node.start_mark, + "found unacceptable key (%s)" % exc, key_node.start_mark) + value = self.construct_object(value_node, deep=deep) + mapping[key] = value + return mapping + + def construct_pairs(self, node, deep=False): + if not isinstance(node, MappingNode): + raise ConstructorError(None, None, + "expected a mapping node, but found %s" % node.id, + node.start_mark) + pairs = [] + for key_node, value_node in node.value: + key = self.construct_object(key_node, deep=deep) + value = self.construct_object(value_node, deep=deep) + pairs.append((key, value)) + return pairs + + def add_constructor(cls, tag, constructor): + if not 'yaml_constructors' in cls.__dict__: + cls.yaml_constructors = cls.yaml_constructors.copy() + cls.yaml_constructors[tag] = constructor + add_constructor = classmethod(add_constructor) + + def add_multi_constructor(cls, tag_prefix, multi_constructor): + if not 'yaml_multi_constructors' in cls.__dict__: + cls.yaml_multi_constructors = cls.yaml_multi_constructors.copy() + cls.yaml_multi_constructors[tag_prefix] = multi_constructor + add_multi_constructor = classmethod(add_multi_constructor) + +class SafeConstructor(BaseConstructor): + + def construct_scalar(self, node): + if isinstance(node, MappingNode): + for key_node, value_node in node.value: + if key_node.tag == u'tag:yaml.org,2002:value': + return self.construct_scalar(value_node) + return BaseConstructor.construct_scalar(self, node) + + def flatten_mapping(self, node): + merge = [] + index = 0 + while index < len(node.value): + key_node, value_node = node.value[index] + if key_node.tag == u'tag:yaml.org,2002:merge': + del node.value[index] + if isinstance(value_node, MappingNode): + self.flatten_mapping(value_node) + merge.extend(value_node.value) + elif isinstance(value_node, SequenceNode): + submerge = [] + for subnode in value_node.value: + if not isinstance(subnode, MappingNode): + raise ConstructorError("while constructing a mapping", + node.start_mark, + "expected a mapping for merging, but found %s" + % subnode.id, subnode.start_mark) + self.flatten_mapping(subnode) + submerge.append(subnode.value) + submerge.reverse() + for value in submerge: + merge.extend(value) + else: + raise ConstructorError("while constructing a mapping", node.start_mark, + "expected a mapping or list of mappings for merging, but found %s" + % value_node.id, value_node.start_mark) + elif key_node.tag == u'tag:yaml.org,2002:value': + key_node.tag = u'tag:yaml.org,2002:str' + index += 1 + else: + index += 1 + if merge: + node.value = merge + node.value + + def construct_mapping(self, node, deep=False): + if isinstance(node, MappingNode): + self.flatten_mapping(node) + return BaseConstructor.construct_mapping(self, node, deep=deep) + + def construct_yaml_null(self, node): + self.construct_scalar(node) + return None + + bool_values = { + u'yes': True, + u'no': False, + u'true': True, + u'false': False, + u'on': True, + u'off': False, + } + + def construct_yaml_bool(self, node): + value = self.construct_scalar(node) + return self.bool_values[value.lower()] + + def construct_yaml_int(self, node): + value = str(self.construct_scalar(node)) + value = value.replace('_', '') + sign = +1 + if value[0] == '-': + sign = -1 + if value[0] in '+-': + value = value[1:] + if value == '0': + return 0 + elif value.startswith('0b'): + return sign*int(value[2:], 2) + elif value.startswith('0x'): + return sign*int(value[2:], 16) + elif value[0] == '0': + return sign*int(value, 8) + elif ':' in value: + digits = [int(part) for part in value.split(':')] + digits.reverse() + base = 1 + value = 0 + for digit in digits: + value += digit*base + base *= 60 + return sign*value + else: + return sign*int(value) + + inf_value = 1e300 + while inf_value != inf_value*inf_value: + inf_value *= inf_value + nan_value = -inf_value/inf_value # Trying to make a quiet NaN (like C99). + + def construct_yaml_float(self, node): + value = str(self.construct_scalar(node)) + value = value.replace('_', '').lower() + sign = +1 + if value[0] == '-': + sign = -1 + if value[0] in '+-': + value = value[1:] + if value == '.inf': + return sign*self.inf_value + elif value == '.nan': + return self.nan_value + elif ':' in value: + digits = [float(part) for part in value.split(':')] + digits.reverse() + base = 1 + value = 0.0 + for digit in digits: + value += digit*base + base *= 60 + return sign*value + else: + return sign*float(value) + + def construct_yaml_binary(self, node): + value = self.construct_scalar(node) + try: + return str(value).decode('base64') + except (binascii.Error, UnicodeEncodeError), exc: + raise ConstructorError(None, None, + "failed to decode base64 data: %s" % exc, node.start_mark) + + timestamp_regexp = re.compile( + ur'''^(?P[0-9][0-9][0-9][0-9]) + -(?P[0-9][0-9]?) + -(?P[0-9][0-9]?) + (?:(?:[Tt]|[ \t]+) + (?P[0-9][0-9]?) + :(?P[0-9][0-9]) + :(?P[0-9][0-9]) + (?:(?P\.[0-9]*))? + (?:[ \t]*(?PZ|(?P[-+])(?P[0-9][0-9]?) + (?::(?P[0-9][0-9]))?))?)?$''', re.X) + + def construct_yaml_timestamp(self, node): + value = self.construct_scalar(node) + match = self.timestamp_regexp.match(node.value) + values = match.groupdict() + year = int(values['year']) + month = int(values['month']) + day = int(values['day']) + if not values['hour']: + return datetime.date(year, month, day) + hour = int(values['hour']) + minute = int(values['minute']) + second = int(values['second']) + fraction = 0 + if values['fraction']: + fraction = int(float(values['fraction'])*1000000) + delta = None + if values['tz_sign']: + tz_hour = int(values['tz_hour']) + tz_minute = int(values['tz_minute'] or 0) + delta = datetime.timedelta(hours=tz_hour, minutes=tz_minute) + if values['tz_sign'] == '-': + delta = -delta + data = datetime.datetime(year, month, day, hour, minute, second, fraction) + if delta: + data -= delta + return data + + def construct_yaml_omap(self, node): + # Note: we do not check for duplicate keys, because it's too + # CPU-expensive. + omap = [] + yield omap + if not isinstance(node, SequenceNode): + raise ConstructorError("while constructing an ordered map", node.start_mark, + "expected a sequence, but found %s" % node.id, node.start_mark) + for subnode in node.value: + if not isinstance(subnode, MappingNode): + raise ConstructorError("while constructing an ordered map", node.start_mark, + "expected a mapping of length 1, but found %s" % subnode.id, + subnode.start_mark) + if len(subnode.value) != 1: + raise ConstructorError("while constructing an ordered map", node.start_mark, + "expected a single mapping item, but found %d items" % len(subnode.value), + subnode.start_mark) + key_node, value_node = subnode.value[0] + key = self.construct_object(key_node) + value = self.construct_object(value_node) + omap.append((key, value)) + + def construct_yaml_pairs(self, node): + # Note: the same code as `construct_yaml_omap`. + pairs = [] + yield pairs + if not isinstance(node, SequenceNode): + raise ConstructorError("while constructing pairs", node.start_mark, + "expected a sequence, but found %s" % node.id, node.start_mark) + for subnode in node.value: + if not isinstance(subnode, MappingNode): + raise ConstructorError("while constructing pairs", node.start_mark, + "expected a mapping of length 1, but found %s" % subnode.id, + subnode.start_mark) + if len(subnode.value) != 1: + raise ConstructorError("while constructing pairs", node.start_mark, + "expected a single mapping item, but found %d items" % len(subnode.value), + subnode.start_mark) + key_node, value_node = subnode.value[0] + key = self.construct_object(key_node) + value = self.construct_object(value_node) + pairs.append((key, value)) + + def construct_yaml_set(self, node): + data = set() + yield data + value = self.construct_mapping(node) + data.update(value) + + def construct_yaml_str(self, node): + value = self.construct_scalar(node) + try: + return str(value) + except UnicodeEncodeError: + return value + + def construct_yaml_seq(self, node): + data = [] + yield data + data.extend(self.construct_sequence(node)) + + def construct_yaml_map(self, node): + data = {} + yield data + value = self.construct_mapping(node) + data.update(value) + + def construct_yaml_object(self, node, cls): + data = cls.__new__(cls) + yield data + if hasattr(data, '__setstate__'): + state = self.construct_mapping(node, deep=True) + data.__setstate__(state) + else: + state = self.construct_mapping(node) + data.__dict__.update(state) + + def construct_undefined(self, node): + raise ConstructorError(None, None, + "could not determine a constructor for the tag %r" % node.tag.encode('utf-8'), + node.start_mark) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:null', + SafeConstructor.construct_yaml_null) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:bool', + SafeConstructor.construct_yaml_bool) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:int', + SafeConstructor.construct_yaml_int) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:float', + SafeConstructor.construct_yaml_float) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:binary', + SafeConstructor.construct_yaml_binary) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:timestamp', + SafeConstructor.construct_yaml_timestamp) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:omap', + SafeConstructor.construct_yaml_omap) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:pairs', + SafeConstructor.construct_yaml_pairs) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:set', + SafeConstructor.construct_yaml_set) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:str', + SafeConstructor.construct_yaml_str) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:seq', + SafeConstructor.construct_yaml_seq) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:map', + SafeConstructor.construct_yaml_map) + +SafeConstructor.add_constructor(None, + SafeConstructor.construct_undefined) + +class Constructor(SafeConstructor): + + def construct_python_str(self, node): + return self.construct_scalar(node).encode('utf-8') + + def construct_python_unicode(self, node): + return self.construct_scalar(node) + + def construct_python_long(self, node): + return long(self.construct_yaml_int(node)) + + def construct_python_complex(self, node): + return complex(self.construct_scalar(node)) + + def construct_python_tuple(self, node): + return tuple(self.construct_sequence(node)) + + def find_python_module(self, name, mark): + if not name: + raise ConstructorError("while constructing a Python module", mark, + "expected non-empty name appended to the tag", mark) + try: + __import__(name) + except ImportError, exc: + raise ConstructorError("while constructing a Python module", mark, + "cannot find module %r (%s)" % (name.encode('utf-8'), exc), mark) + return sys.modules[name] + + def find_python_name(self, name, mark): + if not name: + raise ConstructorError("while constructing a Python object", mark, + "expected non-empty name appended to the tag", mark) + if u'.' in name: + # Python 2.4 only + #module_name, object_name = name.rsplit('.', 1) + items = name.split('.') + object_name = items.pop() + module_name = '.'.join(items) + else: + module_name = '__builtin__' + object_name = name + try: + __import__(module_name) + except ImportError, exc: + raise ConstructorError("while constructing a Python object", mark, + "cannot find module %r (%s)" % (module_name.encode('utf-8'), exc), mark) + module = sys.modules[module_name] + if not hasattr(module, object_name): + raise ConstructorError("while constructing a Python object", mark, + "cannot find %r in the module %r" % (object_name.encode('utf-8'), + module.__name__), mark) + return getattr(module, object_name) + + def construct_python_name(self, suffix, node): + value = self.construct_scalar(node) + if value: + raise ConstructorError("while constructing a Python name", node.start_mark, + "expected the empty value, but found %r" % value.encode('utf-8'), + node.start_mark) + return self.find_python_name(suffix, node.start_mark) + + def construct_python_module(self, suffix, node): + value = self.construct_scalar(node) + if value: + raise ConstructorError("while constructing a Python module", node.start_mark, + "expected the empty value, but found %r" % value.encode('utf-8'), + node.start_mark) + return self.find_python_module(suffix, node.start_mark) + + class classobj: pass + + def make_python_instance(self, suffix, node, + args=None, kwds=None, newobj=False): + if not args: + args = [] + if not kwds: + kwds = {} + cls = self.find_python_name(suffix, node.start_mark) + if newobj and isinstance(cls, type(self.classobj)) \ + and not args and not kwds: + instance = self.classobj() + instance.__class__ = cls + return instance + elif newobj and isinstance(cls, type): + return cls.__new__(cls, *args, **kwds) + else: + return cls(*args, **kwds) + + def set_python_instance_state(self, instance, state): + if hasattr(instance, '__setstate__'): + instance.__setstate__(state) + else: + slotstate = {} + if isinstance(state, tuple) and len(state) == 2: + state, slotstate = state + if hasattr(instance, '__dict__'): + instance.__dict__.update(state) + elif state: + slotstate.update(state) + for key, value in slotstate.items(): + setattr(object, key, value) + + def construct_python_object(self, suffix, node): + # Format: + # !!python/object:module.name { ... state ... } + instance = self.make_python_instance(suffix, node, newobj=True) + yield instance + deep = hasattr(instance, '__setstate__') + state = self.construct_mapping(node, deep=deep) + self.set_python_instance_state(instance, state) + + def construct_python_object_apply(self, suffix, node, newobj=False): + # Format: + # !!python/object/apply # (or !!python/object/new) + # args: [ ... arguments ... ] + # kwds: { ... keywords ... } + # state: ... state ... + # listitems: [ ... listitems ... ] + # dictitems: { ... dictitems ... } + # or short format: + # !!python/object/apply [ ... arguments ... ] + # The difference between !!python/object/apply and !!python/object/new + # is how an object is created, check make_python_instance for details. + if isinstance(node, SequenceNode): + args = self.construct_sequence(node, deep=True) + kwds = {} + state = {} + listitems = [] + dictitems = {} + else: + value = self.construct_mapping(node, deep=True) + args = value.get('args', []) + kwds = value.get('kwds', {}) + state = value.get('state', {}) + listitems = value.get('listitems', []) + dictitems = value.get('dictitems', {}) + instance = self.make_python_instance(suffix, node, args, kwds, newobj) + if state: + self.set_python_instance_state(instance, state) + if listitems: + instance.extend(listitems) + if dictitems: + for key in dictitems: + instance[key] = dictitems[key] + return instance + + def construct_python_object_new(self, suffix, node): + return self.construct_python_object_apply(suffix, node, newobj=True) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/none', + Constructor.construct_yaml_null) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/bool', + Constructor.construct_yaml_bool) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/str', + Constructor.construct_python_str) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/unicode', + Constructor.construct_python_unicode) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/int', + Constructor.construct_yaml_int) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/long', + Constructor.construct_python_long) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/float', + Constructor.construct_yaml_float) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/complex', + Constructor.construct_python_complex) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/list', + Constructor.construct_yaml_seq) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/tuple', + Constructor.construct_python_tuple) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/dict', + Constructor.construct_yaml_map) + +Constructor.add_multi_constructor( + u'tag:yaml.org,2002:python/name:', + Constructor.construct_python_name) + +Constructor.add_multi_constructor( + u'tag:yaml.org,2002:python/module:', + Constructor.construct_python_module) + +Constructor.add_multi_constructor( + u'tag:yaml.org,2002:python/object:', + Constructor.construct_python_object) + +Constructor.add_multi_constructor( + u'tag:yaml.org,2002:python/object/apply:', + Constructor.construct_python_object_apply) + +Constructor.add_multi_constructor( + u'tag:yaml.org,2002:python/object/new:', + Constructor.construct_python_object_new) + Index: /pyyaml/tags/3.04/lib/yaml/composer.py =================================================================== --- /pyyaml/tags/3.04/lib/yaml/composer.py (revision 223) +++ /pyyaml/tags/3.04/lib/yaml/composer.py (revision 223) @@ -0,0 +1,119 @@ + +__all__ = ['Composer', 'ComposerError'] + +from error import MarkedYAMLError +from events import * +from nodes import * + +class ComposerError(MarkedYAMLError): + pass + +class Composer(object): + + def __init__(self): + self.anchors = {} + + def check_node(self): + # If there are more documents available? + return not self.check_event(StreamEndEvent) + + def get_node(self): + # Get the root node of the next document. + if not self.check_event(StreamEndEvent): + return self.compose_document() + + def compose_document(self): + + # Drop the STREAM-START event. + if self.check_event(StreamStartEvent): + self.get_event() + + # Drop the DOCUMENT-START event. + self.get_event() + + # Compose the root node. + node = self.compose_node(None, None) + + # Drop the DOCUMENT-END event. + self.get_event() + + self.anchors = {} + return node + + def compose_node(self, parent, index): + if self.check_event(AliasEvent): + event = self.get_event() + anchor = event.anchor + if anchor not in self.anchors: + raise ComposerError(None, None, "found undefined alias %r" + % anchor.encode('utf-8'), event.start_mark) + return self.anchors[anchor] + event = self.peek_event() + anchor = event.anchor + if anchor is not None: + if anchor in self.anchors: + raise ComposerError("found duplicate anchor %r; first occurence" + % anchor.encode('utf-8'), self.anchors[anchor].start_mark, + "second occurence", event.start_mark) + self.descend_resolver(parent, index) + if self.check_event(ScalarEvent): + node = self.compose_scalar_node(anchor) + elif self.check_event(SequenceStartEvent): + node = self.compose_sequence_node(anchor) + elif self.check_event(MappingStartEvent): + node = self.compose_mapping_node(anchor) + self.ascend_resolver() + return node + + def compose_scalar_node(self, anchor): + event = self.get_event() + tag = event.tag + if tag is None or tag == u'!': + tag = self.resolve(ScalarNode, event.value, event.implicit) + node = ScalarNode(tag, event.value, + event.start_mark, event.end_mark, style=event.style) + if anchor is not None: + self.anchors[anchor] = node + return node + + def compose_sequence_node(self, anchor): + start_event = self.get_event() + tag = start_event.tag + if tag is None or tag == u'!': + tag = self.resolve(SequenceNode, None, start_event.implicit) + node = SequenceNode(tag, [], + start_event.start_mark, None, + flow_style=start_event.flow_style) + if anchor is not None: + self.anchors[anchor] = node + index = 0 + while not self.check_event(SequenceEndEvent): + node.value.append(self.compose_node(node, index)) + index += 1 + end_event = self.get_event() + node.end_mark = end_event.end_mark + return node + + def compose_mapping_node(self, anchor): + start_event = self.get_event() + tag = start_event.tag + if tag is None or tag == u'!': + tag = self.resolve(MappingNode, None, start_event.implicit) + node = MappingNode(tag, [], + start_event.start_mark, None, + flow_style=start_event.flow_style) + if anchor is not None: + self.anchors[anchor] = node + while not self.check_event(MappingEndEvent): + #key_event = self.peek_event() + item_key = self.compose_node(node, None) + #if item_key in node.value: + # raise ComposerError("while composing a mapping", start_event.start_mark, + # "found duplicate key", key_event.start_mark) + item_value = self.compose_node(node, item_key) + #node.value[item_key] = item_value + node.value.append((item_key, item_value)) + end_event = self.get_event() + node.end_mark = end_event.end_mark + return node + Index: /pyyaml/tags/3.04/lib/yaml/error.py =================================================================== --- /pyyaml/tags/3.04/lib/yaml/error.py (revision 222) +++ /pyyaml/tags/3.04/lib/yaml/error.py (revision 222) @@ -0,0 +1,75 @@ + +__all__ = ['Mark', 'YAMLError', 'MarkedYAMLError'] + +class Mark(object): + + def __init__(self, name, index, line, column, buffer, pointer): + self.name = name + self.index = index + self.line = line + self.column = column + self.buffer = buffer + self.pointer = pointer + + def get_snippet(self, indent=4, max_length=75): + if self.buffer is None: + return None + head = '' + start = self.pointer + while start > 0 and self.buffer[start-1] not in u'\0\r\n\x85\u2028\u2029': + start -= 1 + if self.pointer-start > max_length/2-1: + head = ' ... ' + start += 5 + break + tail = '' + end = self.pointer + while end < len(self.buffer) and self.buffer[end] not in u'\0\r\n\x85\u2028\u2029': + end += 1 + if end-self.pointer > max_length/2-1: + tail = ' ... ' + end -= 5 + break + snippet = self.buffer[start:end].encode('utf-8') + return ' '*indent + head + snippet + tail + '\n' \ + + ' '*(indent+self.pointer-start+len(head)) + '^' + + def __str__(self): + snippet = self.get_snippet() + where = " in \"%s\", line %d, column %d" \ + % (self.name, self.line+1, self.column+1) + if snippet is not None: + where += ":\n"+snippet + return where + +class YAMLError(Exception): + pass + +class MarkedYAMLError(YAMLError): + + def __init__(self, context=None, context_mark=None, + problem=None, problem_mark=None, note=None): + self.context = context + self.context_mark = context_mark + self.problem = problem + self.problem_mark = problem_mark + self.note = note + + def __str__(self): + lines = [] + if self.context is not None: + lines.append(self.context) + if self.context_mark is not None \ + and (self.problem is None or self.problem_mark is None + or self.context_mark.name != self.problem_mark.name + or self.context_mark.line != self.problem_mark.line + or self.context_mark.column != self.problem_mark.column): + lines.append(str(self.context_mark)) + if self.problem is not None: + lines.append(self.problem) + if self.problem_mark is not None: + lines.append(str(self.problem_mark)) + if self.note is not None: + lines.append(self.note) + return '\n'.join(lines) + Index: /pyyaml/tags/3.04/lib/yaml/scanner.py =================================================================== --- /pyyaml/tags/3.04/lib/yaml/scanner.py (revision 222) +++ /pyyaml/tags/3.04/lib/yaml/scanner.py (revision 222) @@ -0,0 +1,1456 @@ + +# Scanner produces tokens of the following types: +# STREAM-START +# STREAM-END +# DIRECTIVE(name, value) +# DOCUMENT-START +# DOCUMENT-END +# BLOCK-SEQUENCE-START +# BLOCK-MAPPING-START +# BLOCK-END +# FLOW-SEQUENCE-START +# FLOW-MAPPING-START +# FLOW-SEQUENCE-END +# FLOW-MAPPING-END +# BLOCK-ENTRY +# FLOW-ENTRY +# KEY +# VALUE +# ALIAS(value) +# ANCHOR(value) +# TAG(value) +# SCALAR(value, plain, style) +# +# Read comments in the Scanner code for more details. +# + +__all__ = ['Scanner', 'ScannerError'] + +from error import MarkedYAMLError +from tokens import * + +class ScannerError(MarkedYAMLError): + pass + +class SimpleKey(object): + # See below simple keys treatment. + + def __init__(self, token_number, required, index, line, column, mark): + self.token_number = token_number + self.required = required + self.index = index + self.line = line + self.column = column + self.mark = mark + +class Scanner(object): + + def __init__(self): + """Initialize the scanner.""" + # It is assumed that Scanner and Reader will have a common descendant. + # Reader do the dirty work of checking for BOM and converting the + # input data to Unicode. It also adds NUL to the end. + # + # Reader supports the following methods + # self.peek(i=0) # peek the next i-th character + # self.prefix(l=1) # peek the next l characters + # self.forward(l=1) # read the next l characters and move the pointer. + + # Had we reached the end of the stream? + self.done = False + + # The number of unclosed '{' and '['. `flow_level == 0` means block + # context. + self.flow_level = 0 + + # List of processed tokens that are not yet emitted. + self.tokens = [] + + # Add the STREAM-START token. + self.fetch_stream_start() + + # Number of tokens that were emitted through the `get_token` method. + self.tokens_taken = 0 + + # The current indentation level. + self.indent = -1 + + # Past indentation levels. + self.indents = [] + + # Variables related to simple keys treatment. + + # A simple key is a key that is not denoted by the '?' indicator. + # Example of simple keys: + # --- + # block simple key: value + # ? not a simple key: + # : { flow simple key: value } + # We emit the KEY token before all keys, so when we find a potential + # simple key, we try to locate the corresponding ':' indicator. + # Simple keys should be limited to a single line and 1024 characters. + + # Can a simple key start at the current position? A simple key may + # start: + # - at the beginning of the line, not counting indentation spaces + # (in block context), + # - after '{', '[', ',' (in the flow context), + # - after '?', ':', '-' (in the block context). + # In the block context, this flag also signifies if a block collection + # may start at the current position. + self.allow_simple_key = True + + # Keep track of possible simple keys. This is a dictionary. The key + # is `flow_level`; there can be no more that one possible simple key + # for each level. The value is a SimpleKey record: + # (token_number, required, index, line, column, mark) + # A simple key may start with ALIAS, ANCHOR, TAG, SCALAR(flow), + # '[', or '{' tokens. + self.possible_simple_keys = {} + + # Public methods. + + def check_token(self, *choices): + # Check if the next token is one of the given types. + while self.need_more_tokens(): + self.fetch_more_tokens() + if self.tokens: + if not choices: + return True + for choice in choices: + if isinstance(self.tokens[0], choice): + return True + return False + + def peek_token(self): + # Return the next token, but do not delete if from the queue. + while self.need_more_tokens(): + self.fetch_more_tokens() + if self.tokens: + return self.tokens[0] + + def get_token(self): + # Return the next token. + while self.need_more_tokens(): + self.fetch_more_tokens() + if self.tokens: + self.tokens_taken += 1 + return self.tokens.pop(0) + + # Private methods. + + def need_more_tokens(self): + if self.done: + return False + if not self.tokens: + return True + # The current token may be a potential simple key, so we + # need to look further. + self.stale_possible_simple_keys() + if self.next_possible_simple_key() == self.tokens_taken: + return True + + def fetch_more_tokens(self): + + # Eat whitespaces and comments until we reach the next token. + self.scan_to_next_token() + + # Remove obsolete possible simple keys. + self.stale_possible_simple_keys() + + # Compare the current indentation and column. It may add some tokens + # and decrease the current indentation level. + self.unwind_indent(self.column) + + # Peek the next character. + ch = self.peek() + + # Is it the end of stream? + if ch == u'\0': + return self.fetch_stream_end() + + # Is it a directive? + if ch == u'%' and self.check_directive(): + return self.fetch_directive() + + # Is it the document start? + if ch == u'-' and self.check_document_start(): + return self.fetch_document_start() + + # Is it the document end? + if ch == u'.' and self.check_document_end(): + return self.fetch_document_end() + + # TODO: support for BOM within a stream. + #if ch == u'\uFEFF': + # return self.fetch_bom() <-- issue BOMToken + + # Note: the order of the following checks is NOT significant. + + # Is it the flow sequence start indicator? + if ch == u'[': + return self.fetch_flow_sequence_start() + + # Is it the flow mapping start indicator? + if ch == u'{': + return self.fetch_flow_mapping_start() + + # Is it the flow sequence end indicator? + if ch == u']': + return self.fetch_flow_sequence_end() + + # Is it the flow mapping end indicator? + if ch == u'}': + return self.fetch_flow_mapping_end() + + # Is it the flow entry indicator? + if ch == u',': + return self.fetch_flow_entry() + + # Is it the block entry indicator? + if ch == u'-' and self.check_block_entry(): + return self.fetch_block_entry() + + # Is it the key indicator? + if ch == u'?' and self.check_key(): + return self.fetch_key() + + # Is it the value indicator? + if ch == u':' and self.check_value(): + return self.fetch_value() + + # Is it an alias? + if ch == u'*': + return self.fetch_alias() + + # Is it an anchor? + if ch == u'&': + return self.fetch_anchor() + + # Is it a tag? + if ch == u'!': + return self.fetch_tag() + + # Is it a literal scalar? + if ch == u'|' and not self.flow_level: + return self.fetch_literal() + + # Is it a folded scalar? + if ch == u'>' and not self.flow_level: + return self.fetch_folded() + + # Is it a single quoted scalar? + if ch == u'\'': + return self.fetch_single() + + # Is it a double quoted scalar? + if ch == u'\"': + return self.fetch_double() + + # It must be a plain scalar then. + if self.check_plain(): + return self.fetch_plain() + + # No? It's an error. Let's produce a nice error message. + raise ScannerError("while scanning for the next token", None, + "found character %r that cannot start any token" + % ch.encode('utf-8'), self.get_mark()) + + # Simple keys treatment. + + def next_possible_simple_key(self): + # Return the number of the nearest possible simple key. Actually we + # don't need to loop through the whole dictionary. We may replace it + # with the following code: + # if not self.possible_simple_keys: + # return None + # return self.possible_simple_keys[ + # min(self.possible_simple_keys.keys())].token_number + min_token_number = None + for level in self.possible_simple_keys: + key = self.possible_simple_keys[level] + if min_token_number is None or key.token_number < min_token_number: + min_token_number = key.token_number + return min_token_number + + def stale_possible_simple_keys(self): + # Remove entries that are no longer possible simple keys. According to + # the YAML specification, simple keys + # - should be limited to a single line, + # - should be no longer than 1024 characters. + # Disabling this procedure will allow simple keys of any length and + # height (may cause problems if indentation is broken though). + for level in self.possible_simple_keys.keys(): + key = self.possible_simple_keys[level] + if key.line != self.line \ + or self.index-key.index > 1024: + if key.required: + raise ScannerError("while scanning a simple key", key.mark, + "could not found expected ':'", self.get_mark()) + del self.possible_simple_keys[level] + + def save_possible_simple_key(self): + # The next token may start a simple key. We check if it's possible + # and save its position. This function is called for + # ALIAS, ANCHOR, TAG, SCALAR(flow), '[', and '{'. + + # Check if a simple key is required at the current position. + required = not self.flow_level and self.indent == self.column + + # A simple key is required only if it is the first token in the current + # line. Therefore it is always allowed. + assert self.allow_simple_key or not required + + # The next token might be a simple key. Let's save it's number and + # position. + if self.allow_simple_key: + self.remove_possible_simple_key() + token_number = self.tokens_taken+len(self.tokens) + key = SimpleKey(token_number, required, + self.index, self.line, self.column, self.get_mark()) + self.possible_simple_keys[self.flow_level] = key + + def remove_possible_simple_key(self): + # Remove the saved possible key position at the current flow level. + if self.flow_level in self.possible_simple_keys: + key = self.possible_simple_keys[self.flow_level] + + if key.required: + raise ScannerError("while scanning a simple key", key.mark, + "could not found expected ':'", self.get_mark()) + + del self.possible_simple_keys[self.flow_level] + + # Indentation functions. + + def unwind_indent(self, column): + + ## In flow context, tokens should respect indentation. + ## Actually the condition should be `self.indent >= column` according to + ## the spec. But this condition will prohibit intuitively correct + ## constructions such as + ## key : { + ## } + #if self.flow_level and self.indent > column: + # raise ScannerError(None, None, + # "invalid intendation or unclosed '[' or '{'", + # self.get_mark()) + + # In the flow context, indentation is ignored. We make the scanner less + # restrictive then specification requires. + if self.flow_level: + return + + # In block context, we may need to issue the BLOCK-END tokens. + while self.indent > column: + mark = self.get_mark() + self.indent = self.indents.pop() + self.tokens.append(BlockEndToken(mark, mark)) + + def add_indent(self, column): + # Check if we need to increase indentation. + if self.indent < column: + self.indents.append(self.indent) + self.indent = column + return True + return False + + # Fetchers. + + def fetch_stream_start(self): + # We always add STREAM-START as the first token and STREAM-END as the + # last token. + + # Read the token. + mark = self.get_mark() + + # Add STREAM-START. + self.tokens.append(StreamStartToken(mark, mark, + encoding=self.encoding)) + + + def fetch_stream_end(self): + + # Set the current intendation to -1. + self.unwind_indent(-1) + + # Reset everything (not really needed). + self.allow_simple_key = False + self.possible_simple_keys = {} + + # Read the token. + mark = self.get_mark() + + # Add STREAM-END. + self.tokens.append(StreamEndToken(mark, mark)) + + # The steam is finished. + self.done = True + + def fetch_directive(self): + + # Set the current intendation to -1. + self.unwind_indent(-1) + + # Reset simple keys. + self.remove_possible_simple_key() + self.allow_simple_key = False + + # Scan and add DIRECTIVE. + self.tokens.append(self.scan_directive()) + + def fetch_document_start(self): + self.fetch_document_indicator(DocumentStartToken) + + def fetch_document_end(self): + self.fetch_document_indicator(DocumentEndToken) + + def fetch_document_indicator(self, TokenClass): + + # Set the current intendation to -1. + self.unwind_indent(-1) + + # Reset simple keys. Note that there could not be a block collection + # after '---'. + self.remove_possible_simple_key() + self.allow_simple_key = False + + # Add DOCUMENT-START or DOCUMENT-END. + start_mark = self.get_mark() + self.forward(3) + end_mark = self.get_mark() + self.tokens.append(TokenClass(start_mark, end_mark)) + + def fetch_flow_sequence_start(self): + self.fetch_flow_collection_start(FlowSequenceStartToken) + + def fetch_flow_mapping_start(self): + self.fetch_flow_collection_start(FlowMappingStartToken) + + def fetch_flow_collection_start(self, TokenClass): + + # '[' and '{' may start a simple key. + self.save_possible_simple_key() + + # Increase the flow level. + self.flow_level += 1 + + # Simple keys are allowed after '[' and '{'. + self.allow_simple_key = True + + # Add FLOW-SEQUENCE-START or FLOW-MAPPING-START. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(TokenClass(start_mark, end_mark)) + + def fetch_flow_sequence_end(self): + self.fetch_flow_collection_end(FlowSequenceEndToken) + + def fetch_flow_mapping_end(self): + self.fetch_flow_collection_end(FlowMappingEndToken) + + def fetch_flow_collection_end(self, TokenClass): + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Decrease the flow level. + self.flow_level -= 1 + + # No simple keys after ']' or '}'. + self.allow_simple_key = False + + # Add FLOW-SEQUENCE-END or FLOW-MAPPING-END. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(TokenClass(start_mark, end_mark)) + + def fetch_flow_entry(self): + + # Simple keys are allowed after ','. + self.allow_simple_key = True + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Add FLOW-ENTRY. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(FlowEntryToken(start_mark, end_mark)) + + def fetch_block_entry(self): + + # Block context needs additional checks. + if not self.flow_level: + + # Are we allowed to start a new entry? + if not self.allow_simple_key: + raise ScannerError(None, None, + "sequence entries are not allowed here", + self.get_mark()) + + # We may need to add BLOCK-SEQUENCE-START. + if self.add_indent(self.column): + mark = self.get_mark() + self.tokens.append(BlockSequenceStartToken(mark, mark)) + + # It's an error for the block entry to occur in the flow context, + # but we let the parser detect this. + else: + pass + + # Simple keys are allowed after '-'. + self.allow_simple_key = True + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Add BLOCK-ENTRY. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(BlockEntryToken(start_mark, end_mark)) + + def fetch_key(self): + + # Block context needs additional checks. + if not self.flow_level: + + # Are we allowed to start a key (not nessesary a simple)? + if not self.allow_simple_key: + raise ScannerError(None, None, + "mapping keys are not allowed here", + self.get_mark()) + + # We may need to add BLOCK-MAPPING-START. + if self.add_indent(self.column): + mark = self.get_mark() + self.tokens.append(BlockMappingStartToken(mark, mark)) + + # Simple keys are allowed after '?' in the block context. + self.allow_simple_key = not self.flow_level + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Add KEY. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(KeyToken(start_mark, end_mark)) + + def fetch_value(self): + + # Do we determine a simple key? + if self.flow_level in self.possible_simple_keys: + + # Add KEY. + key = self.possible_simple_keys[self.flow_level] + del self.possible_simple_keys[self.flow_level] + self.tokens.insert(key.token_number-self.tokens_taken, + KeyToken(key.mark, key.mark)) + + # If this key starts a new block mapping, we need to add + # BLOCK-MAPPING-START. + if not self.flow_level: + if self.add_indent(key.column): + self.tokens.insert(key.token_number-self.tokens_taken, + BlockMappingStartToken(key.mark, key.mark)) + + # There cannot be two simple keys one after another. + self.allow_simple_key = False + + # It must be a part of a complex key. + else: + + # Block context needs additional checks. + # (Do we really need them? They will be catched by the parser + # anyway.) + if not self.flow_level: + + # We are allowed to start a complex value if and only if + # we can start a simple key. + if not self.allow_simple_key: + raise ScannerError(None, None, + "mapping values are not allowed here", + self.get_mark()) + + # If this value starts a new block mapping, we need to add + # BLOCK-MAPPING-START. It will be detected as an error later by + # the parser. + if not self.flow_level: + if self.add_indent(self.column): + mark = self.get_mark() + self.tokens.append(BlockMappingStartToken(mark, mark)) + + # Simple keys are allowed after ':' in the block context. + self.allow_simple_key = not self.flow_level + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Add VALUE. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(ValueToken(start_mark, end_mark)) + + def fetch_alias(self): + + # ALIAS could be a simple key. + self.save_possible_simple_key() + + # No simple keys after ALIAS. + self.allow_simple_key = False + + # Scan and add ALIAS. + self.tokens.append(self.scan_anchor(AliasToken)) + + def fetch_anchor(self): + + # ANCHOR could start a simple key. + self.save_possible_simple_key() + + # No simple keys after ANCHOR. + self.allow_simple_key = False + + # Scan and add ANCHOR. + self.tokens.append(self.scan_anchor(AnchorToken)) + + def fetch_tag(self): + + # TAG could start a simple key. + self.save_possible_simple_key() + + # No simple keys after TAG. + self.allow_simple_key = False + + # Scan and add TAG. + self.tokens.append(self.scan_tag()) + + def fetch_literal(self): + self.fetch_block_scalar(style='|') + + def fetch_folded(self): + self.fetch_block_scalar(style='>') + + def fetch_block_scalar(self, style): + + # A simple key may follow a block scalar. + self.allow_simple_key = True + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Scan and add SCALAR. + self.tokens.append(self.scan_block_scalar(style)) + + def fetch_single(self): + self.fetch_flow_scalar(style='\'') + + def fetch_double(self): + self.fetch_flow_scalar(style='"') + + def fetch_flow_scalar(self, style): + + # A flow scalar could be a simple key. + self.save_possible_simple_key() + + # No simple keys after flow scalars. + self.allow_simple_key = False + + # Scan and add SCALAR. + self.tokens.append(self.scan_flow_scalar(style)) + + def fetch_plain(self): + + # A plain scalar could be a simple key. + self.save_possible_simple_key() + + # No simple keys after plain scalars. But note that `scan_plain` will + # change this flag if the scan is finished at the beginning of the + # line. + self.allow_simple_key = False + + # Scan and add SCALAR. May change `allow_simple_key`. + self.tokens.append(self.scan_plain()) + + # Checkers. + + def check_directive(self): + + # DIRECTIVE: ^ '%' ... + # The '%' indicator is already checked. + if self.column == 0: + return True + + def check_document_start(self): + + # DOCUMENT-START: ^ '---' (' '|'\n') + if self.column == 0: + if self.prefix(3) == u'---' \ + and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': + return True + + def check_document_end(self): + + # DOCUMENT-END: ^ '...' (' '|'\n') + if self.column == 0: + if self.prefix(3) == u'...' \ + and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': + return True + + def check_block_entry(self): + + # BLOCK-ENTRY: '-' (' '|'\n') + return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' + + def check_key(self): + + # KEY(flow context): '?' + if self.flow_level: + return True + + # KEY(block context): '?' (' '|'\n') + else: + return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' + + def check_value(self): + + # VALUE(flow context): ':' + if self.flow_level: + return True + + # VALUE(block context): ':' (' '|'\n') + else: + return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' + + def check_plain(self): + + # A plain scalar may start with any non-space character except: + # '-', '?', ':', ',', '[', ']', '{', '}', + # '#', '&', '*', '!', '|', '>', '\'', '\"', + # '%', '@', '`'. + # + # It may also start with + # '-', '?', ':' + # if it is followed by a non-space character. + # + # Note that we limit the last rule to the block context (except the + # '-' character) because we want the flow context to be space + # independent. + ch = self.peek() + return ch not in u'\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'\"%@`' \ + or (self.peek(1) not in u'\0 \t\r\n\x85\u2028\u2029' + and (ch == u'-' or (not self.flow_level and ch in u'?:'))) + + # Scanners. + + def scan_to_next_token(self): + # We ignore spaces, line breaks and comments. + # If we find a line break in the block context, we set the flag + # `allow_simple_key` on. + # The byte order mark is stripped if it's the first character in the + # stream. We do not yet support BOM inside the stream as the + # specification requires. Any such mark will be considered as a part + # of the document. + # + # TODO: We need to make tab handling rules more sane. A good rule is + # Tabs cannot precede tokens + # BLOCK-SEQUENCE-START, BLOCK-MAPPING-START, BLOCK-END, + # KEY(block), VALUE(block), BLOCK-ENTRY + # So the checking code is + # if : + # self.allow_simple_keys = False + # We also need to add the check for `allow_simple_keys == True` to + # `unwind_indent` before issuing BLOCK-END. + # Scanners for block, flow, and plain scalars need to be modified. + + if self.index == 0 and self.peek() == u'\uFEFF': + self.forward() + found = False + while not found: + while self.peek() == u' ': + self.forward() + if self.peek() == u'#': + while self.peek() not in u'\0\r\n\x85\u2028\u2029': + self.forward() + if self.scan_line_break(): + if not self.flow_level: + self.allow_simple_key = True + else: + found = True + + def scan_directive(self): + # See the specification for details. + start_mark = self.get_mark() + self.forward() + name = self.scan_directive_name(start_mark) + value = None + if name == u'YAML': + value = self.scan_yaml_directive_value(start_mark) + end_mark = self.get_mark() + elif name == u'TAG': + value = self.scan_tag_directive_value(start_mark) + end_mark = self.get_mark() + else: + end_mark = self.get_mark() + while self.peek() not in u'\0\r\n\x85\u2028\u2029': + self.forward() + self.scan_directive_ignored_line(start_mark) + return DirectiveToken(name, value, start_mark, end_mark) + + def scan_directive_name(self, start_mark): + # See the specification for details. + length = 0 + ch = self.peek(length) + while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z' \ + or ch in u'-_': + length += 1 + ch = self.peek(length) + if not length: + raise ScannerError("while scanning a directive", start_mark, + "expected alphabetic or numeric character, but found %r" + % ch.encode('utf-8'), self.get_mark()) + value = self.prefix(length) + self.forward(length) + ch = self.peek() + if ch not in u'\0 \r\n\x85\u2028\u2029': + raise ScannerError("while scanning a directive", start_mark, + "expected alphabetic or numeric character, but found %r" + % ch.encode('utf-8'), self.get_mark()) + return value + + def scan_yaml_directive_value(self, start_mark): + # See the specification for details. + while self.peek() == u' ': + self.forward() + major = self.scan_yaml_directive_number(start_mark) + if self.peek() != '.': + raise ScannerError("while scanning a directive", start_mark, + "expected a digit or '.', but found %r" + % self.peek().encode('utf-8'), + self.get_mark()) + self.forward() + minor = self.scan_yaml_directive_number(start_mark) + if self.peek() not in u'\0 \r\n\x85\u2028\u2029': + raise ScannerError("while scanning a directive", start_mark, + "expected a digit or ' ', but found %r" + % self.peek().encode('utf-8'), + self.get_mark()) + return (major, minor) + + def scan_yaml_directive_number(self, start_mark): + # See the specification for details. + ch = self.peek() + if not (u'0' <= ch <= '9'): + raise ScannerError("while scanning a directive", start_mark, + "expected a digit, but found %r" % ch.encode('utf-8'), + self.get_mark()) + length = 0 + while u'0' <= self.peek(length) <= u'9': + length += 1 + value = int(self.prefix(length)) + self.forward(length) + return value + + def scan_tag_directive_value(self, start_mark): + # See the specification for details. + while self.peek() == u' ': + self.forward() + handle = self.scan_tag_directive_handle(start_mark) + while self.peek() == u' ': + self.forward() + prefix = self.scan_tag_directive_prefix(start_mark) + return (handle, prefix) + + def scan_tag_directive_handle(self, start_mark): + # See the specification for details. + value = self.scan_tag_handle('directive', start_mark) + ch = self.peek() + if ch != u' ': + raise ScannerError("while scanning a directive", start_mark, + "expected ' ', but found %r" % ch.encode('utf-8'), + self.get_mark()) + return value + + def scan_tag_directive_prefix(self, start_mark): + # See the specification for details. + value = self.scan_tag_uri('directive', start_mark) + ch = self.peek() + if ch not in u'\0 \r\n\x85\u2028\u2029': + raise ScannerError("while scanning a directive", start_mark, + "expected ' ', but found %r" % ch.encode('utf-8'), + self.get_mark()) + return value + + def scan_directive_ignored_line(self, start_mark): + # See the specification for details. + while self.peek() == u' ': + self.forward() + if self.peek() == u'#': + while self.peek() not in u'\0\r\n\x85\u2028\u2029': + self.forward() + ch = self.peek() + if ch not in u'\0\r\n\x85\u2028\u2029': + raise ScannerError("while scanning a directive", start_mark, + "expected a comment or a line break, but found %r" + % ch.encode('utf-8'), self.get_mark()) + self.scan_line_break() + + def scan_anchor(self, TokenClass): + # The specification does not restrict characters for anchors and + # aliases. This may lead to problems, for instance, the document: + # [ *alias, value ] + # can be interpteted in two ways, as + # [ "value" ] + # and + # [ *alias , "value" ] + # Therefore we restrict aliases to numbers and ASCII letters. + start_mark = self.get_mark() + indicator = self.peek() + if indicator == '*': + name = 'alias' + else: + name = 'anchor' + self.forward() + length = 0 + ch = self.peek(length) + while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z' \ + or ch in u'-_': + length += 1 + ch = self.peek(length) + if not length: + raise ScannerError("while scanning an %s" % name, start_mark, + "expected alphabetic or numeric character, but found %r" + % ch.encode('utf-8'), self.get_mark()) + value = self.prefix(length) + self.forward(length) + ch = self.peek() + if ch not in u'\0 \t\r\n\x85\u2028\u2029?:,]}%@`': + raise ScannerError("while scanning an %s" % name, start_mark, + "expected alphabetic or numeric character, but found %r" + % ch.encode('utf-8'), self.get_mark()) + end_mark = self.get_mark() + return TokenClass(value, start_mark, end_mark) + + def scan_tag(self): + # See the specification for details. + start_mark = self.get_mark() + ch = self.peek(1) + if ch == u'<': + handle = None + self.forward(2) + suffix = self.scan_tag_uri('tag', start_mark) + if self.peek() != u'>': + raise ScannerError("while parsing a tag", start_mark, + "expected '>', but found %r" % self.peek().encode('utf-8'), + self.get_mark()) + self.forward() + elif ch in u'\0 \t\r\n\x85\u2028\u2029': + handle = None + suffix = u'!' + self.forward() + else: + length = 1 + use_handle = False + while ch not in u'\0 \r\n\x85\u2028\u2029': + if ch == u'!': + use_handle = True + break + length += 1 + ch = self.peek(length) + handle = u'!' + if use_handle: + handle = self.scan_tag_handle('tag', start_mark) + else: + handle = u'!' + self.forward() + suffix = self.scan_tag_uri('tag', start_mark) + ch = self.peek() + if ch not in u'\0 \r\n\x85\u2028\u2029': + raise ScannerError("while scanning a tag", start_mark, + "expected ' ', but found %r" % ch.encode('utf-8'), + self.get_mark()) + value = (handle, suffix) + end_mark = self.get_mark() + return TagToken(value, start_mark, end_mark) + + def scan_block_scalar(self, style): + # See the specification for details. + + if style == '>': + folded = True + else: + folded = False + + chunks = [] + start_mark = self.get_mark() + + # Scan the header. + self.forward() + chomping, increment = self.scan_block_scalar_indicators(start_mark) + self.scan_block_scalar_ignored_line(start_mark) + + # Determine the indentation level and go to the first non-empty line. + min_indent = self.indent+1 + if min_indent < 1: + min_indent = 1 + if increment is None: + breaks, max_indent, end_mark = self.scan_block_scalar_indentation() + indent = max(min_indent, max_indent) + else: + indent = min_indent+increment-1 + breaks, end_mark = self.scan_block_scalar_breaks(indent) + line_break = u'' + + # Scan the inner part of the block scalar. + while self.column == indent and self.peek() != u'\0': + chunks.extend(breaks) + leading_non_space = self.peek() not in u' \t' + length = 0 + while self.peek(length) not in u'\0\r\n\x85\u2028\u2029': + length += 1 + chunks.append(self.prefix(length)) + self.forward(length) + line_break = self.scan_line_break() + breaks, end_mark = self.scan_block_scalar_breaks(indent) + if self.column == indent and self.peek() != u'\0': + + # Unfortunately, folding rules are ambiguous. + # + # This is the folding according to the specification: + + if folded and line_break == u'\n' \ + and leading_non_space and self.peek() not in u' \t': + if not breaks: + chunks.append(u' ') + else: + chunks.append(line_break) + + # This is Clark Evans's interpretation (also in the spec + # examples): + # + #if folded and line_break == u'\n': + # if not breaks: + # if self.peek() not in ' \t': + # chunks.append(u' ') + # else: + # chunks.append(line_break) + #else: + # chunks.append(line_break) + else: + break + + # Chomp the tail. + if chomping is not False: + chunks.append(line_break) + if chomping is True: + chunks.extend(breaks) + + # We are done. + return ScalarToken(u''.join(chunks), False, start_mark, end_mark, + style) + + def scan_block_scalar_indicators(self, start_mark): + # See the specification for details. + chomping = None + increment = None + ch = self.peek() + if ch in u'+-': + if ch == '+': + chomping = True + else: + chomping = False + self.forward() + ch = self.peek() + if ch in u'0123456789': + increment = int(ch) + if increment == 0: + raise ScannerError("while scanning a block scalar", start_mark, + "expected indentation indicator in the range 1-9, but found 0", + self.get_mark()) + self.forward() + elif ch in u'0123456789': + increment = int(ch) + if increment == 0: + raise ScannerError("while scanning a block scalar", start_mark, + "expected indentation indicator in the range 1-9, but found 0", + self.get_mark()) + self.forward() + ch = self.peek() + if ch in u'+-': + if ch == '+': + chomping = True + else: + chomping = False + self.forward() + ch = self.peek() + if ch not in u'\0 \r\n\x85\u2028\u2029': + raise ScannerError("while scanning a block scalar", start_mark, + "expected chomping or indentation indicators, but found %r" + % ch.encode('utf-8'), self.get_mark()) + return chomping, increment + + def scan_block_scalar_ignored_line(self, start_mark): + # See the specification for details. + while self.peek() == u' ': + self.forward() + if self.peek() == u'#': + while self.peek() not in u'\0\r\n\x85\u2028\u2029': + self.forward() + ch = self.peek() + if ch not in u'\0\r\n\x85\u2028\u2029': + raise ScannerError("while scanning a block scalar", start_mark, + "expected a comment or a line break, but found %r" + % ch.encode('utf-8'), self.get_mark()) + self.scan_line_break() + + def scan_block_scalar_indentation(self): + # See the specification for details. + chunks = [] + max_indent = 0 + end_mark = self.get_mark() + while self.peek() in u' \r\n\x85\u2028\u2029': + if self.peek() != u' ': + chunks.append(self.scan_line_break()) + end_mark = self.get_mark() + else: + self.forward() + if self.column > max_indent: + max_indent = self.column + return chunks, max_indent, end_mark + + def scan_block_scalar_breaks(self, indent): + # See the specification for details. + chunks = [] + end_mark = self.get_mark() + while self.column < indent and self.peek() == u' ': + self.forward() + while self.peek() in u'\r\n\x85\u2028\u2029': + chunks.append(self.scan_line_break()) + end_mark = self.get_mark() + while self.column < indent and self.peek() == u' ': + self.forward() + return chunks, end_mark + + def scan_flow_scalar(self, style): + # See the specification for details. + # Note that we loose indentation rules for quoted scalars. Quoted + # scalars don't need to adhere indentation because " and ' clearly + # mark the beginning and the end of them. Therefore we are less + # restrictive then the specification requires. We only need to check + # that document separators are not included in scalars. + if style == '"': + double = True + else: + double = False + chunks = [] + start_mark = self.get_mark() + quote = self.peek() + self.forward() + chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark)) + while self.peek() != quote: + chunks.extend(self.scan_flow_scalar_spaces(double, start_mark)) + chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark)) + self.forward() + end_mark = self.get_mark() + return ScalarToken(u''.join(chunks), False, start_mark, end_mark, + style) + + ESCAPE_REPLACEMENTS = { + u'0': u'\0', + u'a': u'\x07', + u'b': u'\x08', + u't': u'\x09', + u'\t': u'\x09', + u'n': u'\x0A', + u'v': u'\x0B', + u'f': u'\x0C', + u'r': u'\x0D', + u'e': u'\x1B', + u' ': u'\x20', + u'\"': u'\"', + u'\\': u'\\', + u'N': u'\x85', + u'_': u'\xA0', + u'L': u'\u2028', + u'P': u'\u2029', + } + + ESCAPE_CODES = { + u'x': 2, + u'u': 4, + u'U': 8, + } + + def scan_flow_scalar_non_spaces(self, double, start_mark): + # See the specification for details. + chunks = [] + while True: + length = 0 + while self.peek(length) not in u'\'\"\\\0 \t\r\n\x85\u2028\u2029': + length += 1 + if length: + chunks.append(self.prefix(length)) + self.forward(length) + ch = self.peek() + if not double and ch == u'\'' and self.peek(1) == u'\'': + chunks.append(u'\'') + self.forward(2) + elif (double and ch == u'\'') or (not double and ch in u'\"\\'): + chunks.append(ch) + self.forward() + elif double and ch == u'\\': + self.forward() + ch = self.peek() + if ch in self.ESCAPE_REPLACEMENTS: + chunks.append(self.ESCAPE_REPLACEMENTS[ch]) + self.forward() + elif ch in self.ESCAPE_CODES: + length = self.ESCAPE_CODES[ch] + self.forward() + for k in range(length): + if self.peek(k) not in u'0123456789ABCDEFabcdef': + raise ScannerError("while scanning a double-quoted scalar", start_mark, + "expected escape sequence of %d hexdecimal numbers, but found %r" % + (length, self.peek(k).encode('utf-8')), self.get_mark()) + code = int(self.prefix(length), 16) + chunks.append(unichr(code)) + self.forward(length) + elif ch in u'\r\n\x85\u2028\u2029': + self.scan_line_break() + chunks.extend(self.scan_flow_scalar_breaks(double, start_mark)) + else: + raise ScannerError("while scanning a double-quoted scalar", start_mark, + "found unknown escape character %r" % ch.encode('utf-8'), self.get_mark()) + else: + return chunks + + def scan_flow_scalar_spaces(self, double, start_mark): + # See the specification for details. + chunks = [] + length = 0 + while self.peek(length) in u' \t': + length += 1 + whitespaces = self.prefix(length) + self.forward(length) + ch = self.peek() + if ch == u'\0': + raise ScannerError("while scanning a quoted scalar", start_mark, + "found unexpected end of stream", self.get_mark()) + elif ch in u'\r\n\x85\u2028\u2029': + line_break = self.scan_line_break() + breaks = self.scan_flow_scalar_breaks(double, start_mark) + if line_break != u'\n': + chunks.append(line_break) + elif not breaks: + chunks.append(u' ') + chunks.extend(breaks) + else: + chunks.append(whitespaces) + return chunks + + def scan_flow_scalar_breaks(self, double, start_mark): + # See the specification for details. + chunks = [] + while True: + # Instead of checking indentation, we check for document + # separators. + prefix = self.prefix(3) + if (prefix == u'---' or prefix == u'...') \ + and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': + raise ScannerError("while scanning a quoted scalar", start_mark, + "found unexpected document separator", self.get_mark()) + while self.peek() in u' \t': + self.forward() + if self.peek() in u'\r\n\x85\u2028\u2029': + chunks.append(self.scan_line_break()) + else: + return chunks + + def scan_plain(self): + # See the specification for details. + # We add an additional restriction for the flow context: + # plain scalars in the flow context cannot contain ',', ':' and '?'. + # We also keep track of the `allow_simple_key` flag here. + # Indentation rules are loosed for the flow context. + chunks = [] + start_mark = self.get_mark() + end_mark = start_mark + indent = self.indent+1 + # We allow zero indentation for scalars, but then we need to check for + # document separators at the beginning of the line. + #if indent == 0: + # indent = 1 + spaces = [] + while True: + length = 0 + if self.peek() == u'#': + break + while True: + ch = self.peek(length) + if ch in u'\0 \t\r\n\x85\u2028\u2029' \ + or (not self.flow_level and ch == u':' and + self.peek(length+1) in u'\0 \t\r\n\x85\u2028\u2029') \ + or (self.flow_level and ch in u',:?[]{}'): + break + length += 1 + # It's not clear what we should do with ':' in the flow context. + if (self.flow_level and ch == u':' + and self.peek(length+1) not in u'\0 \t\r\n\x85\u2028\u2029,[]{}'): + self.forward(length) + raise ScannerError("while scanning a plain scalar", start_mark, + "found unexpected ':'", self.get_mark(), + "Please check http://pyyaml.org/wiki/YAMLColonInFlowContext for details.") + if length == 0: + break + self.allow_simple_key = False + chunks.extend(spaces) + chunks.append(self.prefix(length)) + self.forward(length) + end_mark = self.get_mark() + spaces = self.scan_plain_spaces(indent, start_mark) + if not spaces or self.peek() == u'#' \ + or (not self.flow_level and self.column < indent): + break + return ScalarToken(u''.join(chunks), True, start_mark, end_mark) + + def scan_plain_spaces(self, indent, start_mark): + # See the specification for details. + # The specification is really confusing about tabs in plain scalars. + # We just forbid them completely. Do not use tabs in YAML! + chunks = [] + length = 0 + while self.peek(length) in u' ': + length += 1 + whitespaces = self.prefix(length) + self.forward(length) + ch = self.peek() + if ch in u'\r\n\x85\u2028\u2029': + line_break = self.scan_line_break() + self.allow_simple_key = True + prefix = self.prefix(3) + if (prefix == u'---' or prefix == u'...') \ + and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': + return + breaks = [] + while self.peek() in u' \r\n\x85\u2028\u2029': + if self.peek() == ' ': + self.forward() + else: + breaks.append(self.scan_line_break()) + prefix = self.prefix(3) + if (prefix == u'---' or prefix == u'...') \ + and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': + return + if line_break != u'\n': + chunks.append(line_break) + elif not breaks: + chunks.append(u' ') + chunks.extend(breaks) + elif whitespaces: + chunks.append(whitespaces) + return chunks + + def scan_tag_handle(self, name, start_mark): + # See the specification for details. + # For some strange reasons, the specification does not allow '_' in + # tag handles. I have allowed it anyway. + ch = self.peek() + if ch != u'!': + raise ScannerError("while scanning a %s" % name, start_mark, + "expected '!', but found %r" % ch.encode('utf-8'), + self.get_mark()) + length = 1 + ch = self.peek(length) + if ch != u' ': + while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z' \ + or ch in u'-_': + length += 1 + ch = self.peek(length) + if ch != u'!': + self.forward(length) + raise ScannerError("while scanning a %s" % name, start_mark, + "expected '!', but found %r" % ch.encode('utf-8'), + self.get_mark()) + length += 1 + value = self.prefix(length) + self.forward(length) + return value + + def scan_tag_uri(self, name, start_mark): + # See the specification for details. + # Note: we do not check if URI is well-formed. + chunks = [] + length = 0 + ch = self.peek(length) + while u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z' \ + or ch in u'-;/?:@&=+$,_.!~*\'()[]%': + if ch == u'%': + chunks.append(self.prefix(length)) + self.forward(length) + length = 0 + chunks.append(self.scan_uri_escapes(name, start_mark)) + else: + length += 1 + ch = self.peek(length) + if length: + chunks.append(self.prefix(length)) + self.forward(length) + length = 0 + if not chunks: + raise ScannerError("while parsing a %s" % name, start_mark, + "expected URI, but found %r" % ch.encode('utf-8'), + self.get_mark()) + return u''.join(chunks) + + def scan_uri_escapes(self, name, start_mark): + # See the specification for details. + bytes = [] + mark = self.get_mark() + while self.peek() == u'%': + self.forward() + for k in range(2): + if self.peek(k) not in u'0123456789ABCDEFabcdef': + raise ScannerError("while scanning a %s" % name, start_mark, + "expected URI escape sequence of 2 hexdecimal numbers, but found %r" % + (self.peek(k).encode('utf-8')), self.get_mark()) + bytes.append(chr(int(self.prefix(2), 16))) + self.forward(2) + try: + value = unicode(''.join(bytes), 'utf-8') + except UnicodeDecodeError, exc: + raise ScannerError("while scanning a %s" % name, start_mark, str(exc), mark) + return value + + def scan_line_break(self): + # Transforms: + # '\r\n' : '\n' + # '\r' : '\n' + # '\n' : '\n' + # '\x85' : '\n' + # '\u2028' : '\u2028' + # '\u2029 : '\u2029' + # default : '' + ch = self.peek() + if ch in u'\r\n\x85': + if self.prefix(2) == u'\r\n': + self.forward(2) + else: + self.forward() + return u'\n' + elif ch in u'\u2028\u2029': + self.forward() + return ch + return u'' + +#try: +# import psyco +# psyco.bind(Scanner) +#except ImportError: +# pass + Index: /pyyaml/tags/3.04/lib/yaml/dumper.py =================================================================== --- /pyyaml/tags/3.04/lib/yaml/dumper.py (revision 152) +++ /pyyaml/tags/3.04/lib/yaml/dumper.py (revision 152) @@ -0,0 +1,62 @@ + +__all__ = ['BaseDumper', 'SafeDumper', 'Dumper'] + +from emitter import * +from serializer import * +from representer import * +from resolver import * + +class BaseDumper(Emitter, Serializer, BaseRepresenter, BaseResolver): + + def __init__(self, stream, + default_style=None, default_flow_style=None, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None): + Emitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, + allow_uncode=allow_unicode, line_break=line_break) + Serializer.__init__(self, encoding=encoding, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + Representer.__init__(self, default_style=default_style, + default_flow_style=default_flow_style) + Resolver.__init__(self) + +class SafeDumper(Emitter, Serializer, SafeRepresenter, Resolver): + + def __init__(self, stream, + default_style=None, default_flow_style=None, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None): + Emitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break) + Serializer.__init__(self, encoding=encoding, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + SafeRepresenter.__init__(self, default_style=default_style, + default_flow_style=default_flow_style) + Resolver.__init__(self) + +class Dumper(Emitter, Serializer, Representer, Resolver): + + def __init__(self, stream, + default_style=None, default_flow_style=None, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None): + Emitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break) + Serializer.__init__(self, encoding=encoding, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + Representer.__init__(self, default_style=default_style, + default_flow_style=default_flow_style) + Resolver.__init__(self) + Index: /pyyaml/tags/3.04/lib/yaml/parser.py =================================================================== --- /pyyaml/tags/3.04/lib/yaml/parser.py (revision 222) +++ /pyyaml/tags/3.04/lib/yaml/parser.py (revision 222) @@ -0,0 +1,582 @@ + +# The following YAML grammar is LL(1) and is parsed by a recursive descent +# parser. +# +# stream ::= STREAM-START implicit_document? explicit_document* STREAM-END +# implicit_document ::= block_node DOCUMENT-END* +# explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* +# block_node_or_indentless_sequence ::= +# ALIAS +# | properties (block_content | indentless_block_sequence)? +# | block_content +# | indentless_block_sequence +# block_node ::= ALIAS +# | properties block_content? +# | block_content +# flow_node ::= ALIAS +# | properties flow_content? +# | flow_content +# properties ::= TAG ANCHOR? | ANCHOR TAG? +# block_content ::= block_collection | flow_collection | SCALAR +# flow_content ::= flow_collection | SCALAR +# block_collection ::= block_sequence | block_mapping +# flow_collection ::= flow_sequence | flow_mapping +# block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END +# indentless_sequence ::= (BLOCK-ENTRY block_node?)+ +# block_mapping ::= BLOCK-MAPPING_START +# ((KEY block_node_or_indentless_sequence?)? +# (VALUE block_node_or_indentless_sequence?)?)* +# BLOCK-END +# flow_sequence ::= FLOW-SEQUENCE-START +# (flow_sequence_entry FLOW-ENTRY)* +# flow_sequence_entry? +# FLOW-SEQUENCE-END +# flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? +# flow_mapping ::= FLOW-MAPPING-START +# (flow_mapping_entry FLOW-ENTRY)* +# flow_mapping_entry? +# FLOW-MAPPING-END +# flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? +# +# FIRST sets: +# +# stream: { STREAM-START } +# explicit_document: { DIRECTIVE DOCUMENT-START } +# implicit_document: FIRST(block_node) +# block_node: { ALIAS TAG ANCHOR SCALAR BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START } +# flow_node: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START } +# block_content: { BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START SCALAR } +# flow_content: { FLOW-SEQUENCE-START FLOW-MAPPING-START SCALAR } +# block_collection: { BLOCK-SEQUENCE-START BLOCK-MAPPING-START } +# flow_collection: { FLOW-SEQUENCE-START FLOW-MAPPING-START } +# block_sequence: { BLOCK-SEQUENCE-START } +# block_mapping: { BLOCK-MAPPING-START } +# block_node_or_indentless_sequence: { ALIAS ANCHOR TAG SCALAR BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START BLOCK-ENTRY } +# indentless_sequence: { ENTRY } +# flow_collection: { FLOW-SEQUENCE-START FLOW-MAPPING-START } +# flow_sequence: { FLOW-SEQUENCE-START } +# flow_mapping: { FLOW-MAPPING-START } +# flow_sequence_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START KEY } +# flow_mapping_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START KEY } + +__all__ = ['Parser', 'ParserError'] + +from error import MarkedYAMLError +from tokens import * +from events import * +from scanner import * + +class ParserError(MarkedYAMLError): + pass + +class Parser(object): + # Since writing a recursive-descendant parser is a straightforward task, we + # do not give many comments here. + # Note that we use Python generators. If you rewrite the parser in another + # language, you may replace all 'yield'-s with event handler calls. + + DEFAULT_TAGS = { + u'!': u'!', + u'!!': u'tag:yaml.org,2002:', + } + + def __init__(self): + self.current_event = None + self.yaml_version = None + self.tag_handles = {} + self.states = [] + self.marks = [] + self.state = self.parse_stream_start + + def check_event(self, *choices): + # Check the type of the next event. + if self.current_event is None: + if self.state: + self.current_event = self.state() + if self.current_event is not None: + if not choices: + return True + for choice in choices: + if isinstance(self.current_event, choice): + return True + return False + + def peek_event(self): + # Get the next event. + if self.current_event is None: + if self.state: + self.current_event = self.state() + return self.current_event + + def get_event(self): + # Get the next event and proceed further. + if self.current_event is None: + if self.state: + self.current_event = self.state() + value = self.current_event + self.current_event = None + return value + + # stream ::= STREAM-START implicit_document? explicit_document* STREAM-END + # implicit_document ::= block_node DOCUMENT-END* + # explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* + + def parse_stream_start(self): + + # Parse the stream start. + token = self.get_token() + event = StreamStartEvent(token.start_mark, token.end_mark, + encoding=token.encoding) + + # Prepare the next state. + self.state = self.parse_implicit_document_start + + return event + + def parse_implicit_document_start(self): + + # Parse an implicit document. + if not self.check_token(DirectiveToken, DocumentStartToken, + StreamEndToken): + self.tag_handles = self.DEFAULT_TAGS + token = self.peek_token() + start_mark = end_mark = token.start_mark + event = DocumentStartEvent(start_mark, end_mark, + explicit=False) + + # Prepare the next state. + self.states.append(self.parse_document_end) + self.state = self.parse_block_node + + return event + + else: + return self.parse_document_start() + + def parse_document_start(self): + + # Parse an explicit document. + if not self.check_token(StreamEndToken): + token = self.peek_token() + start_mark = token.start_mark + version, tags = self.process_directives() + if not self.check_token(DocumentStartToken): + raise ParserError(None, None, + "expected '', but found %r" + % self.peek_token().id, + self.peek_token().start_mark) + token = self.get_token() + end_mark = token.end_mark + event = DocumentStartEvent(start_mark, end_mark, + explicit=True, version=version, tags=tags) + self.states.append(self.parse_document_end) + self.state = self.parse_document_content + else: + # Parse the end of the stream. + token = self.get_token() + event = StreamEndEvent(token.start_mark, token.end_mark) + assert not self.states + assert not self.marks + self.state = None + return event + + def parse_document_end(self): + + # Parse the document end. + token = self.peek_token() + start_mark = end_mark = token.start_mark + explicit = False + while self.check_token(DocumentEndToken): + token = self.get_token() + end_mark = token.end_mark + explicit = True + event = DocumentEndEvent(start_mark, end_mark, + explicit=explicit) + + # Prepare the next state. + self.state = self.parse_document_start + + return event + + def parse_document_content(self): + if self.check_token(DirectiveToken, + DocumentStartToken, DocumentEndToken, StreamEndToken): + event = self.process_empty_scalar(self.peek_token().start_mark) + self.state = self.states.pop() + return event + else: + return self.parse_block_node() + + def process_directives(self): + self.yaml_version = None + self.tag_handles = {} + while self.check_token(DirectiveToken): + token = self.get_token() + if token.name == u'YAML': + if self.yaml_version is not None: + raise ParserError(None, None, + "found duplicate YAML directive", token.start_mark) + major, minor = token.value + if major != 1: + raise ParserError(None, None, + "found incompatible YAML document (version 1.* is required)", + token.start_mark) + self.yaml_version = token.value + elif token.name == u'TAG': + handle, prefix = token.value + if handle in self.tag_handles: + raise ParserError(None, None, + "duplicate tag handle %r" % handle.encode('utf-8'), + token.start_mark) + self.tag_handles[handle] = prefix + if self.tag_handles: + value = self.yaml_version, self.tag_handles.copy() + else: + value = self.yaml_version, None + for key in self.DEFAULT_TAGS: + if key not in self.tag_handles: + self.tag_handles[key] = self.DEFAULT_TAGS[key] + return value + + # block_node_or_indentless_sequence ::= ALIAS + # | properties (block_content | indentless_block_sequence)? + # | block_content + # | indentless_block_sequence + # block_node ::= ALIAS + # | properties block_content? + # | block_content + # flow_node ::= ALIAS + # | properties flow_content? + # | flow_content + # properties ::= TAG ANCHOR? | ANCHOR TAG? + # block_content ::= block_collection | flow_collection | SCALAR + # flow_content ::= flow_collection | SCALAR + # block_collection ::= block_sequence | block_mapping + # flow_collection ::= flow_sequence | flow_mapping + + def parse_block_node(self): + return self.parse_node(block=True) + + def parse_flow_node(self): + return self.parse_node() + + def parse_block_node_or_indentless_sequence(self): + return self.parse_node(block=True, indentless_sequence=True) + + def parse_node(self, block=False, indentless_sequence=False): + if self.check_token(AliasToken): + token = self.get_token() + event = AliasEvent(token.value, token.start_mark, token.end_mark) + self.state = self.states.pop() + else: + anchor = None + tag = None + start_mark = end_mark = tag_mark = None + if self.check_token(AnchorToken): + token = self.get_token() + start_mark = token.start_mark + end_mark = token.end_mark + anchor = token.value + if self.check_token(TagToken): + token = self.get_token() + tag_mark = token.start_mark + end_mark = token.end_mark + tag = token.value + elif self.check_token(TagToken): + token = self.get_token() + start_mark = tag_mark = token.start_mark + end_mark = token.end_mark + tag = token.value + if self.check_token(AnchorToken): + token = self.get_token() + end_mark = token.end_mark + anchor = token.value + if tag is not None and tag != u'!': + handle, suffix = tag + if handle is not None: + if handle not in self.tag_handles: + raise ParserError("while parsing a node", start_mark, + "found undefined tag handle %r" % handle.encode('utf-8'), + tag_mark) + tag = self.tag_handles[handle]+suffix + else: + tag = suffix + #if tag == u'!': + # raise ParserError("while parsing a node", start_mark, + # "found non-specific tag '!'", tag_mark, + # "Please check 'http://pyyaml.org/wiki/YAMLNonSpecificTag' and share your opinion.") + if start_mark is None: + start_mark = end_mark = self.peek_token().start_mark + event = None + implicit = (tag is None or tag == u'!') + if indentless_sequence and self.check_token(BlockEntryToken): + end_mark = self.peek_token().end_mark + event = SequenceStartEvent(anchor, tag, implicit, + start_mark, end_mark) + self.state = self.parse_indentless_sequence_entry + else: + if self.check_token(ScalarToken): + token = self.get_token() + end_mark = token.end_mark + if (token.plain and tag is None) or tag == u'!': + implicit = (True, False) + elif tag is None: + implicit = (False, True) + else: + implicit = (False, False) + event = ScalarEvent(anchor, tag, implicit, token.value, + start_mark, end_mark, style=token.style) + self.state = self.states.pop() + elif self.check_token(FlowSequenceStartToken): + end_mark = self.peek_token().end_mark + event = SequenceStartEvent(anchor, tag, implicit, + start_mark, end_mark, flow_style=True) + self.state = self.parse_flow_sequence_first_entry + elif self.check_token(FlowMappingStartToken): + end_mark = self.peek_token().end_mark + event = MappingStartEvent(anchor, tag, implicit, + start_mark, end_mark, flow_style=True) + self.state = self.parse_flow_mapping_first_key + elif block and self.check_token(BlockSequenceStartToken): + end_mark = self.peek_token().start_mark + event = SequenceStartEvent(anchor, tag, implicit, + start_mark, end_mark, flow_style=False) + self.state = self.parse_block_sequence_first_entry + elif block and self.check_token(BlockMappingStartToken): + end_mark = self.peek_token().start_mark + event = MappingStartEvent(anchor, tag, implicit, + start_mark, end_mark, flow_style=False) + self.state = self.parse_block_mapping_first_key + elif anchor is not None or tag is not None: + # Empty scalars are allowed even if a tag or an anchor is + # specified. + event = ScalarEvent(anchor, tag, (implicit, False), u'', + start_mark, end_mark) + self.state = self.states.pop() + else: + if block: + node = 'block' + else: + node = 'flow' + token = self.peek_token() + raise ParserError("while parsing a %s node" % node, start_mark, + "expected the node content, but found %r" % token.id, + token.start_mark) + return event + + # block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END + + def parse_block_sequence_first_entry(self): + token = self.get_token() + self.marks.append(token.start_mark) + return self.parse_block_sequence_entry() + + def parse_block_sequence_entry(self): + if self.check_token(BlockEntryToken): + token = self.get_token() + if not self.check_token(BlockEntryToken, BlockEndToken): + self.states.append(self.parse_block_sequence_entry) + return self.parse_block_node() + else: + self.state = self.parse_block_sequence_entry + return self.process_empty_scalar(token.end_mark) + if not self.check_token(BlockEndToken): + token = self.peek_token() + raise ParserError("while parsing a block collection", self.marks[-1], + "expected , but found %r" % token.id, token.start_mark) + token = self.get_token() + event = SequenceEndEvent(token.start_mark, token.end_mark) + self.state = self.states.pop() + self.marks.pop() + return event + + # indentless_sequence ::= (BLOCK-ENTRY block_node?)+ + + def parse_indentless_sequence_entry(self): + if self.check_token(BlockEntryToken): + token = self.get_token() + if not self.check_token(BlockEntryToken, + KeyToken, ValueToken, BlockEndToken): + self.states.append(self.parse_indentless_sequence_entry) + return self.parse_block_node() + else: + self.state = self.parse_indentless_sequence_entry + return self.process_empty_scalar(token.end_mark) + token = self.peek_token() + event = SequenceEndEvent(token.start_mark, token.start_mark) + self.state = self.states.pop() + return event + + # block_mapping ::= BLOCK-MAPPING_START + # ((KEY block_node_or_indentless_sequence?)? + # (VALUE block_node_or_indentless_sequence?)?)* + # BLOCK-END + + def parse_block_mapping_first_key(self): + token = self.get_token() + self.marks.append(token.start_mark) + return self.parse_block_mapping_key() + + def parse_block_mapping_key(self): + if self.check_token(KeyToken): + token = self.get_token() + if not self.check_token(KeyToken, ValueToken, BlockEndToken): + self.states.append(self.parse_block_mapping_value) + return self.parse_block_node_or_indentless_sequence() + else: + self.state = self.parse_block_mapping_value + return self.process_empty_scalar(token.end_mark) + if not self.check_token(BlockEndToken): + token = self.peek_token() + raise ParserError("while parsing a block mapping", self.marks[-1], + "expected , but found %r" % token.id, token.start_mark) + token = self.get_token() + event = MappingEndEvent(token.start_mark, token.end_mark) + self.state = self.states.pop() + self.marks.pop() + return event + + def parse_block_mapping_value(self): + if self.check_token(ValueToken): + token = self.get_token() + if not self.check_token(KeyToken, ValueToken, BlockEndToken): + self.states.append(self.parse_block_mapping_key) + return self.parse_block_node_or_indentless_sequence() + else: + self.state = self.parse_block_mapping_key + return self.process_empty_scalar(token.end_mark) + else: + self.state = self.parse_block_mapping_key + token = self.peek_token() + return self.process_empty_scalar(token.start_mark) + + # flow_sequence ::= FLOW-SEQUENCE-START + # (flow_sequence_entry FLOW-ENTRY)* + # flow_sequence_entry? + # FLOW-SEQUENCE-END + # flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? + # + # Note that while production rules for both flow_sequence_entry and + # flow_mapping_entry are equal, their interpretations are different. + # For `flow_sequence_entry`, the part `KEY flow_node? (VALUE flow_node?)?` + # generate an inline mapping (set syntax). + + def parse_flow_sequence_first_entry(self): + token = self.get_token() + self.marks.append(token.start_mark) + return self.parse_flow_sequence_entry(first=True) + + def parse_flow_sequence_entry(self, first=False): + if not self.check_token(FlowSequenceEndToken): + if not first: + if self.check_token(FlowEntryToken): + self.get_token() + else: + token = self.peek_token() + raise ParserError("while parsing a flow sequence", self.marks[-1], + "expected ',' or ']', but got %r" % token.id, token.start_mark) + + if self.check_token(KeyToken): + token = self.peek_token() + event = MappingStartEvent(None, None, True, + token.start_mark, token.end_mark, + flow_style=True) + self.state = self.parse_flow_sequence_entry_mapping_key + return event + elif not self.check_token(FlowSequenceEndToken): + self.states.append(self.parse_flow_sequence_entry) + return self.parse_flow_node() + token = self.get_token() + event = SequenceEndEvent(token.start_mark, token.end_mark) + self.state = self.states.pop() + self.marks.pop() + return event + + def parse_flow_sequence_entry_mapping_key(self): + token = self.get_token() + if not self.check_token(ValueToken, + FlowEntryToken, FlowSequenceEndToken): + self.states.append(self.parse_flow_sequence_entry_mapping_value) + return self.parse_flow_node() + else: + self.state = self.parse_flow_sequence_entry_mapping_value + return self.process_empty_scalar(token.end_mark) + + def parse_flow_sequence_entry_mapping_value(self): + if self.check_token(ValueToken): + token = self.get_token() + if not self.check_token(FlowEntryToken, FlowSequenceEndToken): + self.states.append(self.parse_flow_sequence_entry_mapping_end) + return self.parse_flow_node() + else: + self.state = self.parse_flow_sequence_entry_mapping_end + return self.process_empty_scalar(token.end_mark) + else: + self.state = self.parse_flow_sequence_entry_mapping_end + token = self.peek_token() + return self.process_empty_scalar(token.start_mark) + + def parse_flow_sequence_entry_mapping_end(self): + self.state = self.parse_flow_sequence_entry + token = self.peek_token() + return MappingEndEvent(token.start_mark, token.start_mark) + + # flow_mapping ::= FLOW-MAPPING-START + # (flow_mapping_entry FLOW-ENTRY)* + # flow_mapping_entry? + # FLOW-MAPPING-END + # flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? + + def parse_flow_mapping_first_key(self): + token = self.get_token() + self.marks.append(token.start_mark) + return self.parse_flow_mapping_key(first=True) + + def parse_flow_mapping_key(self, first=False): + if not self.check_token(FlowMappingEndToken): + if not first: + if self.check_token(FlowEntryToken): + self.get_token() + else: + token = self.peek_token() + raise ParserError("while parsing a flow mapping", self.marks[-1], + "expected ',' or '}', but got %r" % token.id, token.start_mark) + if self.check_token(KeyToken): + token = self.get_token() + if not self.check_token(ValueToken, + FlowEntryToken, FlowMappingEndToken): + self.states.append(self.parse_flow_mapping_value) + return self.parse_flow_node() + else: + self.state = self.parse_flow_mapping_value + return self.process_empty_scalar(token.end_mark) + elif not self.check_token(FlowMappingEndToken): + self.states.append(self.parse_flow_mapping_empty_value) + return self.parse_flow_node() + token = self.get_token() + event = MappingEndEvent(token.start_mark, token.end_mark) + self.state = self.states.pop() + self.marks.pop() + return event + + def parse_flow_mapping_value(self): + if self.check_token(ValueToken): + token = self.get_token() + if not self.check_token(FlowEntryToken, FlowMappingEndToken): + self.states.append(self.parse_flow_mapping_key) + return self.parse_flow_node() + else: + self.state = self.parse_flow_mapping_key + return self.process_empty_scalar(token.end_mark) + else: + self.state = self.parse_flow_mapping_key + token = self.peek_token() + return self.process_empty_scalar(token.start_mark) + + def parse_flow_mapping_empty_value(self): + self.state = self.parse_flow_mapping_key + return self.process_empty_scalar(self.peek_token().start_mark) + + def process_empty_scalar(self, mark): + return ScalarEvent(None, None, (True, False), u'', mark, mark) + Index: /pyyaml/tags/3.04/lib/yaml/representer.py =================================================================== --- /pyyaml/tags/3.04/lib/yaml/representer.py (revision 225) +++ /pyyaml/tags/3.04/lib/yaml/representer.py (revision 225) @@ -0,0 +1,491 @@ + +__all__ = ['BaseRepresenter', 'SafeRepresenter', 'Representer', + 'RepresenterError'] + +from error import * +from nodes import * + +import datetime + +try: + set +except NameError: + from sets import Set as set + +import sys, copy_reg + +class RepresenterError(YAMLError): + pass + +class BaseRepresenter(object): + + yaml_representers = {} + yaml_multi_representers = {} + + def __init__(self, default_style=None, default_flow_style=None): + self.default_style = default_style + self.default_flow_style = default_flow_style + self.represented_objects = {} + self.object_keeper = [] + self.alias_key = None + + def represent(self, data): + node = self.represent_data(data) + self.serialize(node) + self.represented_objects = {} + self.object_keeper = [] + self.alias_key = None + + class C: pass + c = C() + def f(): pass + def g(): yield None + classobj_type = type(C) + instance_type = type(c) + function_type = type(f) + generator_type = type(g()) + builtin_function_type = type(abs) + module_type = type(sys) + del C, c, f, g + + def get_classobj_bases(self, cls): + bases = [cls] + for base in cls.__bases__: + bases.extend(self.get_classobj_bases(base)) + return bases + + def represent_data(self, data): + if self.ignore_aliases(data): + self.alias_key = None + else: + self.alias_key = id(data) + if self.alias_key is not None: + if self.alias_key in self.represented_objects: + node = self.represented_objects[self.alias_key] + #if node is None: + # raise RepresenterError("recursive objects are not allowed: %r" % data) + return node + #self.represented_objects[alias_key] = None + self.object_keeper.append(data) + data_types = type(data).__mro__ + if type(data) is self.instance_type: + data_types = self.get_classobj_bases(data.__class__)+list(data_types) + if data_types[0] in self.yaml_representers: + node = self.yaml_representers[data_types[0]](self, data) + else: + for data_type in data_types: + if data_type in self.yaml_multi_representers: + node = self.yaml_multi_representers[data_type](self, data) + break + else: + if None in self.yaml_multi_representers: + node = self.yaml_multi_representers[None](self, data) + elif None in self.yaml_representers: + node = self.yaml_representers[None](self, data) + else: + node = ScalarNode(None, unicode(data)) + #if alias_key is not None: + # self.represented_objects[alias_key] = node + return node + + def add_representer(cls, data_type, representer): + if not 'yaml_representers' in cls.__dict__: + cls.yaml_representers = cls.yaml_representers.copy() + cls.yaml_representers[data_type] = representer + add_representer = classmethod(add_representer) + + def add_multi_representer(cls, data_type, representer): + if not 'yaml_multi_representers' in cls.__dict__: + cls.yaml_multi_representers = cls.yaml_multi_representers.copy() + cls.yaml_multi_representers[data_type] = representer + add_multi_representer = classmethod(add_multi_representer) + + def represent_scalar(self, tag, value, style=None): + if style is None: + style = self.default_style + node = ScalarNode(tag, value, style=style) + if self.alias_key is not None: + self.represented_objects[self.alias_key] = node + return node + + def represent_sequence(self, tag, sequence, flow_style=None): + value = [] + node = SequenceNode(tag, value, flow_style=flow_style) + if self.alias_key is not None: + self.represented_objects[self.alias_key] = node + best_style = True + for item in sequence: + node_item = self.represent_data(item) + if not (isinstance(node_item, ScalarNode) and not node_item.style): + best_style = False + value.append(node_item) + if flow_style is None: + if self.default_flow_style is not None: + node.flow_style = self.default_flow_style + else: + node.flow_style = best_style + return node + + def represent_mapping(self, tag, mapping, flow_style=None): + value = [] + node = MappingNode(tag, value, flow_style=flow_style) + if self.alias_key is not None: + self.represented_objects[self.alias_key] = node + best_style = True + if hasattr(mapping, 'items'): + mapping = mapping.items() + mapping.sort() + for item_key, item_value in mapping: + node_key = self.represent_data(item_key) + node_value = self.represent_data(item_value) + if not (isinstance(node_key, ScalarNode) and not node_key.style): + best_style = False + if not (isinstance(node_value, ScalarNode) and not node_value.style): + best_style = False + value.append((node_key, node_value)) + if flow_style is None: + if self.default_flow_style is not None: + node.flow_style = self.default_flow_style + else: + node.flow_style = best_style + return node + + def ignore_aliases(self, data): + return False + +class SafeRepresenter(BaseRepresenter): + + def ignore_aliases(self, data): + if data in [None, ()]: + return True + if isinstance(data, (str, unicode, bool, int, float)): + return True + + def represent_none(self, data): + return self.represent_scalar(u'tag:yaml.org,2002:null', + u'null') + + def represent_str(self, data): + tag = None + style = None + try: + data = unicode(data, 'ascii') + tag = u'tag:yaml.org,2002:str' + except UnicodeDecodeError: + try: + data = unicode(data, 'utf-8') + tag = u'tag:yaml.org,2002:str' + except UnicodeDecodeError: + data = data.encode('base64') + tag = u'tag:yaml.org,2002:binary' + style = '|' + return self.represent_scalar(tag, data, style=style) + + def represent_unicode(self, data): + return self.represent_scalar(u'tag:yaml.org,2002:str', data) + + def represent_bool(self, data): + if data: + value = u'true' + else: + value = u'false' + return self.represent_scalar(u'tag:yaml.org,2002:bool', value) + + def represent_int(self, data): + return self.represent_scalar(u'tag:yaml.org,2002:int', unicode(data)) + + def represent_long(self, data): + return self.represent_scalar(u'tag:yaml.org,2002:int', unicode(data)) + + inf_value = 1e300 + while repr(inf_value) != repr(inf_value*inf_value): + inf_value *= inf_value + + def represent_float(self, data): + if data != data or (data == 0.0 and data == 1.0): + value = u'.nan' + elif data == self.inf_value: + value = u'.inf' + elif data == -self.inf_value: + value = u'-.inf' + else: + value = unicode(repr(data)) + return self.represent_scalar(u'tag:yaml.org,2002:float', value) + + def represent_list(self, data): + #pairs = (len(data) > 0 and isinstance(data, list)) + #if pairs: + # for item in data: + # if not isinstance(item, tuple) or len(item) != 2: + # pairs = False + # break + #if not pairs: + return self.represent_sequence(u'tag:yaml.org,2002:seq', data) + #value = [] + #for item_key, item_value in data: + # value.append(self.represent_mapping(u'tag:yaml.org,2002:map', + # [(item_key, item_value)])) + #return SequenceNode(u'tag:yaml.org,2002:pairs', value) + + def represent_dict(self, data): + return self.represent_mapping(u'tag:yaml.org,2002:map', data) + + def represent_set(self, data): + value = {} + for key in data: + value[key] = None + return self.represent_mapping(u'tag:yaml.org,2002:set', value) + + def represent_date(self, data): + value = unicode(data.isoformat()) + return self.represent_scalar(u'tag:yaml.org,2002:timestamp', value) + + def represent_datetime(self, data): + value = unicode(data.isoformat(' ')) + return self.represent_scalar(u'tag:yaml.org,2002:timestamp', value) + + def represent_yaml_object(self, tag, data, cls, flow_style=None): + if hasattr(data, '__getstate__'): + state = data.__getstate__() + else: + state = data.__dict__.copy() + return self.represent_mapping(tag, state, flow_style=flow_style) + + def represent_undefined(self, data): + raise RepresenterError("cannot represent an object: %s" % data) + +SafeRepresenter.add_representer(type(None), + SafeRepresenter.represent_none) + +SafeRepresenter.add_representer(str, + SafeRepresenter.represent_str) + +SafeRepresenter.add_representer(unicode, + SafeRepresenter.represent_unicode) + +SafeRepresenter.add_representer(bool, + SafeRepresenter.represent_bool) + +SafeRepresenter.add_representer(int, + SafeRepresenter.represent_int) + +SafeRepresenter.add_representer(long, + SafeRepresenter.represent_long) + +SafeRepresenter.add_representer(float, + SafeRepresenter.represent_float) + +SafeRepresenter.add_representer(list, + SafeRepresenter.represent_list) + +SafeRepresenter.add_representer(tuple, + SafeRepresenter.represent_list) + +SafeRepresenter.add_representer(dict, + SafeRepresenter.represent_dict) + +SafeRepresenter.add_representer(set, + SafeRepresenter.represent_set) + +SafeRepresenter.add_representer(datetime.date, + SafeRepresenter.represent_date) +SafeRepresenter.add_representer(datetime.datetime, + SafeRepresenter.represent_datetime) + +SafeRepresenter.add_representer(None, + SafeRepresenter.represent_undefined) + +class Representer(SafeRepresenter): + + def represent_str(self, data): + tag = None + style = None + try: + data = unicode(data, 'ascii') + tag = u'tag:yaml.org,2002:str' + except UnicodeDecodeError: + try: + data = unicode(data, 'utf-8') + tag = u'tag:yaml.org,2002:python/str' + except UnicodeDecodeError: + data = data.encode('base64') + tag = u'tag:yaml.org,2002:binary' + style = '|' + return self.represent_scalar(tag, data, style=style) + + def represent_unicode(self, data): + tag = None + try: + data.encode('ascii') + tag = u'tag:yaml.org,2002:python/unicode' + except UnicodeEncodeError: + tag = u'tag:yaml.org,2002:str' + return self.represent_scalar(tag, data) + + def represent_long(self, data): + tag = u'tag:yaml.org,2002:int' + if int(data) is not data: + tag = u'tag:yaml.org,2002:python/long' + return self.represent_scalar(tag, unicode(data)) + + def represent_complex(self, data): + if data.imag == 0.0: + data = u'%r' % data.real + elif data.real == 0.0: + data = u'%rj' % data.imag + elif data.imag > 0: + data = u'%r+%rj' % (data.real, data.imag) + else: + data = u'%r%rj' % (data.real, data.imag) + return self.represent_scalar(u'tag:yaml.org,2002:python/complex', data) + + def represent_tuple(self, data): + return self.represent_sequence(u'tag:yaml.org,2002:python/tuple', data) + + def represent_name(self, data): + name = u'%s.%s' % (data.__module__, data.__name__) + return self.represent_scalar(u'tag:yaml.org,2002:python/name:'+name, u'') + + def represent_module(self, data): + return self.represent_scalar( + u'tag:yaml.org,2002:python/module:'+data.__name__, u'') + + def represent_instance(self, data): + # For instances of classic classes, we use __getinitargs__ and + # __getstate__ to serialize the data. + + # If data.__getinitargs__ exists, the object must be reconstructed by + # calling cls(**args), where args is a tuple returned by + # __getinitargs__. Otherwise, the cls.__init__ method should never be + # called and the class instance is created by instantiating a trivial + # class and assigning to the instance's __class__ variable. + + # If data.__getstate__ exists, it returns the state of the object. + # Otherwise, the state of the object is data.__dict__. + + # We produce either a !!python/object or !!python/object/new node. + # If data.__getinitargs__ does not exist and state is a dictionary, we + # produce a !!python/object node . Otherwise we produce a + # !!python/object/new node. + + cls = data.__class__ + class_name = u'%s.%s' % (cls.__module__, cls.__name__) + args = None + state = None + if hasattr(data, '__getinitargs__'): + args = list(data.__getinitargs__()) + if hasattr(data, '__getstate__'): + state = data.__getstate__() + else: + state = data.__dict__ + if args is None and isinstance(state, dict): + return self.represent_mapping( + u'tag:yaml.org,2002:python/object:'+class_name, state) + if isinstance(state, dict) and not state: + return self.represent_sequence( + u'tag:yaml.org,2002:python/object/new:'+class_name, args) + value = {} + if args: + value['args'] = args + value['state'] = state + return self.represent_mapping( + u'tag:yaml.org,2002:python/object/new:'+class_name, value) + + def represent_object(self, data): + # We use __reduce__ API to save the data. data.__reduce__ returns + # a tuple of length 2-5: + # (function, args, state, listitems, dictitems) + + # For reconstructing, we calls function(*args), then set its state, + # listitems, and dictitems if they are not None. + + # A special case is when function.__name__ == '__newobj__'. In this + # case we create the object with args[0].__new__(*args). + + # Another special case is when __reduce__ returns a string - we don't + # support it. + + # We produce a !!python/object, !!python/object/new or + # !!python/object/apply node. + + cls = type(data) + if cls in copy_reg.dispatch_table: + reduce = copy_reg.dispatch_table[cls](data) + elif hasattr(data, '__reduce_ex__'): + reduce = data.__reduce_ex__(2) + elif hasattr(data, '__reduce__'): + reduce = data.__reduce__() + else: + raise RepresenterError("cannot represent object: %r" % data) + reduce = (list(reduce)+[None]*5)[:5] + function, args, state, listitems, dictitems = reduce + args = list(args) + if state is None: + state = {} + if listitems is not None: + listitems = list(listitems) + if dictitems is not None: + dictitems = dict(dictitems) + if function.__name__ == '__newobj__': + function = args[0] + args = args[1:] + tag = u'tag:yaml.org,2002:python/object/new:' + newobj = True + else: + tag = u'tag:yaml.org,2002:python/object/apply:' + newobj = False + function_name = u'%s.%s' % (function.__module__, function.__name__) + if not args and not listitems and not dictitems \ + and isinstance(state, dict) and newobj: + return self.represent_mapping( + u'tag:yaml.org,2002:python/object:'+function_name, state) + if not listitems and not dictitems \ + and isinstance(state, dict) and not state: + return self.represent_sequence(tag+function_name, args) + value = {} + if args: + value['args'] = args + if state or not isinstance(state, dict): + value['state'] = state + if listitems: + value['listitems'] = listitems + if dictitems: + value['dictitems'] = dictitems + return self.represent_mapping(tag+function_name, value) + +Representer.add_representer(str, + Representer.represent_str) + +Representer.add_representer(unicode, + Representer.represent_unicode) + +Representer.add_representer(long, + Representer.represent_long) + +Representer.add_representer(complex, + Representer.represent_complex) + +Representer.add_representer(tuple, + Representer.represent_tuple) + +Representer.add_representer(type, + Representer.represent_name) + +Representer.add_representer(Representer.classobj_type, + Representer.represent_name) + +Representer.add_representer(Representer.function_type, + Representer.represent_name) + +Representer.add_representer(Representer.builtin_function_type, + Representer.represent_name) + +Representer.add_representer(Representer.module_type, + Representer.represent_module) + +Representer.add_multi_representer(Representer.instance_type, + Representer.represent_instance) + +Representer.add_multi_representer(object, + Representer.represent_object) + Index: /pyyaml/tags/3.04/lib/yaml/__init__.py =================================================================== --- /pyyaml/tags/3.04/lib/yaml/__init__.py (revision 223) +++ /pyyaml/tags/3.04/lib/yaml/__init__.py (revision 223) @@ -0,0 +1,289 @@ + +from error import * + +from tokens import * +from events import * +from nodes import * + +from loader import * +from dumper import * + +try: + from cyaml import * +except ImportError: + pass + +def scan(stream, Loader=Loader): + """ + Scan a YAML stream and produce scanning tokens. + """ + loader = Loader(stream) + while loader.check_token(): + yield loader.get_token() + +def parse(stream, Loader=Loader): + """ + Parse a YAML stream and produce parsing events. + """ + loader = Loader(stream) + while loader.check_event(): + yield loader.get_event() + +def compose(stream, Loader=Loader): + """ + Parse the first YAML document in a stream + and produce the corresponding representation tree. + """ + loader = Loader(stream) + if loader.check_node(): + return loader.get_node() + +def compose_all(stream, Loader=Loader): + """ + Parse all YAML documents in a stream + and produce corresponsing representation trees. + """ + loader = Loader(stream) + while loader.check_node(): + yield loader.get_node() + +def load_all(stream, Loader=Loader): + """ + Parse all YAML documents in a stream + and produce corresponding Python objects. + """ + loader = Loader(stream) + while loader.check_data(): + yield loader.get_data() + +def load(stream, Loader=Loader): + """ + Parse the first YAML document in a stream + and produce the corresponding Python object. + """ + loader = Loader(stream) + if loader.check_data(): + return loader.get_data() + +def safe_load_all(stream): + """ + Parse all YAML documents in a stream + and produce corresponding Python objects. + Resolve only basic YAML tags. + """ + return load_all(stream, SafeLoader) + +def safe_load(stream): + """ + Parse the first YAML document in a stream + and produce the corresponding Python object. + Resolve only basic YAML tags. + """ + return load(stream, SafeLoader) + +def emit(events, stream=None, Dumper=Dumper, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None): + """ + Emit YAML parsing events into a stream. + If stream is None, return the produced string instead. + """ + getvalue = None + if stream is None: + try: + from cStringIO import StringIO + except ImportError: + from StringIO import StringIO + stream = StringIO() + getvalue = stream.getvalue + dumper = Dumper(stream, canonical=canonical, indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break) + for event in events: + dumper.emit(event) + if getvalue: + return getvalue() + +def serialize_all(nodes, stream=None, Dumper=Dumper, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding='utf-8', explicit_start=None, explicit_end=None, + version=None, tags=None): + """ + Serialize a sequence of representation trees into a YAML stream. + If stream is None, return the produced string instead. + """ + getvalue = None + if stream is None: + try: + from cStringIO import StringIO + except ImportError: + from StringIO import StringIO + stream = StringIO() + getvalue = stream.getvalue + dumper = Dumper(stream, canonical=canonical, indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break, + encoding=encoding, version=version, tags=tags, + explicit_start=explicit_start, explicit_end=explicit_end) + dumper.open() + for node in nodes: + dumper.serialize(node) + dumper.close() + if getvalue: + return getvalue() + +def serialize(node, stream=None, Dumper=Dumper, **kwds): + """ + Serialize a representation tree into a YAML stream. + If stream is None, return the produced string instead. + """ + return serialize_all([node], stream, Dumper=Dumper, **kwds) + +def dump_all(documents, stream=None, Dumper=Dumper, + default_style=None, default_flow_style=None, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding='utf-8', explicit_start=None, explicit_end=None, + version=None, tags=None): + """ + Serialize a sequence of Python objects into a YAML stream. + If stream is None, return the produced string instead. + """ + getvalue = None + if stream is None: + try: + from cStringIO import StringIO + except ImportError: + from StringIO import StringIO + stream = StringIO() + getvalue = stream.getvalue + dumper = Dumper(stream, default_style=default_style, + default_flow_style=default_flow_style, + canonical=canonical, indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break, + encoding=encoding, version=version, tags=tags, + explicit_start=explicit_start, explicit_end=explicit_end) + dumper.open() + for data in documents: + dumper.represent(data) + dumper.close() + if getvalue: + return getvalue() + +def dump(data, stream=None, Dumper=Dumper, **kwds): + """ + Serialize a Python object into a YAML stream. + If stream is None, return the produced string instead. + """ + return dump_all([data], stream, Dumper=Dumper, **kwds) + +def safe_dump_all(documents, stream=None, **kwds): + """ + Serialize a sequence of Python objects into a YAML stream. + Produce only basic YAML tags. + If stream is None, return the produced string instead. + """ + return dump_all(documents, stream, Dumper=SafeDumper, **kwds) + +def safe_dump(data, stream=None, **kwds): + """ + Serialize a Python object into a YAML stream. + Produce only basic YAML tags. + If stream is None, return the produced string instead. + """ + return dump_all([data], stream, Dumper=SafeDumper, **kwds) + +def add_implicit_resolver(tag, regexp, first=None, + Loader=Loader, Dumper=Dumper): + """ + Add an implicit scalar detector. + If an implicit scalar value matches the given regexp, + the corresponding tag is assigned to the scalar. + first is a sequence of possible initial characters or None. + """ + Loader.add_implicit_resolver(tag, regexp, first) + Dumper.add_implicit_resolver(tag, regexp, first) + +def add_path_resolver(tag, path, kind=None, Loader=Loader, Dumper=Dumper): + """ + Add a path based resolver for the given tag. + A path is a list of keys that forms a path + to a node in the representation tree. + Keys can be string values, integers, or None. + """ + Loader.add_path_resolver(tag, path, kind) + Dumper.add_path_resolver(tag, path, kind) + +def add_constructor(tag, constructor, Loader=Loader): + """ + Add a constructor for the given tag. + Constructor is a function that accepts a Loader instance + and a node object and produces the corresponding Python object. + """ + Loader.add_constructor(tag, constructor) + +def add_multi_constructor(tag_prefix, multi_constructor, Loader=Loader): + """ + Add a multi-constructor for the given tag prefix. + Multi-constructor is called for a node if its tag starts with tag_prefix. + Multi-constructor accepts a Loader instance, a tag suffix, + and a node object and produces the corresponding Python object. + """ + Loader.add_multi_constructor(tag_prefix, multi_constructor) + +def add_representer(data_type, representer, Dumper=Dumper): + """ + Add a representer for the given type. + Representer is a function accepting a Dumper instance + and an instance of the given data type + and producing the corresponding representation node. + """ + Dumper.add_representer(data_type, representer) + +def add_multi_representer(data_type, multi_representer, Dumper=Dumper): + """ + Add a representer for the given type. + Multi-representer is a function accepting a Dumper instance + and an instance of the given data type or subtype + and producing the corresponding representation node. + """ + Dumper.add_multi_representer(data_type, multi_representer) + +class YAMLObjectMetaclass(type): + """ + The metaclass for YAMLObject. + """ + def __init__(cls, name, bases, kwds): + super(YAMLObjectMetaclass, cls).__init__(name, bases, kwds) + if 'yaml_tag' in kwds and kwds['yaml_tag'] is not None: + cls.yaml_loader.add_constructor(cls.yaml_tag, cls.from_yaml) + cls.yaml_dumper.add_representer(cls, cls.to_yaml) + +class YAMLObject(object): + """ + An object that can dump itself to a YAML stream + and load itself from a YAML stream. + """ + + __metaclass__ = YAMLObjectMetaclass + + yaml_loader = Loader + yaml_dumper = Dumper + + yaml_tag = None + yaml_flow_style = None + + def from_yaml(cls, loader, node): + """ + Convert a representation node to a Python object. + """ + return loader.construct_yaml_object(node, cls) + from_yaml = classmethod(from_yaml) + + def to_yaml(cls, dumper, data): + """ + Convert a Python object to a representation node. + """ + return dumper.represent_yaml_object(cls.yaml_tag, data, cls, + flow_style=cls.yaml_flow_style) + to_yaml = classmethod(to_yaml) + Index: /pyyaml/tags/3.04/lib/yaml/resolver.py =================================================================== --- /pyyaml/tags/3.04/lib/yaml/resolver.py (revision 226) +++ /pyyaml/tags/3.04/lib/yaml/resolver.py (revision 226) @@ -0,0 +1,210 @@ + +__all__ = ['BaseResolver', 'Resolver'] + +from error import * +from nodes import * + +import re + +class ResolverError(YAMLError): + pass + +class BaseResolver(object): + + DEFAULT_SCALAR_TAG = u'tag:yaml.org,2002:str' + DEFAULT_SEQUENCE_TAG = u'tag:yaml.org,2002:seq' + DEFAULT_MAPPING_TAG = u'tag:yaml.org,2002:map' + + yaml_implicit_resolvers = {} + yaml_path_resolvers = {} + + def __init__(self): + self.resolver_exact_paths = [] + self.resolver_prefix_paths = [] + + def add_implicit_resolver(cls, tag, regexp, first): + if not 'yaml_implicit_resolvers' in cls.__dict__: + cls.yaml_implicit_resolvers = cls.yaml_implicit_resolvers.copy() + if first is None: + first = [None] + for ch in first: + cls.yaml_implicit_resolvers.setdefault(ch, []).append((tag, regexp)) + add_implicit_resolver = classmethod(add_implicit_resolver) + + def add_path_resolver(cls, tag, path, kind=None): + if not 'yaml_path_resolvers' in cls.__dict__: + cls.yaml_path_resolvers = cls.yaml_path_resolvers.copy() + new_path = [] + for element in path: + if isinstance(element, (list, tuple)): + if len(element) == 2: + node_check, index_check = element + elif len(element) == 1: + node_check = element[0] + index_check = True + else: + raise ResolverError("Invalid path element: %s" % element) + else: + node_check = None + index_check = element + if node_check is str: + node_check = ScalarNode + elif node_check is list: + node_check = SequenceNode + elif node_check is dict: + node_check = MappingNode + elif node_check not in [ScalarNode, SequenceNode, MappingNode] \ + and not isinstance(node_check, basestring) \ + and node_check is not None: + raise ResolverError("Invalid node checker: %s" % node_check) + if not isinstance(index_check, (basestring, int)) \ + and index_check is not None: + raise ResolverError("Invalid index checker: %s" % index_check) + new_path.append((node_check, index_check)) + if kind is str: + kind = ScalarNode + elif kind is list: + kind = SequenceNode + elif kind is dict: + kind = MappingNode + elif kind not in [ScalarNode, SequenceNode, MappingNode] \ + and kind is not None: + raise ResolverError("Invalid node kind: %s" % kind) + cls.yaml_path_resolvers[tuple(new_path), kind] = tag + add_path_resolver = classmethod(add_path_resolver) + + def descend_resolver(self, current_node, current_index): + if not self.yaml_path_resolvers: + return + exact_paths = {} + prefix_paths = [] + if current_node: + depth = len(self.resolver_prefix_paths) + for path, kind in self.resolver_prefix_paths[-1]: + if self.check_resolver_prefix(depth, path, kind, + current_node, current_index): + if len(path) > depth: + prefix_paths.append((path, kind)) + else: + exact_paths[kind] = self.yaml_path_resolvers[path, kind] + else: + for path, kind in self.yaml_path_resolvers: + if not path: + exact_paths[kind] = self.yaml_path_resolvers[path, kind] + else: + prefix_paths.append((path, kind)) + self.resolver_exact_paths.append(exact_paths) + self.resolver_prefix_paths.append(prefix_paths) + + def ascend_resolver(self): + if not self.yaml_path_resolvers: + return + self.resolver_exact_paths.pop() + self.resolver_prefix_paths.pop() + + def check_resolver_prefix(self, depth, path, kind, + current_node, current_index): + node_check, index_check = path[depth-1] + if isinstance(node_check, basestring): + if current_node.tag != node_check: + return + elif node_check is not None: + if not isinstance(current_node, node_check): + return + if index_check is True and current_index is not None: + return + if index_check in [False, None] and current_index is None: + return + if isinstance(index_check, basestring): + if not (isinstance(current_index, ScalarNode) + and index_check == current_index.value): + return + elif isinstance(index_check, int): + if index_check != current_index: + return + return True + + def resolve(self, kind, value, implicit): + if kind is ScalarNode and implicit[0]: + if value == u'': + resolvers = self.yaml_implicit_resolvers.get(u'', []) + else: + resolvers = self.yaml_implicit_resolvers.get(value[0], []) + resolvers += self.yaml_implicit_resolvers.get(None, []) + for tag, regexp in resolvers: + if regexp.match(value): + return tag + implicit = implicit[1] + if self.yaml_path_resolvers: + exact_paths = self.resolver_exact_paths[-1] + if kind in exact_paths: + return exact_paths[kind] + if None in exact_paths: + return exact_paths[None] + if kind is ScalarNode: + return self.DEFAULT_SCALAR_TAG + elif kind is SequenceNode: + return self.DEFAULT_SEQUENCE_TAG + elif kind is MappingNode: + return self.DEFAULT_MAPPING_TAG + +class Resolver(BaseResolver): + pass + +Resolver.add_implicit_resolver( + u'tag:yaml.org,2002:bool', + re.compile(ur'''^(?:yes|Yes|YES|no|No|NO + |true|True|TRUE|false|False|FALSE + |on|On|ON|off|Off|OFF)$''', re.X), + list(u'yYnNtTfFoO')) + +Resolver.add_implicit_resolver( + u'tag:yaml.org,2002:float', + re.compile(ur'''^(?:[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*(?:[eE][-+][0-9]+)? + |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]* + |[-+]?\.(?:inf|Inf|INF) + |\.(?:nan|NaN|NAN))$''', re.X), + list(u'-+0123456789.')) + +Resolver.add_implicit_resolver( + u'tag:yaml.org,2002:int', + re.compile(ur'''^(?:[-+]?0b[0-1_]+ + |[-+]?0[0-7_]+ + |[-+]?(?:0|[1-9][0-9_]*) + |[-+]?0x[0-9a-fA-F_]+ + |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$''', re.X), + list(u'-+0123456789')) + +Resolver.add_implicit_resolver( + u'tag:yaml.org,2002:merge', + re.compile(ur'^(?:<<)$'), + ['<']) + +Resolver.add_implicit_resolver( + u'tag:yaml.org,2002:null', + re.compile(ur'''^(?: ~ + |null|Null|NULL + | )$''', re.X), + [u'~', u'n', u'N', u'']) + +Resolver.add_implicit_resolver( + u'tag:yaml.org,2002:timestamp', + re.compile(ur'''^(?:[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9] + |[0-9][0-9][0-9][0-9] -[0-9][0-9]? -[0-9][0-9]? + (?:[Tt]|[ \t]+)[0-9][0-9]? + :[0-9][0-9] :[0-9][0-9] (?:\.[0-9]*)? + (?:[ \t]*(?:Z|[-+][0-9][0-9]?(?::[0-9][0-9])?))?)$''', re.X), + list(u'0123456789')) + +Resolver.add_implicit_resolver( + u'tag:yaml.org,2002:value', + re.compile(ur'^(?:=)$'), + ['=']) + +# The following resolver is only for documentation purposes. It cannot work +# because plain scalars cannot start with '!', '&', or '*'. +Resolver.add_implicit_resolver( + u'tag:yaml.org,2002:yaml', + re.compile(ur'^(?:!|&|\*)$'), + list(u'!&*')) + Index: /pyyaml/tags/3.04/lib/yaml/reader.py =================================================================== --- /pyyaml/tags/3.04/lib/yaml/reader.py (revision 222) +++ /pyyaml/tags/3.04/lib/yaml/reader.py (revision 222) @@ -0,0 +1,225 @@ +# This module contains abstractions for the input stream. You don't have to +# looks further, there are no pretty code. +# +# We define two classes here. +# +# Mark(source, line, column) +# It's just a record and its only use is producing nice error messages. +# Parser does not use it for any other purposes. +# +# Reader(source, data) +# Reader determines the encoding of `data` and converts it to unicode. +# Reader provides the following methods and attributes: +# reader.peek(length=1) - return the next `length` characters +# reader.forward(length=1) - move the current position to `length` characters. +# reader.index - the number of the current character. +# reader.line, stream.column - the line and the column of the current character. + +__all__ = ['Reader', 'ReaderError'] + +from error import YAMLError, Mark + +import codecs, re + +# Unfortunately, codec functions in Python 2.3 does not support the `finish` +# arguments, so we have to write our own wrappers. + +try: + codecs.utf_8_decode('', 'strict', False) + from codecs import utf_8_decode, utf_16_le_decode, utf_16_be_decode + +except TypeError: + + def utf_16_le_decode(data, errors, finish=False): + if not finish and len(data) % 2 == 1: + data = data[:-1] + return codecs.utf_16_le_decode(data, errors) + + def utf_16_be_decode(data, errors, finish=False): + if not finish and len(data) % 2 == 1: + data = data[:-1] + return codecs.utf_16_be_decode(data, errors) + + def utf_8_decode(data, errors, finish=False): + if not finish: + # We are trying to remove a possible incomplete multibyte character + # from the suffix of the data. + # The first byte of a multi-byte sequence is in the range 0xc0 to 0xfd. + # All further bytes are in the range 0x80 to 0xbf. + # UTF-8 encoded UCS characters may be up to six bytes long. + count = 0 + while count < 5 and count < len(data) \ + and '\x80' <= data[-count-1] <= '\xBF': + count -= 1 + if count < 5 and count < len(data) \ + and '\xC0' <= data[-count-1] <= '\xFD': + data = data[:-count-1] + return codecs.utf_8_decode(data, errors) + +class ReaderError(YAMLError): + + def __init__(self, name, position, character, encoding, reason): + self.name = name + self.character = character + self.position = position + self.encoding = encoding + self.reason = reason + + def __str__(self): + if isinstance(self.character, str): + return "'%s' codec can't decode byte #x%02x: %s\n" \ + " in \"%s\", position %d" \ + % (self.encoding, ord(self.character), self.reason, + self.name, self.position) + else: + return "unacceptable character #x%04x: %s\n" \ + " in \"%s\", position %d" \ + % (ord(self.character), self.reason, + self.name, self.position) + +class Reader(object): + # Reader: + # - determines the data encoding and converts it to unicode, + # - checks if characters are in allowed range, + # - adds '\0' to the end. + + # Reader accepts + # - a `str` object, + # - a `unicode` object, + # - a file-like object with its `read` method returning `str`, + # - a file-like object with its `read` method returning `unicode`. + + # Yeah, it's ugly and slow. + + def __init__(self, stream): + self.name = None + self.stream = None + self.stream_pointer = 0 + self.eof = True + self.buffer = u'' + self.pointer = 0 + self.raw_buffer = None + self.raw_decode = None + self.encoding = None + self.index = 0 + self.line = 0 + self.column = 0 + if isinstance(stream, unicode): + self.name = "" + self.check_printable(stream) + self.buffer = stream+u'\0' + elif isinstance(stream, str): + self.name = "" + self.raw_buffer = stream + self.determine_encoding() + else: + self.stream = stream + self.name = getattr(stream, 'name', "") + self.eof = False + self.raw_buffer = '' + self.determine_encoding() + + def peek(self, index=0): + try: + return self.buffer[self.pointer+index] + except IndexError: + self.update(index+1) + return self.buffer[self.pointer+index] + + def prefix(self, length=1): + if self.pointer+length >= len(self.buffer): + self.update(length) + return self.buffer[self.pointer:self.pointer+length] + + def forward(self, length=1): + if self.pointer+length+1 >= len(self.buffer): + self.update(length+1) + while length: + ch = self.buffer[self.pointer] + self.pointer += 1 + self.index += 1 + if ch in u'\n\x85\u2028\u2029' \ + or (ch == u'\r' and self.buffer[self.pointer] != u'\n'): + self.line += 1 + self.column = 0 + elif ch != u'\uFEFF': + self.column += 1 + length -= 1 + + def get_mark(self): + if self.stream is None: + return Mark(self.name, self.index, self.line, self.column, + self.buffer, self.pointer) + else: + return Mark(self.name, self.index, self.line, self.column, + None, None) + + def determine_encoding(self): + while not self.eof and len(self.raw_buffer) < 2: + self.update_raw() + if not isinstance(self.raw_buffer, unicode): + if self.raw_buffer.startswith(codecs.BOM_UTF16_LE): + self.raw_decode = utf_16_le_decode + self.encoding = 'utf-16-le' + elif self.raw_buffer.startswith(codecs.BOM_UTF16_BE): + self.raw_decode = utf_16_be_decode + self.encoding = 'utf-16-be' + else: + self.raw_decode = utf_8_decode + self.encoding = 'utf-8' + self.update(1) + + NON_PRINTABLE = re.compile(u'[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\uD7FF\uE000-\uFFFD]') + def check_printable(self, data): + match = self.NON_PRINTABLE.search(data) + if match: + character = match.group() + position = self.index+(len(self.buffer)-self.pointer)+match.start() + raise ReaderError(self.name, position, character, + 'unicode', "special characters are not allowed") + + def update(self, length): + if self.raw_buffer is None: + return + self.buffer = self.buffer[self.pointer:] + self.pointer = 0 + while len(self.buffer) < length: + if not self.eof: + self.update_raw() + if self.raw_decode is not None: + try: + data, converted = self.raw_decode(self.raw_buffer, + 'strict', self.eof) + except UnicodeDecodeError, exc: + character = exc.object[exc.start] + if self.stream is not None: + position = self.stream_pointer-len(self.raw_buffer)+exc.start + else: + position = exc.start + raise ReaderError(self.name, position, character, + exc.encoding, exc.reason) + else: + data = self.raw_buffer + converted = len(data) + self.check_printable(data) + self.buffer += data + self.raw_buffer = self.raw_buffer[converted:] + if self.eof: + self.buffer += u'\0' + self.raw_buffer = None + break + + def update_raw(self, size=1024): + data = self.stream.read(size) + if data: + self.raw_buffer += data + self.stream_pointer += len(data) + else: + self.eof = True + +#try: +# import psyco +# psyco.bind(Reader) +#except ImportError: +# pass + Index: /pyyaml/tags/3.04/lib/yaml/tokens.py =================================================================== --- /pyyaml/tags/3.04/lib/yaml/tokens.py (revision 222) +++ /pyyaml/tags/3.04/lib/yaml/tokens.py (revision 222) @@ -0,0 +1,104 @@ + +class Token(object): + def __init__(self, start_mark, end_mark): + self.start_mark = start_mark + self.end_mark = end_mark + def __repr__(self): + attributes = [key for key in self.__dict__ + if not key.endswith('_mark')] + attributes.sort() + arguments = ', '.join(['%s=%r' % (key, getattr(self, key)) + for key in attributes]) + return '%s(%s)' % (self.__class__.__name__, arguments) + +#class BOMToken(Token): +# id = '' + +class DirectiveToken(Token): + id = '' + def __init__(self, name, value, start_mark, end_mark): + self.name = name + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + +class DocumentStartToken(Token): + id = '' + +class DocumentEndToken(Token): + id = '' + +class StreamStartToken(Token): + id = '' + def __init__(self, start_mark=None, end_mark=None, + encoding=None): + self.start_mark = start_mark + self.end_mark = end_mark + self.encoding = encoding + +class StreamEndToken(Token): + id = '' + +class BlockSequenceStartToken(Token): + id = '' + +class BlockMappingStartToken(Token): + id = '' + +class BlockEndToken(Token): + id = '' + +class FlowSequenceStartToken(Token): + id = '[' + +class FlowMappingStartToken(Token): + id = '{' + +class FlowSequenceEndToken(Token): + id = ']' + +class FlowMappingEndToken(Token): + id = '}' + +class KeyToken(Token): + id = '?' + +class ValueToken(Token): + id = ':' + +class BlockEntryToken(Token): + id = '-' + +class FlowEntryToken(Token): + id = ',' + +class AliasToken(Token): + id = '' + def __init__(self, value, start_mark, end_mark): + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + +class AnchorToken(Token): + id = '' + def __init__(self, value, start_mark, end_mark): + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + +class TagToken(Token): + id = '' + def __init__(self, value, start_mark, end_mark): + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + +class ScalarToken(Token): + id = '' + def __init__(self, value, plain, start_mark, end_mark, style=None): + self.value = value + self.plain = plain + self.start_mark = start_mark + self.end_mark = end_mark + self.style = style + Index: /pyyaml/tags/3.04/lib/yaml/events.py =================================================================== --- /pyyaml/tags/3.04/lib/yaml/events.py (revision 222) +++ /pyyaml/tags/3.04/lib/yaml/events.py (revision 222) @@ -0,0 +1,86 @@ + +# Abstract classes. + +class Event(object): + def __init__(self, start_mark=None, end_mark=None): + self.start_mark = start_mark + self.end_mark = end_mark + def __repr__(self): + attributes = [key for key in ['anchor', 'tag', 'implicit', 'value'] + if hasattr(self, key)] + arguments = ', '.join(['%s=%r' % (key, getattr(self, key)) + for key in attributes]) + return '%s(%s)' % (self.__class__.__name__, arguments) + +class NodeEvent(Event): + def __init__(self, anchor, start_mark=None, end_mark=None): + self.anchor = anchor + self.start_mark = start_mark + self.end_mark = end_mark + +class CollectionStartEvent(NodeEvent): + def __init__(self, anchor, tag, implicit, start_mark=None, end_mark=None, + flow_style=None): + self.anchor = anchor + self.tag = tag + self.implicit = implicit + self.start_mark = start_mark + self.end_mark = end_mark + self.flow_style = flow_style + +class CollectionEndEvent(Event): + pass + +# Implementations. + +class StreamStartEvent(Event): + def __init__(self, start_mark=None, end_mark=None, encoding=None): + self.start_mark = start_mark + self.end_mark = end_mark + self.encoding = encoding + +class StreamEndEvent(Event): + pass + +class DocumentStartEvent(Event): + def __init__(self, start_mark=None, end_mark=None, + explicit=None, version=None, tags=None): + self.start_mark = start_mark + self.end_mark = end_mark + self.explicit = explicit + self.version = version + self.tags = tags + +class DocumentEndEvent(Event): + def __init__(self, start_mark=None, end_mark=None, + explicit=None): + self.start_mark = start_mark + self.end_mark = end_mark + self.explicit = explicit + +class AliasEvent(NodeEvent): + pass + +class ScalarEvent(NodeEvent): + def __init__(self, anchor, tag, implicit, value, + start_mark=None, end_mark=None, style=None): + self.anchor = anchor + self.tag = tag + self.implicit = implicit + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + self.style = style + +class SequenceStartEvent(CollectionStartEvent): + pass + +class SequenceEndEvent(CollectionEndEvent): + pass + +class MappingStartEvent(CollectionStartEvent): + pass + +class MappingEndEvent(CollectionEndEvent): + pass + Index: /pyyaml/tags/3.04/lib/yaml/cyaml.py =================================================================== --- /pyyaml/tags/3.04/lib/yaml/cyaml.py (revision 223) +++ /pyyaml/tags/3.04/lib/yaml/cyaml.py (revision 223) @@ -0,0 +1,85 @@ + +__all__ = ['CBaseLoader', 'CSafeLoader', 'CLoader', + 'CBaseDumper', 'CSafeDumper', 'CDumper'] + +from _yaml import CParser, CEmitter + +from constructor import * + +from serializer import * +from representer import * + +from resolver import * + +class CBaseLoader(CParser, BaseConstructor, BaseResolver): + + def __init__(self, stream): + CParser.__init__(self, stream) + BaseConstructor.__init__(self) + BaseResolver.__init__(self) + +class CSafeLoader(CParser, SafeConstructor, Resolver): + + def __init__(self, stream): + CParser.__init__(self, stream) + SafeConstructor.__init__(self) + Resolver.__init__(self) + +class CLoader(CParser, Constructor, Resolver): + + def __init__(self, stream): + CParser.__init__(self, stream) + Constructor.__init__(self) + Resolver.__init__(self) + +class CBaseDumper(CEmitter, BaseRepresenter, BaseResolver): + + def __init__(self, stream, + default_style=None, default_flow_style=None, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None): + CEmitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + Representer.__init__(self, default_style=default_style, + default_flow_style=default_flow_style) + Resolver.__init__(self) + +class CSafeDumper(CEmitter, SafeRepresenter, Resolver): + + def __init__(self, stream, + default_style=None, default_flow_style=None, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None): + CEmitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + SafeRepresenter.__init__(self, default_style=default_style, + default_flow_style=default_flow_style) + Resolver.__init__(self) + +class CDumper(CEmitter, Serializer, Representer, Resolver): + + def __init__(self, stream, + default_style=None, default_flow_style=None, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None): + CEmitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + Representer.__init__(self, default_style=default_style, + default_flow_style=default_flow_style) + Resolver.__init__(self) + Index: /pyyaml/tags/3.04/lib/yaml/loader.py =================================================================== --- /pyyaml/tags/3.04/lib/yaml/loader.py (revision 137) +++ /pyyaml/tags/3.04/lib/yaml/loader.py (revision 137) @@ -0,0 +1,40 @@ + +__all__ = ['BaseLoader', 'SafeLoader', 'Loader'] + +from reader import * +from scanner import * +from parser import * +from composer import * +from constructor import * +from resolver import * + +class BaseLoader(Reader, Scanner, Parser, Composer, BaseConstructor, BaseResolver): + + def __init__(self, stream): + Reader.__init__(self, stream) + Scanner.__init__(self) + Parser.__init__(self) + Composer.__init__(self) + BaseConstructor.__init__(self) + BaseResolver.__init__(self) + +class SafeLoader(Reader, Scanner, Parser, Composer, SafeConstructor, Resolver): + + def __init__(self, stream): + Reader.__init__(self, stream) + Scanner.__init__(self) + Parser.__init__(self) + Composer.__init__(self) + SafeConstructor.__init__(self) + Resolver.__init__(self) + +class Loader(Reader, Scanner, Parser, Composer, Constructor, Resolver): + + def __init__(self, stream): + Reader.__init__(self, stream) + Scanner.__init__(self) + Parser.__init__(self) + Composer.__init__(self) + Constructor.__init__(self) + Resolver.__init__(self) + Index: /pyyaml/tags/3.04/lib/yaml/nodes.py =================================================================== --- /pyyaml/tags/3.04/lib/yaml/nodes.py (revision 222) +++ /pyyaml/tags/3.04/lib/yaml/nodes.py (revision 222) @@ -0,0 +1,49 @@ + +class Node(object): + def __init__(self, tag, value, start_mark, end_mark): + self.tag = tag + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + def __repr__(self): + value = self.value + #if isinstance(value, list): + # if len(value) == 0: + # value = '' + # elif len(value) == 1: + # value = '<1 item>' + # else: + # value = '<%d items>' % len(value) + #else: + # if len(value) > 75: + # value = repr(value[:70]+u' ... ') + # else: + # value = repr(value) + value = repr(value) + return '%s(tag=%r, value=%s)' % (self.__class__.__name__, self.tag, value) + +class ScalarNode(Node): + id = 'scalar' + def __init__(self, tag, value, + start_mark=None, end_mark=None, style=None): + self.tag = tag + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + self.style = style + +class CollectionNode(Node): + def __init__(self, tag, value, + start_mark=None, end_mark=None, flow_style=None): + self.tag = tag + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + self.flow_style = flow_style + +class SequenceNode(CollectionNode): + id = 'sequence' + +class MappingNode(CollectionNode): + id = 'mapping' + Index: /pyyaml/tags/3.04/lib/yaml/serializer.py =================================================================== --- /pyyaml/tags/3.04/lib/yaml/serializer.py (revision 222) +++ /pyyaml/tags/3.04/lib/yaml/serializer.py (revision 222) @@ -0,0 +1,111 @@ + +__all__ = ['Serializer', 'SerializerError'] + +from error import YAMLError +from events import * +from nodes import * + +class SerializerError(YAMLError): + pass + +class Serializer(object): + + ANCHOR_TEMPLATE = u'id%03d' + + def __init__(self, encoding=None, + explicit_start=None, explicit_end=None, version=None, tags=None): + self.use_encoding = encoding + self.use_explicit_start = explicit_start + self.use_explicit_end = explicit_end + self.use_version = version + self.use_tags = tags + self.serialized_nodes = {} + self.anchors = {} + self.last_anchor_id = 0 + self.closed = None + + def open(self): + if self.closed is None: + self.emit(StreamStartEvent(encoding=self.use_encoding)) + self.closed = False + elif self.closed: + raise SerializerError("serializer is closed") + else: + raise SerializerError("serializer is already opened") + + def close(self): + if self.closed is None: + raise SerializerError("serializer is not opened") + elif not self.closed: + self.emit(StreamEndEvent()) + self.closed = True + + #def __del__(self): + # self.close() + + def serialize(self, node): + if self.closed is None: + raise SerializerError("serializer is not opened") + elif self.closed: + raise SerializerError("serializer is closed") + self.emit(DocumentStartEvent(explicit=self.use_explicit_start, + version=self.use_version, tags=self.use_tags)) + self.anchor_node(node) + self.serialize_node(node, None, None) + self.emit(DocumentEndEvent(explicit=self.use_explicit_end)) + self.serialized_nodes = {} + self.anchors = {} + self.last_alias_id = 0 + + def anchor_node(self, node): + if node in self.anchors: + if self.anchors[node] is None: + self.anchors[node] = self.generate_anchor(node) + else: + self.anchors[node] = None + if isinstance(node, SequenceNode): + for item in node.value: + self.anchor_node(item) + elif isinstance(node, MappingNode): + for key, value in node.value: + self.anchor_node(key) + self.anchor_node(value) + + def generate_anchor(self, node): + self.last_anchor_id += 1 + return self.ANCHOR_TEMPLATE % self.last_anchor_id + + def serialize_node(self, node, parent, index): + alias = self.anchors[node] + if node in self.serialized_nodes: + self.emit(AliasEvent(alias)) + else: + self.serialized_nodes[node] = True + self.descend_resolver(parent, index) + if isinstance(node, ScalarNode): + detected_tag = self.resolve(ScalarNode, node.value, (True, False)) + default_tag = self.resolve(ScalarNode, node.value, (False, True)) + implicit = (node.tag == detected_tag), (node.tag == default_tag) + self.emit(ScalarEvent(alias, node.tag, implicit, node.value, + style=node.style)) + elif isinstance(node, SequenceNode): + implicit = (node.tag + == self.resolve(SequenceNode, node.value, True)) + self.emit(SequenceStartEvent(alias, node.tag, implicit, + flow_style=node.flow_style)) + index = 0 + for item in node.value: + self.serialize_node(item, node, index) + index += 1 + self.emit(SequenceEndEvent()) + elif isinstance(node, MappingNode): + implicit = (node.tag + == self.resolve(MappingNode, node.value, True)) + self.emit(MappingStartEvent(alias, node.tag, implicit, + flow_style=node.flow_style)) + for key, value in node.value: + self.serialize_node(key, node, None) + self.serialize_node(value, node, key) + self.emit(MappingEndEvent()) + self.ascend_resolver() + Index: /pyyaml/tags/3.04/lib/yaml/emitter.py =================================================================== --- /pyyaml/tags/3.04/lib/yaml/emitter.py (revision 222) +++ /pyyaml/tags/3.04/lib/yaml/emitter.py (revision 222) @@ -0,0 +1,1163 @@ + +# Emitter expects events obeying the following grammar: +# stream ::= STREAM-START document* STREAM-END +# document ::= DOCUMENT-START node DOCUMENT-END +# node ::= SCALAR | sequence | mapping +# sequence ::= SEQUENCE-START node* SEQUENCE-END +# mapping ::= MAPPING-START (node node)* MAPPING-END + +__all__ = ['Emitter', 'EmitterError'] + +from error import YAMLError +from events import * + +import re + +class EmitterError(YAMLError): + pass + +class ScalarAnalysis(object): + def __init__(self, scalar, empty, multiline, + allow_flow_plain, allow_block_plain, + allow_single_quoted, allow_double_quoted, + allow_block): + self.scalar = scalar + self.empty = empty + self.multiline = multiline + self.allow_flow_plain = allow_flow_plain + self.allow_block_plain = allow_block_plain + self.allow_single_quoted = allow_single_quoted + self.allow_double_quoted = allow_double_quoted + self.allow_block = allow_block + +class Emitter(object): + + DEFAULT_TAG_PREFIXES = { + u'!' : u'!', + u'tag:yaml.org,2002:' : u'!!', + } + + def __init__(self, stream, canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None): + + # The stream should have the methods `write` and possibly `flush`. + self.stream = stream + + # Encoding can be overriden by STREAM-START. + self.encoding = None + + # Emitter is a state machine with a stack of states to handle nested + # structures. + self.states = [] + self.state = self.expect_stream_start + + # Current event and the event queue. + self.events = [] + self.event = None + + # The current indentation level and the stack of previous indents. + self.indents = [] + self.indent = None + + # Flow level. + self.flow_level = 0 + + # Contexts. + self.root_context = False + self.sequence_context = False + self.mapping_context = False + self.simple_key_context = False + + # Characteristics of the last emitted character: + # - current position. + # - is it a whitespace? + # - is it an indention character + # (indentation space, '-', '?', or ':')? + self.line = 0 + self.column = 0 + self.whitespace = True + self.indention = True + + # Formatting details. + self.canonical = canonical + self.allow_unicode = allow_unicode + self.best_indent = 2 + if indent and 1 < indent < 10: + self.best_indent = indent + self.best_width = 80 + if width and width > self.best_indent*2: + self.best_width = width + self.best_line_break = u'\n' + if line_break in [u'\r', u'\n', u'\r\n']: + self.best_line_break = line_break + + # Tag prefixes. + self.tag_prefixes = None + + # Prepared anchor and tag. + self.prepared_anchor = None + self.prepared_tag = None + + # Scalar analysis and style. + self.analysis = None + self.style = None + + def emit(self, event): + self.events.append(event) + while not self.need_more_events(): + self.event = self.events.pop(0) + self.state() + self.event = None + + # In some cases, we wait for a few next events before emitting. + + def need_more_events(self): + if not self.events: + return True + event = self.events[0] + if isinstance(event, DocumentStartEvent): + return self.need_events(1) + elif isinstance(event, SequenceStartEvent): + return self.need_events(2) + elif isinstance(event, MappingStartEvent): + return self.need_events(3) + else: + return False + + def need_events(self, count): + level = 0 + for event in self.events[1:]: + if isinstance(event, (DocumentStartEvent, CollectionStartEvent)): + level += 1 + elif isinstance(event, (DocumentEndEvent, CollectionEndEvent)): + level -= 1 + elif isinstance(event, StreamEndEvent): + level = -1 + if level < 0: + return False + return (len(self.events) < count+1) + + def increase_indent(self, flow=False, indentless=False): + self.indents.append(self.indent) + if self.indent is None: + if flow: + self.indent = self.best_indent + else: + self.indent = 0 + elif not indentless: + self.indent += self.best_indent + + # States. + + # Stream handlers. + + def expect_stream_start(self): + if isinstance(self.event, StreamStartEvent): + if self.event.encoding: + self.encoding = self.event.encoding + self.write_stream_start() + self.state = self.expect_first_document_start + else: + raise EmitterError("expected StreamStartEvent, but got %s" + % self.event) + + def expect_nothing(self): + raise EmitterError("expected nothing, but got %s" % self.event) + + # Document handlers. + + def expect_first_document_start(self): + return self.expect_document_start(first=True) + + def expect_document_start(self, first=False): + if isinstance(self.event, DocumentStartEvent): + if self.event.version: + version_text = self.prepare_version(self.event.version) + self.write_version_directive(version_text) + self.tag_prefixes = self.DEFAULT_TAG_PREFIXES.copy() + if self.event.tags: + handles = self.event.tags.keys() + handles.sort() + for handle in handles: + prefix = self.event.tags[handle] + self.tag_prefixes[prefix] = handle + handle_text = self.prepare_tag_handle(handle) + prefix_text = self.prepare_tag_prefix(prefix) + self.write_tag_directive(handle_text, prefix_text) + implicit = (first and not self.event.explicit and not self.canonical + and not self.event.version and not self.event.tags + and not self.check_empty_document()) + if not implicit: + self.write_indent() + self.write_indicator(u'---', True) + if self.canonical: + self.write_indent() + self.state = self.expect_document_root + elif isinstance(self.event, StreamEndEvent): + self.write_stream_end() + self.state = self.expect_nothing + else: + raise EmitterError("expected DocumentStartEvent, but got %s" + % self.event) + + def expect_document_end(self): + if isinstance(self.event, DocumentEndEvent): + self.write_indent() + if self.event.explicit: + self.write_indicator(u'...', True) + self.write_indent() + self.flush_stream() + self.state = self.expect_document_start + else: + raise EmitterError("expected DocumentEndEvent, but got %s" + % self.event) + + def expect_document_root(self): + self.states.append(self.expect_document_end) + self.expect_node(root=True) + + # Node handlers. + + def expect_node(self, root=False, sequence=False, mapping=False, + simple_key=False): + self.root_context = root + self.sequence_context = sequence + self.mapping_context = mapping + self.simple_key_context = simple_key + if isinstance(self.event, AliasEvent): + self.expect_alias() + elif isinstance(self.event, (ScalarEvent, CollectionStartEvent)): + self.process_anchor(u'&') + self.process_tag() + if isinstance(self.event, ScalarEvent): + self.expect_scalar() + elif isinstance(self.event, SequenceStartEvent): + if self.flow_level or self.canonical or self.event.flow_style \ + or self.check_empty_sequence(): + self.expect_flow_sequence() + else: + self.expect_block_sequence() + elif isinstance(self.event, MappingStartEvent): + if self.flow_level or self.canonical or self.event.flow_style \ + or self.check_empty_mapping(): + self.expect_flow_mapping() + else: + self.expect_block_mapping() + else: + raise EmitterError("expected NodeEvent, but got %s" % self.event) + + def expect_alias(self): + if self.event.anchor is None: + raise EmitterError("anchor is not specified for alias") + self.process_anchor(u'*') + self.state = self.states.pop() + + def expect_scalar(self): + self.increase_indent(flow=True) + self.process_scalar() + self.indent = self.indents.pop() + self.state = self.states.pop() + + # Flow sequence handlers. + + def expect_flow_sequence(self): + self.write_indicator(u'[', True, whitespace=True) + self.flow_level += 1 + self.increase_indent(flow=True) + self.state = self.expect_first_flow_sequence_item + + def expect_first_flow_sequence_item(self): + if isinstance(self.event, SequenceEndEvent): + self.indent = self.indents.pop() + self.flow_level -= 1 + self.write_indicator(u']', False) + self.state = self.states.pop() + else: + if self.canonical or self.column > self.best_width: + self.write_indent() + self.states.append(self.expect_flow_sequence_item) + self.expect_node(sequence=True) + + def expect_flow_sequence_item(self): + if isinstance(self.event, SequenceEndEvent): + self.indent = self.indents.pop() + self.flow_level -= 1 + if self.canonical: + self.write_indicator(u',', False) + self.write_indent() + self.write_indicator(u']', False) + self.state = self.states.pop() + else: + self.write_indicator(u',', False) + if self.canonical or self.column > self.best_width: + self.write_indent() + self.states.append(self.expect_flow_sequence_item) + self.expect_node(sequence=True) + + # Flow mapping handlers. + + def expect_flow_mapping(self): + self.write_indicator(u'{', True, whitespace=True) + self.flow_level += 1 + self.increase_indent(flow=True) + self.state = self.expect_first_flow_mapping_key + + def expect_first_flow_mapping_key(self): + if isinstance(self.event, MappingEndEvent): + self.indent = self.indents.pop() + self.flow_level -= 1 + self.write_indicator(u'}', False) + self.state = self.states.pop() + else: + if self.canonical or self.column > self.best_width: + self.write_indent() + if not self.canonical and self.check_simple_key(): + self.states.append(self.expect_flow_mapping_simple_value) + self.expect_node(mapping=True, simple_key=True) + else: + self.write_indicator(u'?', True) + self.states.append(self.expect_flow_mapping_value) + self.expect_node(mapping=True) + + def expect_flow_mapping_key(self): + if isinstance(self.event, MappingEndEvent): + self.indent = self.indents.pop() + self.flow_level -= 1 + if self.canonical: + self.write_indicator(u',', False) + self.write_indent() + self.write_indicator(u'}', False) + self.state = self.states.pop() + else: + self.write_indicator(u',', False) + if self.canonical or self.column > self.best_width: + self.write_indent() + if not self.canonical and self.check_simple_key(): + self.states.append(self.expect_flow_mapping_simple_value) + self.expect_node(mapping=True, simple_key=True) + else: + self.write_indicator(u'?', True) + self.states.append(self.expect_flow_mapping_value) + self.expect_node(mapping=True) + + def expect_flow_mapping_simple_value(self): + self.write_indicator(u':', False) + self.states.append(self.expect_flow_mapping_key) + self.expect_node(mapping=True) + + def expect_flow_mapping_value(self): + if self.canonical or self.column > self.best_width: + self.write_indent() + self.write_indicator(u':', True) + self.states.append(self.expect_flow_mapping_key) + self.expect_node(mapping=True) + + # Block sequence handlers. + + def expect_block_sequence(self): + indentless = (self.mapping_context and not self.indention) + self.increase_indent(flow=False, indentless=indentless) + self.state = self.expect_first_block_sequence_item + + def expect_first_block_sequence_item(self): + return self.expect_block_sequence_item(first=True) + + def expect_block_sequence_item(self, first=False): + if not first and isinstance(self.event, SequenceEndEvent): + self.indent = self.indents.pop() + self.state = self.states.pop() + else: + self.write_indent() + self.write_indicator(u'-', True, indention=True) + self.states.append(self.expect_block_sequence_item) + self.expect_node(sequence=True) + + # Block mapping handlers. + + def expect_block_mapping(self): + self.increase_indent(flow=False) + self.state = self.expect_first_block_mapping_key + + def expect_first_block_mapping_key(self): + return self.expect_block_mapping_key(first=True) + + def expect_block_mapping_key(self, first=False): + if not first and isinstance(self.event, MappingEndEvent): + self.indent = self.indents.pop() + self.state = self.states.pop() + else: + self.write_indent() + if self.check_simple_key(): + self.states.append(self.expect_block_mapping_simple_value) + self.expect_node(mapping=True, simple_key=True) + else: + self.write_indicator(u'?', True, indention=True) + self.states.append(self.expect_block_mapping_value) + self.expect_node(mapping=True) + + def expect_block_mapping_simple_value(self): + self.write_indicator(u':', False) + self.states.append(self.expect_block_mapping_key) + self.expect_node(mapping=True) + + def expect_block_mapping_value(self): + self.write_indent() + self.write_indicator(u':', True, indention=True) + self.states.append(self.expect_block_mapping_key) + self.expect_node(mapping=True) + + # Checkers. + + def check_empty_sequence(self): + return (isinstance(self.event, SequenceStartEvent) and self.events + and isinstance(self.events[0], SequenceEndEvent)) + + def check_empty_mapping(self): + return (isinstance(self.event, MappingStartEvent) and self.events + and isinstance(self.events[0], MappingEndEvent)) + + def check_empty_document(self): + if not isinstance(self.event, DocumentStartEvent) or not self.events: + return False + event = self.events[0] + return (isinstance(event, ScalarEvent) and event.anchor is None + and event.tag is None and event.implicit and event.value == u'') + + def check_simple_key(self): + length = 0 + if isinstance(self.event, NodeEvent) and self.event.anchor is not None: + if self.prepared_anchor is None: + self.prepared_anchor = self.prepare_anchor(self.event.anchor) + length += len(self.prepared_anchor) + if isinstance(self.event, (ScalarEvent, CollectionStartEvent)) \ + and self.event.tag is not None: + if self.prepared_tag is None: + self.prepared_tag = self.prepare_tag(self.event.tag) + length += len(self.prepared_tag) + if isinstance(self.event, ScalarEvent): + if self.analysis is None: + self.analysis = self.analyze_scalar(self.event.value) + length += len(self.analysis.scalar) + return (length < 128 and (isinstance(self.event, AliasEvent) + or (isinstance(self.event, ScalarEvent) + and not self.analysis.empty and not self.analysis.multiline) + or self.check_empty_sequence() or self.check_empty_mapping())) + + # Anchor, Tag, and Scalar processors. + + def process_anchor(self, indicator): + if self.event.anchor is None: + self.prepared_anchor = None + return + if self.prepared_anchor is None: + self.prepared_anchor = self.prepare_anchor(self.event.anchor) + if self.prepared_anchor: + self.write_indicator(indicator+self.prepared_anchor, True) + self.prepared_anchor = None + + def process_tag(self): + tag = self.event.tag + if isinstance(self.event, ScalarEvent): + if self.style is None: + self.style = self.choose_scalar_style() + if ((not self.canonical or tag is None) and + ((self.style == '' and self.event.implicit[0]) + or (self.style != '' and self.event.implicit[1]))): + self.prepared_tag = None + return + if self.event.implicit[0] and tag is None: + tag = u'!' + self.prepared_tag = None + else: + if (not self.canonical or tag is None) and self.event.implicit: + self.prepared_tag = None + return + if tag is None: + raise EmitterError("tag is not specified") + if self.prepared_tag is None: + self.prepared_tag = self.prepare_tag(tag) + if self.prepared_tag: + self.write_indicator(self.prepared_tag, True) + self.prepared_tag = None + + def choose_scalar_style(self): + if self.analysis is None: + self.analysis = self.analyze_scalar(self.event.value) + if self.event.style == '"' or self.canonical: + return '"' + if not self.event.style and self.event.implicit[0]: + if (not (self.simple_key_context and + (self.analysis.empty or self.analysis.multiline)) + and (self.flow_level and self.analysis.allow_flow_plain + or (not self.flow_level and self.analysis.allow_block_plain))): + return '' + if self.event.style and self.event.style in '|>': + if (not self.flow_level and not self.simple_key_context + and self.analysis.allow_block): + return self.event.style + if not self.event.style or self.event.style == '\'': + if (self.analysis.allow_single_quoted and + not (self.simple_key_context and self.analysis.multiline)): + return '\'' + return '"' + + def process_scalar(self): + if self.analysis is None: + self.analysis = self.analyze_scalar(self.event.value) + if self.style is None: + self.style = self.choose_scalar_style() + split = (not self.simple_key_context) + #if self.analysis.multiline and split \ + # and (not self.style or self.style in '\'\"'): + # self.write_indent() + if self.style == '"': + self.write_double_quoted(self.analysis.scalar, split) + elif self.style == '\'': + self.write_single_quoted(self.analysis.scalar, split) + elif self.style == '>': + self.write_folded(self.analysis.scalar) + elif self.style == '|': + self.write_literal(self.analysis.scalar) + else: + self.write_plain(self.analysis.scalar, split) + self.analysis = None + self.style = None + + # Analyzers. + + def prepare_version(self, version): + major, minor = version + if major != 1: + raise EmitterError("unsupported YAML version: %d.%d" % (major, minor)) + return u'%d.%d' % (major, minor) + + def prepare_tag_handle(self, handle): + if not handle: + raise EmitterError("tag handle must not be empty") + if handle[0] != u'!' or handle[-1] != u'!': + raise EmitterError("tag handle must start and end with '!': %r" + % (handle.encode('utf-8'))) + for ch in handle[1:-1]: + if not (u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z' \ + or ch in u'-_'): + raise EmitterError("invalid character %r in the tag handle: %r" + % (ch.encode('utf-8'), handle.encode('utf-8'))) + return handle + + def prepare_tag_prefix(self, prefix): + if not prefix: + raise EmitterError("tag prefix must not be empty") + chunks = [] + start = end = 0 + if prefix[0] == u'!': + end = 1 + while end < len(prefix): + ch = prefix[end] + if u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z' \ + or ch in u'-;/?!:@&=+$,_.~*\'()[]': + end += 1 + else: + if start < end: + chunks.append(prefix[start:end]) + start = end = end+1 + data = ch.encode('utf-8') + for ch in data: + chunks.append(u'%%%02X' % ord(ch)) + if start < end: + chunks.append(prefix[start:end]) + return u''.join(chunks) + + def prepare_tag(self, tag): + if not tag: + raise EmitterError("tag must not be empty") + if tag == u'!': + return tag + handle = None + suffix = tag + for prefix in self.tag_prefixes: + if tag.startswith(prefix) \ + and (prefix == u'!' or len(prefix) < len(tag)): + handle = self.tag_prefixes[prefix] + suffix = tag[len(prefix):] + chunks = [] + start = end = 0 + while end < len(suffix): + ch = suffix[end] + if u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z' \ + or ch in u'-;/?:@&=+$,_.~*\'()[]' \ + or (ch == u'!' and handle != u'!'): + end += 1 + else: + if start < end: + chunks.append(suffix[start:end]) + start = end = end+1 + data = ch.encode('utf-8') + for ch in data: + chunks.append(u'%%%02X' % ord(ch)) + if start < end: + chunks.append(suffix[start:end]) + suffix_text = u''.join(chunks) + if handle: + return u'%s%s' % (handle, suffix_text) + else: + return u'!<%s>' % suffix_text + + def prepare_anchor(self, anchor): + if not anchor: + raise EmitterError("anchor must not be empty") + for ch in anchor: + if not (u'0' <= ch <= u'9' or u'A' <= ch <= 'Z' or u'a' <= ch <= 'z' \ + or ch in u'-_'): + raise EmitterError("invalid character %r in the anchor: %r" + % (ch.encode('utf-8'), anchor.encode('utf-8'))) + return anchor + + def analyze_scalar(self, scalar): + + # Empty scalar is a special case. + if not scalar: + return ScalarAnalysis(scalar=scalar, empty=True, multiline=False, + allow_flow_plain=False, allow_block_plain=True, + allow_single_quoted=True, allow_double_quoted=True, + allow_block=False) + + # Indicators and special characters. + block_indicators = False + flow_indicators = False + line_breaks = False + special_characters = False + + # Whitespaces. + inline_spaces = False # non-space space+ non-space + inline_breaks = False # non-space break+ non-space + leading_spaces = False # ^ space+ (non-space | $) + leading_breaks = False # ^ break+ (non-space | $) + trailing_spaces = False # (^ | non-space) space+ $ + trailing_breaks = False # (^ | non-space) break+ $ + inline_breaks_spaces = False # non-space break+ space+ non-space + mixed_breaks_spaces = False # anything else + + # Check document indicators. + if scalar.startswith(u'---') or scalar.startswith(u'...'): + block_indicators = True + flow_indicators = True + + # First character or preceded by a whitespace. + preceeded_by_space = True + + # Last character or followed by a whitespace. + followed_by_space = (len(scalar) == 1 or + scalar[1] in u'\0 \t\r\n\x85\u2028\u2029') + + # The current series of whitespaces contain plain spaces. + spaces = False + + # The current series of whitespaces contain line breaks. + breaks = False + + # The current series of whitespaces contain a space followed by a + # break. + mixed = False + + # The current series of whitespaces start at the beginning of the + # scalar. + leading = False + + index = 0 + while index < len(scalar): + ch = scalar[index] + + # Check for indicators. + + if index == 0: + # Leading indicators are special characters. + if ch in u'#,[]{}&*!|>\'\"%@`': + flow_indicators = True + block_indicators = True + if ch in u'?:': + flow_indicators = True + if followed_by_space: + block_indicators = True + if ch == u'-' and followed_by_space: + flow_indicators = True + block_indicators = True + else: + # Some indicators cannot appear within a scalar as well. + if ch in u',?[]{}': + flow_indicators = True + if ch == u':': + flow_indicators = True + if followed_by_space: + block_indicators = True + if ch == u'#' and preceeded_by_space: + flow_indicators = True + block_indicators = True + + # Check for line breaks, special, and unicode characters. + + if ch in u'\n\x85\u2028\u2029': + line_breaks = True + if not (ch == u'\n' or u'\x20' <= ch <= u'\x7E'): + if (ch == u'\x85' or u'\xA0' <= ch <= u'\uD7FF' + or u'\uE000' <= ch <= u'\uFFFD') and ch != u'\uFEFF': + unicode_characters = True + if not self.allow_unicode: + special_characters = True + else: + special_characters = True + + # Spaces, line breaks, and how they are mixed. State machine. + + # Start or continue series of whitespaces. + if ch in u' \n\x85\u2028\u2029': + if spaces and breaks: + if ch != u' ': # break+ (space+ break+) => mixed + mixed = True + elif spaces: + if ch != u' ': # (space+ break+) => mixed + breaks = True + mixed = True + elif breaks: + if ch == u' ': # break+ space+ + spaces = True + else: + leading = (index == 0) + if ch == u' ': # space+ + spaces = True + else: # break+ + breaks = True + + # Series of whitespaces ended with a non-space. + elif spaces or breaks: + if leading: + if spaces and breaks: + mixed_breaks_spaces = True + elif spaces: + leading_spaces = True + elif breaks: + leading_breaks = True + else: + if mixed: + mixed_breaks_spaces = True + elif spaces and breaks: + inline_breaks_spaces = True + elif spaces: + inline_spaces = True + elif breaks: + inline_breaks = True + spaces = breaks = mixed = leading = False + + # Series of whitespaces reach the end. + if (spaces or breaks) and (index == len(scalar)-1): + if spaces and breaks: + mixed_breaks_spaces = True + elif spaces: + trailing_spaces = True + if leading: + leading_spaces = True + elif breaks: + trailing_breaks = True + if leading: + leading_breaks = True + spaces = breaks = mixed = leading = False + + # Prepare for the next character. + index += 1 + preceeded_by_space = (ch in u'\0 \t\r\n\x85\u2028\u2029') + followed_by_space = (index+1 >= len(scalar) or + scalar[index+1] in u'\0 \t\r\n\x85\u2028\u2029') + + # Let's decide what styles are allowed. + allow_flow_plain = True + allow_block_plain = True + allow_single_quoted = True + allow_double_quoted = True + allow_block = True + + # Leading and trailing whitespace are bad for plain scalars. We also + # do not want to mess with leading whitespaces for block scalars. + if leading_spaces or leading_breaks or trailing_spaces: + allow_flow_plain = allow_block_plain = allow_block = False + + # Trailing breaks are fine for block scalars, but unacceptable for + # plain scalars. + if trailing_breaks: + allow_flow_plain = allow_block_plain = False + + # The combination of (space+ break+) is only acceptable for block + # scalars. + if inline_breaks_spaces: + allow_flow_plain = allow_block_plain = allow_single_quoted = False + + # Mixed spaces and breaks, as well as special character are only + # allowed for double quoted scalars. + if mixed_breaks_spaces or special_characters: + allow_flow_plain = allow_block_plain = \ + allow_single_quoted = allow_block = False + + # We don't emit multiline plain scalars. + if line_breaks: + allow_flow_plain = allow_block_plain = False + + # Flow indicators are forbidden for flow plain scalars. + if flow_indicators: + allow_flow_plain = False + + # Block indicators are forbidden for block plain scalars. + if block_indicators: + allow_block_plain = False + + return ScalarAnalysis(scalar=scalar, + empty=False, multiline=line_breaks, + allow_flow_plain=allow_flow_plain, + allow_block_plain=allow_block_plain, + allow_single_quoted=allow_single_quoted, + allow_double_quoted=allow_double_quoted, + allow_block=allow_block) + + # Writers. + + def flush_stream(self): + if hasattr(self.stream, 'flush'): + self.stream.flush() + + def write_stream_start(self): + # Write BOM if needed. + if self.encoding and self.encoding.startswith('utf-16'): + self.stream.write(u'\xFF\xFE'.encode(self.encoding)) + + def write_stream_end(self): + self.flush_stream() + + def write_indicator(self, indicator, need_whitespace, + whitespace=False, indention=False): + if self.whitespace or not need_whitespace: + data = indicator + else: + data = u' '+indicator + self.whitespace = whitespace + self.indention = self.indention and indention + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + + def write_indent(self): + indent = self.indent or 0 + if not self.indention or self.column > indent \ + or (self.column == indent and not self.whitespace): + self.write_line_break() + if self.column < indent: + self.whitespace = True + data = u' '*(indent-self.column) + self.column = indent + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + + def write_line_break(self, data=None): + if data is None: + data = self.best_line_break + self.whitespace = True + self.indention = True + self.line += 1 + self.column = 0 + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + + def write_version_directive(self, version_text): + data = u'%%YAML %s' % version_text + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + self.write_line_break() + + def write_tag_directive(self, handle_text, prefix_text): + data = u'%%TAG %s %s' % (handle_text, prefix_text) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + self.write_line_break() + + # Scalar streams. + + def write_single_quoted(self, text, split=True): + self.write_indicator(u'\'', True) + spaces = False + breaks = False + start = end = 0 + while end <= len(text): + ch = None + if end < len(text): + ch = text[end] + if spaces: + if ch is None or ch != u' ': + if start+1 == end and self.column > self.best_width and split \ + and start != 0 and end != len(text): + self.write_indent() + else: + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + elif breaks: + if ch is None or ch not in u'\n\x85\u2028\u2029': + if text[start] == u'\n': + self.write_line_break() + for br in text[start:end]: + if br == u'\n': + self.write_line_break() + else: + self.write_line_break(br) + self.write_indent() + start = end + else: + if ch is None or ch in u' \n\x85\u2028\u2029' or ch == u'\'': + if start < end: + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + if ch == u'\'': + data = u'\'\'' + self.column += 2 + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + 1 + if ch is not None: + spaces = (ch == u' ') + breaks = (ch in u'\n\x85\u2028\u2029') + end += 1 + self.write_indicator(u'\'', False) + + ESCAPE_REPLACEMENTS = { + u'\0': u'0', + u'\x07': u'a', + u'\x08': u'b', + u'\x09': u't', + u'\x0A': u'n', + u'\x0B': u'v', + u'\x0C': u'f', + u'\x0D': u'r', + u'\x1B': u'e', + u'\"': u'\"', + u'\\': u'\\', + u'\x85': u'N', + u'\xA0': u'_', + u'\u2028': u'L', + u'\u2029': u'P', + } + + def write_double_quoted(self, text, split=True): + self.write_indicator(u'"', True) + start = end = 0 + while end <= len(text): + ch = None + if end < len(text): + ch = text[end] + if ch is None or ch in u'"\\\x85\u2028\u2029\uFEFF' \ + or not (u'\x20' <= ch <= u'\x7E' + or (self.allow_unicode + and (u'\xA0' <= ch <= u'\uD7FF' + or u'\uE000' <= ch <= u'\uFFFD'))): + if start < end: + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + if ch is not None: + if ch in self.ESCAPE_REPLACEMENTS: + data = u'\\'+self.ESCAPE_REPLACEMENTS[ch] + elif ch <= u'\xFF': + data = u'\\x%02X' % ord(ch) + elif ch <= u'\uFFFF': + data = u'\\u%04X' % ord(ch) + else: + data = u'\\U%08X' % ord(ch) + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end+1 + if 0 < end < len(text)-1 and (ch == u' ' or start >= end) \ + and self.column+(end-start) > self.best_width and split: + data = text[start:end]+u'\\' + if start < end: + start = end + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + self.write_indent() + self.whitespace = False + self.indention = False + if text[start] == u' ': + data = u'\\' + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + end += 1 + self.write_indicator(u'"', False) + + def determine_chomp(self, text): + tail = text[-2:] + while len(tail) < 2: + tail = u' '+tail + if tail[-1] in u'\n\x85\u2028\u2029': + if tail[-2] in u'\n\x85\u2028\u2029': + return u'+' + else: + return u'' + else: + return u'-' + + def write_folded(self, text): + chomp = self.determine_chomp(text) + self.write_indicator(u'>'+chomp, True) + self.write_indent() + leading_space = False + spaces = False + breaks = False + start = end = 0 + while end <= len(text): + ch = None + if end < len(text): + ch = text[end] + if breaks: + if ch is None or ch not in u'\n\x85\u2028\u2029': + if not leading_space and ch is not None and ch != u' ' \ + and text[start] == u'\n': + self.write_line_break() + leading_space = (ch == u' ') + for br in text[start:end]: + if br == u'\n': + self.write_line_break() + else: + self.write_line_break(br) + if ch is not None: + self.write_indent() + start = end + elif spaces: + if ch != u' ': + if start+1 == end and self.column > self.best_width: + self.write_indent() + else: + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + else: + if ch is None or ch in u' \n\x85\u2028\u2029': + data = text[start:end] + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + if ch is None: + self.write_line_break() + start = end + if ch is not None: + breaks = (ch in u'\n\x85\u2028\u2029') + spaces = (ch == u' ') + end += 1 + + def write_literal(self, text): + chomp = self.determine_chomp(text) + self.write_indicator(u'|'+chomp, True) + self.write_indent() + breaks = False + start = end = 0 + while end <= len(text): + ch = None + if end < len(text): + ch = text[end] + if breaks: + if ch is None or ch not in u'\n\x85\u2028\u2029': + for br in text[start:end]: + if br == u'\n': + self.write_line_break() + else: + self.write_line_break(br) + if ch is not None: + self.write_indent() + start = end + else: + if ch is None or ch in u'\n\x85\u2028\u2029': + data = text[start:end] + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + if ch is None: + self.write_line_break() + start = end + if ch is not None: + breaks = (ch in u'\n\x85\u2028\u2029') + end += 1 + + def write_plain(self, text, split=True): + if not text: + return + if not self.whitespace: + data = u' ' + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + self.writespace = False + self.indention = False + spaces = False + breaks = False + start = end = 0 + while end <= len(text): + ch = None + if end < len(text): + ch = text[end] + if spaces: + if ch != u' ': + if start+1 == end and self.column > self.best_width and split: + self.write_indent() + self.writespace = False + self.indention = False + else: + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + elif breaks: + if ch not in u'\n\x85\u2028\u2029': + if text[start] == u'\n': + self.write_line_break() + for br in text[start:end]: + if br == u'\n': + self.write_line_break() + else: + self.write_line_break(br) + self.write_indent() + self.whitespace = False + self.indention = False + start = end + else: + if ch is None or ch in u' \n\x85\u2028\u2029': + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + if ch is not None: + spaces = (ch == u' ') + breaks = (ch in u'\n\x85\u2028\u2029') + end += 1 + Index: /pyyaml/tags/3.04/setup.py =================================================================== --- /pyyaml/tags/3.04/setup.py (revision 232) +++ /pyyaml/tags/3.04/setup.py (revision 232) @@ -0,0 +1,53 @@ + +NAME = 'PyYAML' +VERSION = '3.04' +DESCRIPTION = "YAML parser and emitter for Python" +LONG_DESCRIPTION = """\ +YAML is a data serialization format designed for human readability and +interaction with scripting languages. PyYAML is a YAML parser and +emitter for Python. + +PyYAML features a complete YAML 1.1 parser, Unicode support, pickle +support, capable extension API, and sensible error messages. PyYAML +supports standard YAML tags and provides Python-specific tags that allow +to represent an arbitrary Python object. + +PyYAML is applicable for a broad range of tasks from complex +configuration files to object serialization and persistance.""" +AUTHOR = "Kirill Simonov" +AUTHOR_EMAIL = 'xi@resolvent.net' +LICENSE = "MIT" +PLATFORMS = "Any" +URL = "http://pyyaml.org/wiki/PyYAML" +DOWNLOAD_URL = "http://pyyaml.org/download/pyyaml/%s-%s.tar.gz" % (NAME, VERSION) +CLASSIFIERS = [ + "Development Status :: 4 - Beta", + "Intended Audience :: Developers", + "License :: OSI Approved :: MIT License", + "Operating System :: OS Independent", + "Programming Language :: Python", + "Topic :: Software Development :: Libraries :: Python Modules", + "Topic :: Text Processing :: Markup", +] + +from distutils.core import setup + +if __name__ == '__main__': + + setup( + name=NAME, + version=VERSION, + description=DESCRIPTION, + long_description=LONG_DESCRIPTION, + author=AUTHOR, + author_email=AUTHOR_EMAIL, + license=LICENSE, + platforms=PLATFORMS, + url=URL, + download_url=DOWNLOAD_URL, + classifiers=CLASSIFIERS, + + package_dir={'': 'lib'}, + packages=['yaml'], + ) +