Merge branch 'dev'

Author: Arzaroth Lekva

.travis.yml

@@ -4,6 +4,8 @@ python:
   - "2.7"
   - "3.3"
   - "3.4"
+  - "3.5"
+  - "3.6"
 install:
   - pip install -r test-requirements.txt
   - python setup.py install

README.md

@@ -4,38 +4,39 @@ A library providing python bindings for rapidxml
 
 ### Example
 
-    import rapidxml
+```python
+import rapidxml
 
-    r = rapidxml.RapidXml(b"<test/><test2>foo</test2><test></test>") # parsing from bytes
-    test = r.first_node("test") # get first node named test
-    test.name = "foo" # changing node's name to foo
-    r.first_node("test2").value = "bar" # changing node's value to bar
+r = rapidxml.RapidXml(b"<test/><test2>foo</test2><test></test>") # parsing from bytes
+test = r.first_node("test") # get first node named test
+test.name = "foo" # changing node's name to foo
+r.first_node("test2").value = "bar" # changing node's value to bar
 
-    print(str(r)) # will output a prettified string of the xml document
-    print(r.unparse(pretty=False, raw=True)) # will output the xml document as flat bytes
-    print(test) # also works for nodes
+print(str(r)) # will output a prettified string of the xml document
+print(r.unparse(pretty=False, raw=True)) # will output the xml document as flat bytes
+print(test) # also works for nodes
 
-    with open('dump.xml', 'w') as f:
-        f.write(str(r))
-    r = rapidxml.RapidXml("dump.xml", True) # loading from file
-
-    assert(str(r) == r.unparse(True, False)) # is always True
-    assert(repr(r) == r.unparse(pretty=False, raw=False)) # also always True
+with open('dump.xml', 'w') as f:
+    f.write(str(r))
+r = rapidxml.RapidXml("dump.xml", from_file=True) # loading from file
 
+assert(str(r) == r.unparse(True, False)) # is always True
+assert(repr(r) == r.unparse(pretty=False, raw=False)) # also always True
+```
 
 ### Install
 
-[![Latest Version](https://pypip.in/version/RapidXml/badge.svg)](https://pypi.python.org/pypi/RapidXml/)
-[![Supported Python Versions](https://pypip.in/py_versions/RapidXml/badge.svg)](https://pypi.python.org/pypi/RapidXml/)
+[![Latest Version](https://img.shields.io/pypi/v/RapidXml.svg)](https://pypi.python.org/pypi/RapidXml/)
+[![Supported Python Versions](https://img.shields.io/pypi/pyversions/RapidXml.svg)](https://pypi.python.org/pypi/RapidXml/)
 
 If you have downloaded the source code:
-
-    python setup.py install
-
+```sh
+python setup.py install
+```
 or if you want to obtain a copy from the Pypi repository:
-
-    pip install rapidxml
-
+```sh
+pip install rapidxml
+```
 Both commands will install the required package dependencies.
 
 A distribution package can be obtained for manual installation at:
@@ -46,9 +47,9 @@ A distribution package can be obtained for manual installation at:
 ### Source
 
 python_rapidxml's git repo is available on GitHub, which can be browsed at [github](https://github.com/Arzaroth/python_rapidxml) and cloned like that:
-
-    git clone https://github.com/Arzaroth/python_rapidxml.git
-
+```sh
+git clone https://github.com/Arzaroth/python_rapidxml.git
+```
 
 ### License
 
@@ -57,6 +58,6 @@ MIT license. See the LICENSE file.
 
 ### Development status
 
-[![Build Status](https://travis-ci.org/Arzaroth/python_rapidxml.svg?branch=2.0)](https://travis-ci.org/Arzaroth/python_rapidxml)
+[![Build Status](https://travis-ci.org/Arzaroth/python_rapidxml.svg?branch=master)](https://travis-ci.org/Arzaroth/python_rapidxml)
 
 This project is currently under development.

rapidxml/c_ext/src/document_object.cpp

@@ -25,7 +25,8 @@ static void rapidxml_DocumentObject_dealloc(rapidxml_DocumentObject* self) {
 
 static int _parse(rapidxml_DocumentObject* self,
                   Py_buffer* text_buff,
-                  bool from_file) {
+                  bool from_file,
+                  bool parse_cdata) {
   const char* text;
   std::vector<char> text_vector;
 
@@ -43,9 +44,14 @@ static int _parse(rapidxml_DocumentObject* self,
   }
   try {
     self->base.base.document->clear();
-    (self->base.base.document
-     ->parse<rapidxml::parse_no_utf8 | rapidxml::parse_no_data_nodes>)
-      (self->base.base.document->allocate_string(text));
+    char* data = self->base.base.document->allocate_string(text);
+    if (!parse_cdata) {
+      (self->base.base.document
+       ->parse<rapidxml::parse_no_utf8 | rapidxml::parse_no_data_nodes>)(data);
+    } else {
+      (self->base.base.document
+       ->parse<rapidxml::parse_declaration_node>)(data);
+    }
   } catch (rapidxml::parse_error &e) {
     PyErr_SetString(rapidxml_RapidXmlError, e.what());
     return 0;
@@ -58,17 +64,20 @@ static PyObject* rapidxml_DocumentObject_parse(rapidxml_DocumentObject* self,
                                                PyObject* kwds) {
   Py_buffer text_buff;
   PyObject* from_file_obj = NULL;
+  PyObject* read_cdata = NULL;
   char kw_text[] = "text";
   char kw_from_file[] = "from_file";
+  char kw_parse_cdata[] = "parse_cdata";
 
-  static char* kwlist[] = {kw_text, kw_from_file, NULL};
-  if (!PyArg_ParseTupleAndKeywords(args, kwds, "s*|O", kwlist,
-                                   &text_buff, &from_file_obj)) {
+  static char* kwlist[] = {kw_text, kw_from_file, kw_parse_cdata, NULL};
+  if (!PyArg_ParseTupleAndKeywords(args, kwds, "s*|OO", kwlist,
+                                   &text_buff, &from_file_obj, &read_cdata)) {
     return NULL;
   }
 
   if (!_parse(self, &text_buff,
-              (from_file_obj != NULL) && PyObject_IsTrue(from_file_obj))) {
+              (from_file_obj != NULL) && PyObject_IsTrue(from_file_obj),
+              (read_cdata != NULL) && PyObject_IsTrue(read_cdata))) {
     return NULL;
   }
   Py_INCREF(Py_None);
@@ -80,21 +89,26 @@ static int rapidxml_DocumentObject_init(rapidxml_DocumentObject* self,
                                         PyObject* kwds) {
   Py_buffer text_buff = {0};
   PyObject* from_file_obj = NULL;
+  PyObject* read_cdata = NULL;
   char kw_text[] = "text";
   char kw_from_file[] = "from_file";
+  char kw_parse_cdata[] = "parse_cdata";
 
   if (rapidxml_NodeType.tp_init(reinterpret_cast<PyObject*>(self), args, kwds) < 0) {
     return -1;
   }
-  static char* kwlist[] = {kw_text, kw_from_file, NULL};
-  if (!PyArg_ParseTupleAndKeywords(args, kwds, "|s*O", kwlist,
-                                   &text_buff, &from_file_obj)) {
+  static char* kwlist[] = {kw_text, kw_from_file, kw_parse_cdata, NULL};
+  if (!PyArg_ParseTupleAndKeywords(args, kwds, "|s*OO", kwlist,
+                                   &text_buff, &from_file_obj, &read_cdata)) {
     return -1;
   }
   self->base.base.underlying_obj = new rapidxml::xml_document<>();
   self->base.base.document = static_cast<rapidxml::xml_document<>*>(self->base.base.underlying_obj);
   if (text_buff.buf) {
-    return _parse(self, &text_buff, (from_file_obj != NULL) && PyObject_IsTrue(from_file_obj)) - 1;
+    return (_parse(self, &text_buff,
+                   (from_file_obj != NULL) && PyObject_IsTrue(from_file_obj),
+                   (read_cdata != NULL) && PyObject_IsTrue(read_cdata))
+            - 1);
   }
   return 0;
 }
@@ -128,7 +142,7 @@ static PyObject* rapidxml_DocumentObject_allocate_node(rapidxml_DocumentObject*
   return _bind_result(reinterpret_cast<rapidxml_BaseObject*>(self),
                       node, &rapidxml_NodeType);
 }
-#include <iostream>
+
 static PyObject* rapidxml_DocumentObject_allocate_attribute(rapidxml_DocumentObject* self,
                                                             PyObject* args,
                                                             PyObject* kwds) {

rapidxml/rapidxml.py

@@ -94,16 +94,16 @@ def __iter__(self):
                                 self.cdata_key,
                                 self.always_aslist)
 
-
 class RapidXml(DictNode, rapidxml.c_ext.Document):
     def __init__(self,
                  text="",
                  from_file=False,
                  attribute_prefix='@',
                  cdata_key='#text',
-                 always_aslist=False):
+                 always_aslist=False,
+                 parse_cdata=False):
         DictNode.__init__(self, attribute_prefix, cdata_key, always_aslist)
-        rapidxml.c_ext.Document.__init__(self, text, from_file)
+        rapidxml.c_ext.Document.__init__(self, text, from_file, parse_cdata)
 
     def allocate_node(self, *args):
         return DictNode(self.attribute_prefix,

setup.py

@@ -8,7 +8,7 @@
 
 from setuptools import setup, Extension, find_packages
 
-VERSION = ("2", "0", "0")
+VERSION = ("2", "1", "0")
 
 rapidxml = Extension("rapidxml.c_ext",
                      define_macros=[('MAJOR_VERSION', VERSION[0]),

tests/conftest.py

@@ -22,3 +22,24 @@ def init_rapidxml():
   <test>some text</test>
 </root>""")
     return r
+
+@pytest.fixture(scope="function")
+def init_rapidxml_with_CDADA():
+    data = b"<root><test attr1=\"one\" attr2=\"two\" attr3=\"three\"/><test2><node id=\"1\"/><node id=\"2\"/><node id=\"3\"/></test2><test>some text</test><ns2:AdditionalData><ns2:Data TID=\"AD_1\"><![CDATA[{\"Cart\":{\"expirationTime\":\"2017-04-22T09:40\",\"id\":\"b469df3b-f626-4fe3-898c-825373e546a2\",\"products\":[\"1223\"],\"creationTime\":\"2017-04-21T09:40\",\"totalPrice\":{\"currencyCode\":\"EUR\",\"amount\":\"138.000\"}}}]]></ns2:Data></ns2:AdditionalData></root>"
+    r = rapidxml.RapidXml(data, parse_cdata=True)
+    return r
+
+@pytest.fixture(scope="module")
+def cdata_obj():
+    return {
+        "Cart": {
+            "expirationTime": "2017-04-22T09:40",
+            "id": "b469df3b-f626-4fe3-898c-825373e546a2",
+            "products": ["1223"],
+            "creationTime":"2017-04-21T09:40",
+            "totalPrice": {
+                "currencyCode": "EUR",
+                "amount": "138.000",
+            },
+        },
+    }

tests/test_attributes.py

@@ -53,3 +53,51 @@ def test_insert_attribute(init_rapidxml):
     test = attr2.previous_attribute()
     assert test.name == "test"
     assert test.value == "test"
+
+def test_first_attribute_cdata(init_rapidxml_with_CDADA):
+    test = init_rapidxml_with_CDADA.first_node().first_node("test")
+    assert test.first_attribute().name == "attr1"
+    assert test.first_attribute().value == "one"
+    attr2 = test.first_attribute("attr2")
+    assert attr2.name == "attr2"
+    assert attr2.value == "two"
+
+def test_last_attribute_cdata(init_rapidxml_with_CDADA):
+    test = init_rapidxml_with_CDADA.first_node().first_node("test")
+    assert test.last_attribute().name == "attr3"
+    assert test.last_attribute().value == "three"
+    attr2 = test.last_attribute("attr2")
+    assert attr2.name == "attr2"
+    assert attr2.value == "two"
+
+def test_append_attribute_cdata(init_rapidxml_with_CDADA):
+    root = init_rapidxml_with_CDADA.first_node()
+    root.append_attribute(init_rapidxml_with_CDADA.allocate_attribute())
+    assert root.last_attribute().name == ""
+    assert root.last_attribute().value == ""
+    root.append_attribute(init_rapidxml_with_CDADA.allocate_attribute("test"))
+    assert root.last_attribute().name == "test"
+    assert root.last_attribute().value == ""
+    root.append_attribute(init_rapidxml_with_CDADA.allocate_attribute(value="test"))
+    assert root.last_attribute().name == ""
+    assert root.last_attribute().value == "test"
+    root.append_attribute(init_rapidxml_with_CDADA.allocate_attribute("test", "test"))
+    assert root.last_attribute().name == "test"
+    assert root.last_attribute().value == "test"
+
+def test_prepend_attribute_cdata(init_rapidxml_with_CDADA):
+    root = init_rapidxml_with_CDADA.first_node()
+    root.prepend_attribute(init_rapidxml_with_CDADA.allocate_attribute("test", "test"))
+    assert root.first_attribute().name == "test"
+    assert root.first_attribute().value == "test"
+    root.prepend_attribute(init_rapidxml_with_CDADA.allocate_attribute("test2", "test2"))
+    assert root.first_attribute().name == "test2"
+    assert root.first_attribute().value == "test2"
+
+def test_insert_attribute_cdata(init_rapidxml_with_CDADA):
+    test = init_rapidxml_with_CDADA.first_node().first_node()
+    attr2 = test.first_attribute("attr2")
+    test.insert_attribute(attr2, init_rapidxml_with_CDADA.allocate_attribute("test", "test"))
+    test = attr2.previous_attribute()
+    assert test.name == "test"
+    assert test.value == "test"

tests/test_basic.py

@@ -57,3 +57,62 @@ def test_assign(init_rapidxml):
     assert init_rapidxml.unparse() == ('<new_root><new_test new_attr1="one" attr2="new_two" attr3="three"/>'
                                        '<test2><node id="1"/><node id="2"/><node id="3"/></test2>'
                                        '<test>some new text</test></new_root>')
+
+def test_init_cdata(init_rapidxml_with_CDADA):
+    datra_str =('<root><test attr1="one" attr2="two" attr3="three"/>'
+                '<test2><node id="1"/><node id="2"/><node id="3"/></test2>'
+                '<test>some text</test>'
+                "<ns2:AdditionalData><ns2:Data TID=\"AD_1\">"
+                "<![CDATA[{\"Cart\":{\"expirationTime\":\"2017-04-22T09:40\","
+                "\"id\":\"b469df3b-f626-4fe3-898c-825373e546a2\",\"products\":[\"1223\"],"
+                "\"creationTime\":\"2017-04-21T09:40\",\"totalPrice\":"
+                "{\"currencyCode\":\"EUR\",\"amount\":\"138.000\"}}}]]>"
+                "</ns2:Data></ns2:AdditionalData></root>")
+    assert init_rapidxml_with_CDADA.unparse() == rapidxml.RapidXml(datra_str,
+                                                                   from_file=False,
+                                                                   attribute_prefix='@',
+                                                                   cdata_key='#text',
+                                                                   always_aslist=False,
+                                                                   parse_cdata=True).unparse()
+    assert init_rapidxml_with_CDADA.unparse() == repr(init_rapidxml_with_CDADA)
+    assert init_rapidxml_with_CDADA.unparse(True) == str(init_rapidxml_with_CDADA)
+
+def test_parse_cdata(init_rapidxml_with_CDADA):
+    r = rapidxml.RapidXml()
+    try:
+        data = init_rapidxml_with_CDADA.unparse().encode('utf-8')
+    except UnicodeDecodeError:
+        data = init_rapidxml_with_CDADA.unparse()
+    r.parse(data, from_file=False, parse_cdata=True)
+    assert str(r) == str(init_rapidxml_with_CDADA)
+
+def test_parse_from_file_cdata(init_rapidxml_with_CDADA, tmpdir):
+    f = tmpdir.join("dump.xml")
+    f.write(init_rapidxml_with_CDADA.unparse())
+    r = rapidxml.RapidXml(str(f), from_file=True, parse_cdata=True)
+    assert str(r) == str(init_rapidxml_with_CDADA)
+
+def test_equals_cdata(init_rapidxml_with_CDADA):
+    assert init_rapidxml_with_CDADA == init_rapidxml_with_CDADA
+    root = init_rapidxml_with_CDADA.first_node()
+    assert root == root
+    assert root == init_rapidxml_with_CDADA.first_node()
+    assert root.first_node() != root.first_node("test2")
+    assert (root != root) == (not (root == root))
+
+def test_parent_cdata(init_rapidxml_with_CDADA):
+    assert init_rapidxml_with_CDADA.parent is None
+    assert init_rapidxml_with_CDADA.first_node().parent == init_rapidxml_with_CDADA
+
+def test_assign_cdata(init_rapidxml_with_CDADA):
+    root = init_rapidxml_with_CDADA.first_node()
+    root.name = "new_root"
+    assert root.name == "new_root"
+    test = root.first_node()
+    test.name = "new_test"
+    test.first_attribute().name = "new_attr1"
+    test.first_attribute().next_attribute().value = "new_two"
+    test = root.first_node("test")
+    test.value = "some new text"
+    assert test.value == "some new text"
+

tests/test_iterations.py

@@ -29,3 +29,27 @@ def test_attributes(init_rapidxml):
         i_attr = i_attr.next_attribute()
         if i_attr:
             assert i_attr.previous_attribute() == attr
+
+def test_children_cdata(init_rapidxml_with_CDADA):
+    test2 = init_rapidxml_with_CDADA.first_node().first_node("test2")
+    i_node = test2.first_node()
+    for node in test2.children:
+        assert i_node == node
+        assert node.name == "node"
+        assert node.value == ""
+        i_node = i_node.next_sibling()
+        if i_node:
+            assert i_node.previous_sibling() == node
+
+def test_attributes_cdata(init_rapidxml_with_CDADA):
+    test = init_rapidxml_with_CDADA.first_node().first_node()
+    i_attr = test.first_attribute()
+    for attr, expected_attr in zip(test.attributes, [('attr1', 'one'),
+                                                     ('attr2', 'two'),
+                                                     ('attr3', 'three')]):
+        assert i_attr == attr
+        assert (attr.name, attr.value) == expected_attr
+        assert (i_attr.name, i_attr.value) == expected_attr
+        i_attr = i_attr.next_attribute()
+        if i_attr:
+            assert i_attr.previous_attribute() == attr