Changeset 25


Ignore:
Timestamp:
08/25/05 01:30:06 (8 years ago)
Author:
xi
Message:

Adding some docstrings.

Location:
trunk
Files:
7 edited
2 copied

Legend:

Unmodified
Added
Removed

  • trunk/ext/_syckmodule.c

    r20 r25  
    4343PyDoc_STRVAR(PySyckNode_doc, 
    4444    "_syck.Node() -> TypeError\n\n" 
    45     "_syck.Node is an abstract type. It is a base type for _syck.Scalar,\n" 
     45    "_syck.Node is an abstract type. It is the base type for _syck.Scalar,\n" 
    4646    "_syck.Seq, and _syck.Map. You cannot create an instance of _syck.Node\n" 
    4747    "directly. You may use _syck.Node for type checking or subclassing.\n"); 
    … …  
    220220    "      -> a Scalar node\n\n" 
    221221    "_syck.Scalar represents a scalar node in Syck parser and emitter\n" 
    222     "graphs. A scalar node points to a single string value.\n"); 
     222    "trees. A scalar node points to a single string value.\n"); 
    223223 
    224224typedef struct { 
    … …  
    549549    "Seq(value=[], tag=None, inline=False) -> a Seq node\n\n" 
    550550    "_syck.Seq represents a sequence node in Syck parser and emitter\n" 
    551     "graphs. A sequence node points to an ordered set of subnodes.\n"); 
     551    "trees. A sequence node points to an ordered set of subnodes.\n"); 
    552552 
    553553typedef struct { 
    … …  
    718718 
    719719PyDoc_STRVAR(PySyckMap_doc, 
    720     "Map(value='', tag=None, inline=False) -> a Map node\n\n" 
     720    "Map(value={}, tag=None, inline=False) -> a Map node\n\n" 
    721721    "_syck.Map represents a mapping node in Syck parser and emitter\n" 
    722     "graphs. A mapping node points to an unordered collections of pairs.\n"); 
     722    "trees. A mapping node points to an unordered collections of pairs.\n"); 
    723723 
    724724typedef struct { 
    … …  
    833833        PyDoc_STR("the node kind, always 'map', read-only"), &PySyck_MapKind}, 
    834834    {"value", (getter)PySyckNode_getvalue, (setter)PySyckMap_setvalue, 
    835         PyDoc_STR("the node value, a mapping"), NULL}, 
     835        PyDoc_STR("the node value, a list of pairs or a dictionary"), NULL}, 
    836836    {"tag", (getter)PySyckNode_gettag, (setter)PySyckNode_settag, 
    837837        PyDoc_STR("the node tag, a string or None"), NULL}, 
    … …  
    893893    "      -> a Parser object\n\n" 
    894894    "_syck.Parser is a low-lever wrapper of the Syck parser. It parses\n" 
    895     "a YAML stream and produces a graph of Nodes.\n"); 
     895    "a YAML stream and produces a tree of Nodes.\n"); 
    896896 
    897897typedef struct { 
    … …  
    10171017static PyGetSetDef PySyckParser_getsetters[] = { 
    10181018    {"source", (getter)PySyckParser_getsource, NULL, 
    1019         PyDoc_STR("IO source, a string or file-like object"), NULL}, 
     1019        PyDoc_STR("IO source, a string or a file-like object"), NULL}, 
    10201020    {"implicit_typing", (getter)PySyckParser_getimplicit_typing, NULL, 
    10211021        PyDoc_STR("implicit typing of builtin YAML types"), NULL}, 
    … …  
    12531253 
    12541254    if (self->parsing) { 
    1255         PyErr_SetString(PyExc_RuntimeError, "do not call Parser.parse while it is already parsing"); 
     1255        PyErr_SetString(PyExc_RuntimeError, 
     1256                "do not call Parser.parse while it is already running"); 
    12561257        return NULL; 
    12571258    } 
    … …  
    12921293PyDoc_STRVAR(PySyckParser_parse_doc, 
    12931294    "parse() -> the root Node object\n\n" 
    1294     "Parses the source and returns the next document. On EOF, returns None\n" 
    1295     "and sets the 'eof' attribute on.\n"); 
     1295    "Parses the source and returns the root of the Node tree. Call it\n" 
     1296    "several times to retrieve all documents from the source. On EOF,\n" 
     1297    "returns None and sets the 'eof' attribute on.\n"); 
    12961298 
    12971299static PyMethodDef PySyckParser_methods[] = { 
    … …  
    13481350 
    13491351PyDoc_STRVAR(PySyckEmitter_doc, 
    1350     "Emitter(output, headless=False, use_header=True, explicit_typing=True," 
    1351     "        style=None, best_width=80, indent=2) -> an Emitter object\n\n" 
    1352     "_syck.Emitter is a low-lever wrapper of the Syck emitter. It emit\n" 
     1352    "Emitter(output, headless=False, use_header=False, use_version=False,\n" 
     1353    "        explicit_typing=True, style=None, best_width=80, indent=2)\n" 
     1354    "                -> an Emitter object\n\n" 
     1355    "_syck.Emitter is a low-lever wrapper of the Syck emitter. It emits\n" 
    13531356    "a tree of Nodes into a YAML stream.\n"); 
    13541357 
    … …  
    15301533        PyDoc_STR("headerless document flag"), NULL}, 
    15311534    {"use_header", (getter)PySyckEmitter_getuse_header, NULL, 
    1532         PyDoc_STR("force header"), NULL}, 
     1535        PyDoc_STR("force header flag"), NULL}, 
    15331536    {"use_version", (getter)PySyckEmitter_getuse_version, NULL, 
    1534         PyDoc_STR("force version"), NULL}, 
     1537        PyDoc_STR("force version flag"), NULL}, 
    15351538    {"explicit_typing", (getter)PySyckEmitter_getexplicit_typing, NULL, 
    15361539        PyDoc_STR("explicit typing for all collections"), NULL}, 
    … …  
    17521755    Py_INCREF(output); 
    17531756    self->output = output; 
    1754  
    1755 /* 
    1756     self->emitter = syck_new_emitter(); 
    1757     self->emitter->bonus = self; 
    1758     self->emitter->headless = self->headless; 
    1759     self->emitter->use_header = use_header; 
    1760     self->emitter->use_version = use_version; 
    1761     self->emitter->explicit_typing = explicit_typing; 
    1762     self->emitter->style = self->style; 
    1763     self->emitter->best_width = self->best_width; 
    1764     self->emitter->indent = self->indent; 
    1765  
    1766     syck_emitter_handler(self->emitter, PySyckEmitter_node_handler); 
    1767     syck_output_handler(self->emitter, PySyckEmitter_write_handler); 
    1768 */ 
    17691757 
    17701758    self->emitting = 0; 
    … …  
    19741962PyDoc_STRVAR(PySyckEmitter_emit_doc, 
    19751963    "emit(root_node) -> None\n\n" 
    1976     "Emit the Node tree to the output.\n"); 
     1964    "Emits the Node tree to the output.\n"); 
    19771965 
    19781966static PyMethodDef PySyckEmitter_methods[] = { 
    … …  
    20332021 
    20342022PyDoc_STRVAR(PySyck_doc, 
    2035     "low-level wrapper for the Syck YAML parser and emitter"); 
     2023    "_syck is a low-level wrapper for the Syck YAML parser and emitter.\n" 
     2024    "Do not use it directly, use the module 'syck' instead.\n"); 
     2025 
     2026static int 
     2027add_slotnames(PyTypeObject *type) 
     2028{ 
     2029    PyObject *slotnames; 
     2030    PyObject *name; 
     2031    PyGetSetDef *getsetter; 
     2032 
     2033    if (!type->tp_getset) return 0; 
     2034    if (!type->tp_dict) return 0; 
     2035 
     2036    slotnames = PyList_New(0); 
     2037    if (!slotnames) return -1; 
     2038 
     2039    for (getsetter = type->tp_getset; getsetter->name; getsetter++) { 
     2040        if (!getsetter->set) continue; 
     2041        name = PyString_FromString(getsetter->name); 
     2042        if (!name) { 
     2043           Py_DECREF(slotnames); 
     2044           return -1; 
     2045        } 
     2046        if (PyList_Append(slotnames, name) < 0) { 
     2047            Py_DECREF(name); 
     2048            Py_DECREF(slotnames); 
     2049            return -1; 
     2050        } 
     2051        Py_DECREF(name); 
     2052    } 
     2053 
     2054    if (PyDict_SetItemString(type->tp_dict, "__slotnames__", slotnames) < 0) { 
     2055        Py_DECREF(slotnames); 
     2056        return -1; 
     2057    } 
     2058 
     2059    Py_DECREF(slotnames); 
     2060    return 0; 
     2061} 
    20362062 
    20372063PyMODINIT_FUNC 
    … …  
    20442070    if (PyType_Ready(&PySyckScalar_Type) < 0) 
    20452071        return; 
     2072    if (add_slotnames(&PySyckScalar_Type) < 0) 
     2073        return; 
    20462074    if (PyType_Ready(&PySyckSeq_Type) < 0) 
    20472075        return; 
     2076    if (add_slotnames(&PySyckSeq_Type) < 0) 
     2077        return; 
    20482078    if (PyType_Ready(&PySyckMap_Type) < 0) 
     2079        return; 
     2080    if (add_slotnames(&PySyckMap_Type) < 0) 
    20492081        return; 
    20502082    if (PyType_Ready(&PySyckParser_Type) < 0) 

  • trunk/lib/syck/__init__.py

    r19 r25  
     1""" 
     2YAML is a data serialization format designed for human readability and 
     3interaction with scripting languages. 
     4 
     5Syck is an extension for reading and writing YAML in scripting languages. 
     6 
     7PySyck provides Python bindings for Syck YAML parser and emitter. 
     8 
     9To start working with PySyck, import the package 'syck': 
     10>>> from syck import * 
     11 
     12To parse a YAML document into a Python object, use the function 'load()': 
     13>>> load(''' 
     14... - Mark McGwire 
     15... - Sammy Sosa 
     16... - Ken Griffey 
     17... ''') 
     18['Mark McGwire', 'Sammy Sosa', 'Ken Griffey'] 
     19 
     20To emit a Python object into a YAML document, use the function 'dump()': 
     21>>> print dump(['Mark McGwire', 'Sammy Sosa', 'Ken Griffey']) 
     22--- 
     23- Mark McGwire 
     24- Sammy Sosa 
     25- Ken Griffey 
     26 
     27You may get access to the YAML parser tree using the function 'parse()': 
     28>>> root_node = parse(''' 
     29... - Mark McGwire 
     30... - Sammy Sosa 
     31... - Ken Griffey 
     32... ''') 
     33>>> root_node 
     34<_syck.Seq object at 0xb7a1f874> 
     35>>> root_node.kind 
     36'seq' 
     37>>> root_node.value 
     38[<_syck.Scalar object at 0xb7a1e5fc>, <_syck.Scalar object at 0xb7a1e65c>, <_syck.Scalar object at 0xb7a1e6bc>] 
     39 
     40You may now use the function 'emit()' to obtain the YAML document again: 
     41>>> print emit(root_node) 
     42--- 
     43- Mark McGwire 
     44- Sammy Sosa 
     45- Ken Griffey 
     46 
     47What do you get if you apply the function 'dump()' to root_node? Let's try it: 
     48>>> print dump(root_node) 
     49--- !python/object:_syck.Seq 
     50value: 
     51- !python/object:_syck.Scalar 
     52  value: Mark McGwire 
     53  tag: tag:yaml.org,2002:str 
     54- !python/object:_syck.Scalar 
     55  value: Sammy Sosa 
     56  tag: tag:yaml.org,2002:str 
     57- !python/object:_syck.Scalar 
     58  value: Ken Griffey 
     59  tag: tag:yaml.org,2002:str 
     60 
     61As you can see, PySyck allow you to represent complex Python objects. 
     62 
     63You can also dump the generated YAML output into any file-like object: 
     64>>> import os 
     65>>> stream = os.tmpfile() 
     66>>> object = ['foo', 'bar', ['baz']] 
     67>>> dump(object, stream) 
     68>>> stream.seek(0) 
     69>>> print stream.read() 
     70--- 
     71- foo 
     72- bar 
     73- - baz 
     74 
     75To load several documents from a single YAML stream, use the function 
     76'load_documents()': 
     77>>> source = ''' 
     78... --- 
     79... american: 
     80...   - Boston Red Sox 
     81...   - Detroit Tigers 
     82...   - New York Yankees 
     83... national: 
     84...   - New York Mets 
     85...   - Chicago Cubs 
     86...   - Atlanta Braves 
     87... --- 
     88... - [name        , hr, avg  ] 
     89... - [Mark McGwire, 65, 0.278] 
     90... - [Sammy Sosa  , 63, 0.288] 
     91... ''' 
     92>>> for document in load_documents(source): 
     93...     print document 
     94... 
     95{'national': ['New York Mets', 'Chicago Cubs', 'Atlanta Braves'], 'american': ['Boston Red Sox', 'Detroit Tigers', 'New York Yankees']} 
     96[['name', 'hr', 'avg'], ['Mark McGwire', 65, 0.27800000000000002], ['Sammy Sosa', 63, 0.28799999999999998]] 
     97 
     98See the source code for more details. 
     99""" 
     100 
    1101 
    2102from _syck import * 

  • trunk/lib/syck/dumpers.py

    r24 r25  
     1""" 
     2syck.dumpers is a high-level wrapper for the Syck YAML emitter. 
     3Do not use it directly, use the module 'syck' instead. 
     4""" 
    15 
    26import _syck 
    … …  
    1014    'emit', 'dump', 'emit_documents', 'dump_documents'] 
    1115 
    12 INF = 1e300000 
    13 NEGINF = -INF 
    14 NAN = INF/INF 
    15  
    16  
    1716class GenericDumper(_syck.Emitter): 
     17    """ 
     18    GenericDumper dumps native Python objects into YAML documents. 
     19    """ 
    1820 
    1921    def dump(self, object): 
     22        """Dumps the given Python object as a YAML document.""" 
    2023        self.emit(self._convert(object, {})) 
    2124 
    … …  
    3033                node.value[index] = self._convert(item, object_to_node) 
    3134        elif node.kind == 'map': 
    32             for key in node.value.keys(): 
    33                 value = node.value[key] 
    34                 del node.value[key] 
    35                 node.value[self._convert(key, object_to_node)] =    \ 
    36                         self._convert(value, object_to_node) 
     35            if isinstance(node.value, dict): 
     36                for key in node.value.keys(): 
     37                    value = node.value[key] 
     38                    del node.value[key] 
     39                    node.value[self._convert(key, object_to_node)] =    \ 
     40                            self._convert(value, object_to_node) 
     41            elif isinstance(node.value, list): 
     42                for index in range(len(node.value)): 
     43                    key, value = node.value[index] 
     44                    node.value[index] = (self._convert(key, object_to_node), 
     45                            self._convert(value, object_to_node)) 
    3746#        # Workaround against a Syck bug: 
    3847#        if node.kind == 'scalar' and node.style not in ['1quote', '2quote'] \ 
    … …  
    4251 
    4352    def represent(self, object): 
     53        """Represents the given Python object as a 'Node'.""" 
    4454        if isinstance(object, dict): 
    4555            return _syck.Map(object.copy(), tag="tag:yaml.org,2002:map") 
    … …  
    5060 
    5161    def allow_aliases(self, object): 
     62        """Checks whether the given object can be aliased.""" 
    5263        return True 
    5364 
    5465class Dumper(GenericDumper): 
    55  
    56     def __init__(self, *args, **kwds): 
    57         super(Dumper, self).__init__(*args, **kwds) 
     66    """ 
     67    Dumper dumps native Python objects into YAML documents. 
     68    """ 
     69 
     70    INF = 1e300000 
     71    inf_value = repr(INF) 
     72    neginf_value = repr(-INF) 
     73    nan_value = repr(INF/INF) 
    5874 
    5975    def find_representer(self, object): 
     76        """ 
     77        For the given object, find a method that can represent it as a 'Node' 
     78        object. 
     79 
     80        If the type of the object has the form 'package.module.type', 
     81        find_representer() returns the method 'represent_package_module_type'. 
     82        If this method does not exist, it checks the base types. 
     83        """ 
    6084        for object_type in type(object).__mro__: 
    6185            if object_type.__module__ == '__builtin__': 
    … …  
    6892 
    6993    def represent(self, object): 
     94        """Represents the given Python object as a 'Node'.""" 
    7095        representer = self.find_representer(object) 
    7196        if representer: 
    … …  
    97122    def represent_float(self, object): 
    98123        value = repr(object) 
    99         if value == repr(INF): 
     124        if value == self.inf_value: 
    100125            value = '.inf' 
    101         elif value == repr(NEGINF): 
     126        elif value == self.neginf_value: 
    102127            value = '-.inf' 
    103         elif value == repr(NAN): 
     128        elif value == self.nan_value: 
    104129            value = '.nan' 
    105130        return _syck.Scalar(value, tag="tag:yaml.org,2002:float") 
    … …  
    107132    def represent_sets_Set(self, object): 
    108133        return _syck.Seq(list(object), tag="tag:yaml.org,2002:set") 
     134    represent_set = represent_sets_Set 
    109135 
    110136    def represent_datetime_datetime(self, object): 
    … …  
    121147 
    122148    def represent_type(self, object): 
    123         # TODO: Python 2.2 does not provide the module name of a function 
    124149        name = '%s.%s' % (object.__module__, object.__name__) 
    125150        return _syck.Scalar('', tag="tag:python.yaml.org,2002:name:"+name) 
    126151    represent_classobj = represent_type 
    127152    represent_class = represent_type 
     153    # TODO: Python 2.2 does not provide the module name of a function 
    128154    represent_function = represent_type 
    129155    represent_builtin_function_or_method = represent_type 
    … …  
    200226                    tag="tag:python.yaml.org,2002:apply:"+class_name) 
    201227 
     228    def represent__syck_Node(self, object): 
     229        object_type = type(object) 
     230        type_name = '%s.%s' % (object_type.__module__, object_type.__name__) 
     231        state = [] 
     232        if hasattr(object_type, '__slotnames__'): 
     233            for name in object_type.__slotnames__: 
     234                value = getattr(object, name) 
     235                if value: 
     236                    state.append((name, value)) 
     237        return _syck.Map(state, 
     238                tag="tag:python.yaml.org,2002:object:"+type_name) 
     239 
    202240    def allow_aliases(self, object): 
     241        """Checks whether the given object can be aliased.""" 
    203242        if object is None or type(object) in [int, bool, float]: 
    204243            return False 
    … …  
    210249 
    211250def emit(node, output=None, Dumper=Dumper, **parameters): 
     251    """ 
     252    Emits the given node to the output. 
     253 
     254    If output is None, returns the produced YAML document. 
     255    """ 
    212256    if output is None: 
    213257        dumper = Dumper(StringIO.StringIO(), **parameters) 
    … …  
    219263 
    220264def dump(object, output=None, Dumper=Dumper, **parameters): 
     265    """ 
     266    Dumps the given object to the output. 
     267 
     268    If output is None, returns the produced YAML document. 
     269    """ 
    221270    if output is None: 
    222271        dumper = Dumper(StringIO.StringIO(), **parameters) 
    … …  
    228277 
    229278def emit_documents(nodes, output=None, Dumper=Dumper, **parameters): 
     279    """ 
     280    Emits the list of nodes to the output. 
     281     
     282    If output is None, returns the produced YAML document. 
     283    """ 
    230284    if output is None: 
    231285        dumper = Dumper(StringIO.StringIO(), **parameters) 
    … …  
    238292 
    239293def dump_documents(objects, output=None, Dumper=Dumper, **parameters): 
     294    """ 
     295    Dumps the list of objects to the output. 
     296     
     297    If output is None, returns the produced YAML document. 
     298    """ 
    240299    if output is None: 
    241300        dumper = Dumper(StringIO.StringIO(), **parameters) 

  • trunk/lib/syck/loaders.py

    r22 r25  
     1""" 
     2syck.loaders is a high-level wrapper for the Syck YAML parser. 
     3Do not use it directly, use the module 'syck' instead. 
     4""" 
    15 
    26# Python 2.2 compatibility 
    … …  
    2731 
    2832class GenericLoader(_syck.Parser): 
     33    """ 
     34    GenericLoader constructs primitive Python objects from YAML documents. 
     35    """ 
    2936 
    3037    def load(self): 
     38        """ 
     39        Loads a YAML document from the source and return a native Python 
     40        object. On EOF, returns None and set the eof attribute on. 
     41        """ 
    3142        node = self.parse() 
    3243        if self.eof: 
    … …  
    7182 
    7283    def construct(self, node): 
     84        """Constructs a Python object by the given node.""" 
    7385        return node.value 
    7486 
    7587class Merge: 
     88    """Represents the merge key '<<'.""" 
    7689    pass 
    7790 
    7891class Default: 
     92    """Represents the default key '='.""" 
    7993    pass 
    8094 
    8195class Loader(GenericLoader): 
     96    """ 
     97    Loader constructs native Python objects from YAML documents. 
     98    """ 
    8299 
    83100    inf_value = 1e300000 
    … …  
    109126 
    110127    def find_constructor(self, node): 
     128        """ 
     129        Returns the contructor for generating a Python object for the given 
     130        node. 
     131 
     132        The node tags are mapped to constructors by the following rule: 
     133 
     134        Tag                             Constructor 
     135        ---                             ----------- 
     136        tag:yaml.org,2002:type          construct_type 
     137        tag:python.yaml.org,2002:type   construct_python_type 
     138        x-private:type                  construct_private_type 
     139        tag:domain.tld,2002:type        construct_domain_tld_2002_type 
     140 
     141        See the method code for more details. 
     142        """ 
    111143        parts = [] 
    112144        if node.tag: 
    … …  
    130162 
    131163    def construct(self, node): 
     164        """Constructs a Python object by the given node.""" 
    132165        if node.kind == 'map' and self.merge_key in node.value: 
    133166            self.merge_maps(node) 
    … …  
    301334            if isinstance(state, tuple) and len(state) == 2: 
    302335                state, slotstate = state 
    303             object.__dict__.update(state) 
     336            if hasattr(object, '__dict__'): 
     337                object.__dict__.update(state) 
     338            elif state: 
     339                slotstate.update(state) 
    304340            for key, value in slotstate.items(): 
    305341                setattr(object, key, value) 
    … …  
    349385 
    350386def parse_documents(source, Loader=Loader, **parameters): 
    351     """Iterates over 'source' and yields the root node of each document.""" 
     387    """Iterates over 'source' and yields the root 'Node' for each document.""" 
    352388    loader = Loader(source, **parameters) 
    353389    while True: 
    … …  
    358394 
    359395def load_documents(source, Loader=Loader, **parameters): 
    360     """Iterates over 'source' and yields the root object of each document.""" 
     396    """Iterates over 'source' and yields the root object for each document.""" 
    361397    loader = Loader(source, **parameters) 
    362398    while True: 

  • trunk/sandbox/emit-it/Makefile

    r11 r25  
     1 
     2ALL = emit-it complex-key-bug trailing-space-bug 
    13 
    24.PHONY: default clean 
    35 
    4 default: emit-it 
     6default: $(ALL) 
    57 
    68clean: 
    7         rm -f emit-it 
    8         rm -f emit-it.o 
     9        rm -f *.o 
     10        rm -f $(ALL) 
    911 
    10 emit-it: emit-it.o 
    11         gcc emit-it.o -o emit-it -lsyck -L${HOME}/lib -Wall -Wstrict-prototypes 
     12%.o: %.c 
     13        gcc -c $< -o $@ -Wall -Wstrict-prototypes -I${HOME}/include 
    1214 
    13 emit-it.o: emit-it.c 
    14         gcc -c emit-it.c -o emit-it.o -I${HOME}/include 
    15  
     15$(ALL): %: %.o 
     16        gcc $< -o $@ -lsyck -L${HOME}/lib -Wall -Wstrict-prototypes 

  • trunk/sandbox/emit-it/complex-key-bug.c

    r17 r25  
    11 
    2 #include <stdlib.h> 
    32#include <stdio.h> 
    4 #include <stdarg.h> 
    5 #include <error.h> 
    6 #include <string.h> 
    73 
    84#include <syck.h> 
    … …  
    1612{ 
    1713    switch (id) { 
     14 
    1815        case 1: 
    19             syck_emit_seq(e, "tag:domainmyseq.tld,2002:zz", seq_none); 
     16            syck_emit_map(e, NULL, map_none); 
    2017            syck_emit_item(e, 2); 
    2118            syck_emit_item(e, 3); 
    22             syck_emit_item(e, 4); 
    23 /*            syck_emit_item(e, 2); 
    24             syck_emit_item(e, 1);*/ 
    2519            syck_emit_end(e); 
    2620            break; 
     21 
    2722        case 2: 
    28             syck_emit_scalar(e, "tag:yaml.org,2002:str", scalar_none, 0, 0, 0, "Mark McGwire ", strlen("Mark McGwire ")); 
     23            syck_emit_map(e, "x-private:key", map_none); 
     24            syck_emit_item(e, 4); 
     25            syck_emit_item(e, 5); 
     26            syck_emit_end(e); 
    2927            break; 
     28 
    3029        case 3: 
    31             syck_emit_scalar(e, "tag:python.yaml.org,2002:object", scalar_none, 0, 0, 0, "Sammy Sosa", strlen("Sammy Sosa")); 
    32             break; 
    3330        case 4: 
    34             syck_emit_scalar(e, "x-private:myowntype", scalar_none, 0, 0, 0, "Ken Griffey", strlen("Ken Griffey")); 
     31        case 5: 
     32            syck_emit_scalar(e, NULL, scalar_none, 0, 0, 0, "foo", 3); 
    3533            break; 
    3634    } 
     35         
    3736} 
    3837 
    … …  
    4847    syck_emitter_mark_node(e, 3); 
    4948    syck_emitter_mark_node(e, 4); 
    50 /*    syck_emitter_mark_node(e, 2); 
    51     syck_emitter_mark_node(e, 1);*/ 
     49    syck_emitter_mark_node(e, 5); 
    5250    syck_emit(e, 1); 
    5351    syck_emitter_flush(e, 0); 

  • trunk/sandbox/emit-it/emit-it.c

    r17 r25  
    1616{ 
    1717    switch (id) { 
     18/* 
    1819        case 1: 
    1920            syck_emit_seq(e, "tag:domainmyseq.tld,2002:zz", seq_none); 
    … …  
    2122            syck_emit_item(e, 3); 
    2223            syck_emit_item(e, 4); 
    23 /*            syck_emit_item(e, 2); 
    24             syck_emit_item(e, 1);*/ 
    2524            syck_emit_end(e); 
    2625            break; 
    … …  
    3433            syck_emit_scalar(e, "x-private:myowntype", scalar_none, 0, 0, 0, "Ken Griffey", strlen("Ken Griffey")); 
    3534            break; 
     35*/ 
     36 
     37        case 1: 
     38            syck_emit_map(e, NULL, map_none); 
     39            syck_emit_item(e, 2); 
     40            syck_emit_item(e, 3); 
     41            syck_emit_end(e); 
     42            break; 
     43 
     44        case 2: 
     45            syck_emit_map(e, "x-private:key", map_none); 
     46            syck_emit_item(e, 4); 
     47            syck_emit_item(e, 5); 
     48            syck_emit_end(e); 
     49            break; 
     50 
     51        case 3: 
     52        case 4: 
     53        case 5: 
     54            syck_emit_scalar(e, NULL, scalar_none, 0, 0, 0, "foo", 3); 
     55            break; 
    3656    } 
     57         
    3758} 
    3859 
    … …  
    4869    syck_emitter_mark_node(e, 3); 
    4970    syck_emitter_mark_node(e, 4); 
     71    syck_emitter_mark_node(e, 5); 
    5072/*    syck_emitter_mark_node(e, 2); 
    5173    syck_emitter_mark_node(e, 1);*/ 

  • trunk/sandbox/emit-it/trailing-space-bug.c

    r17 r25  
    11 
    2 #include <stdlib.h> 
    32#include <stdio.h> 
    4 #include <stdarg.h> 
    5 #include <error.h> 
    63#include <string.h> 
    74 
    85#include <syck.h> 
     6 
     7#define VALUE "this scalar contains traling spaces   " 
    98 
    109void output_handler(SyckEmitter *e, char *str, long len) 
    … …  
    1716    switch (id) { 
    1817        case 1: 
    19             syck_emit_seq(e, "tag:domainmyseq.tld,2002:zz", seq_none); 
    20             syck_emit_item(e, 2); 
    21             syck_emit_item(e, 3); 
    22             syck_emit_item(e, 4); 
    23 /*            syck_emit_item(e, 2); 
    24             syck_emit_item(e, 1);*/ 
    25             syck_emit_end(e); 
    26             break; 
    27         case 2: 
    28             syck_emit_scalar(e, "tag:yaml.org,2002:str", scalar_none, 0, 0, 0, "Mark McGwire ", strlen("Mark McGwire ")); 
    29             break; 
    30         case 3: 
    31             syck_emit_scalar(e, "tag:python.yaml.org,2002:object", scalar_none, 0, 0, 0, "Sammy Sosa", strlen("Sammy Sosa")); 
    32             break; 
    33         case 4: 
    34             syck_emit_scalar(e, "x-private:myowntype", scalar_none, 0, 0, 0, "Ken Griffey", strlen("Ken Griffey")); 
     18            syck_emit_scalar(e, "tag:yaml.org,2002:str", scalar_none, 0, 0, 0, VALUE, strlen(VALUE)); 
    3519            break; 
    3620    } 
     21         
    3722} 
    3823 
    … …  
    4530    syck_output_handler(e, output_handler); 
    4631    syck_emitter_mark_node(e, 1); 
    47     syck_emitter_mark_node(e, 2); 
    48     syck_emitter_mark_node(e, 3); 
    49     syck_emitter_mark_node(e, 4); 
    50 /*    syck_emitter_mark_node(e, 2); 
    51     syck_emitter_mark_node(e, 1);*/ 
    5232    syck_emit(e, 1); 
    5333    syck_emitter_flush(e, 0); 

  • trunk/tests/test_pickle.py

    r24 r25  
    288288] 
    289289 
     290NODES = """ 
     291- foo 
     292- [bar, baz] 
     293""" 
     294 
     295BUGGY_NODES = """ 
     296- foo 
     297- { bar: baz } 
     298""" 
     299 
    290300class ExLoader(syck.Loader): 
    291301 
    … …  
    332342            self.assertEqual(left, right) 
    333343 
     344class TestNodesReduce(unittest.TestCase): 
     345 
     346    def testNodesReduce(self): 
     347        object = syck.load(NODES) 
     348        nodes = syck.parse(NODES) 
     349        output = syck.dump(nodes) 
     350        print output 
     351        nodes2 = syck.load(output) 
     352        output2 = syck.emit(nodes2) 
     353        object2 = syck.load(output2) 
     354        self.assertEqual(object, object2) 
     355 
     356    def testBuggyNodesReduce(self): 
     357        object = syck.load(BUGGY_NODES) 
     358        nodes = syck.parse(BUGGY_NODES) 
     359        output = syck.dump(nodes) 
     360        print output 
     361        nodes2 = syck.load(output) 
     362        output2 = syck.emit(nodes2) 
     363        object2 = syck.load(output2) 
     364        self.assertEqual(object, object2) 
     365 
Note: See TracChangeset for help on using the changeset viewer.