tilia-xml 1.2.0

data/lib/tilia/xml/xml_serializable.rb

@@ -0,0 +1,27 @@
+module Tilia
+  module Xml
+    # Objects implementing XmlSerializable can control how they are represented in
+    # Xml.
+    module XmlSerializable
+      # The xmlSerialize metod is called during xml writing.
+      #
+      # Use the $writer argument to write its own xml serialization.
+      #
+      # An important note: do _not_ create a parent element. Any element
+      # implementing XmlSerializble should only ever write what's considered
+      # its 'inner xml'.
+      #
+      # The parent of the current element is responsible for writing a
+      # containing element.
+      #
+      # This allows serializers to be re-used for different element names.
+      #
+      # If you are opening new elements, you must also close them again.
+      #
+      # @param [Writer] _writer
+      # @return [void]
+      def xml_serialize(_writer)
+      end
+    end
+  end
+end

data/lib/tilia/xml.rb

@@ -0,0 +1,23 @@
+# Namespace for Tilia library
+module Tilia
+  # Load active support core extensions
+  require 'active_support'
+  require 'active_support/core_ext'
+
+  # Tilia libraries
+  require 'tilia/uri'
+
+  # Namespace of the Tilia::Xml library
+  module Xml
+    require 'tilia/xml/xml_deserializable'
+    require 'tilia/xml/xml_serializable'
+    require 'tilia/xml/context_stack_trait'
+    require 'tilia/xml/element'
+    require 'tilia/xml/parse_exception'
+    require 'tilia/xml/lib_xml_exception'
+    require 'tilia/xml/reader'
+    require 'tilia/xml/service'
+    require 'tilia/xml/version'
+    require 'tilia/xml/writer'
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require 'simplecov'
+require 'minitest/autorun'
+
+require 'tilia/xml'

data/test/xml/context_stack_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+module Tilia
+  module Xml
+    class ContextStackTest < Minitest::Test
+      def setup
+        @stack = ContextStackMock.new
+      end
+
+      def test_push_and_pull
+        @stack.context_uri = '/foo/bar'
+        @stack.element_map['{DAV:}foo'] = 'Bar'
+        @stack.namespace_map['DAV:'] = 'd'
+
+        @stack.push_context
+
+        assert_equal('/foo/bar', @stack.context_uri)
+        assert_equal('Bar', @stack.element_map['{DAV:}foo'])
+        assert_equal('d', @stack.namespace_map['DAV:'])
+
+        @stack.context_uri = '/gir/zim'
+        @stack.element_map['{DAV:}foo'] = 'newBar'
+        @stack.namespace_map['DAV:'] = 'dd'
+
+        @stack.pop_context
+
+        assert_equal('/foo/bar', @stack.context_uri)
+        assert_equal('Bar', @stack.element_map['{DAV:}foo'])
+        assert_equal('d', @stack.namespace_map['DAV:'])
+      end
+    end
+
+    class ContextStackMock
+      include ContextStackTrait
+      def initialize
+        initialize_context_stack_attributes
+      end
+    end
+  end
+end

data/test/xml/element/cdata_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+module Tilia
+  module Xml
+    class CDataTest < Minitest::Test
+      def test_deserialize
+        input = <<BLA
+<?xml version="1.0"?>
+<root xmlns="http://sabredav.org/ns">
+ <blabla />
+</root>
+BLA
+        reader = Reader.new
+        reader.element_map = { '{http://sabredav.org/ns}blabla' => Element::Cdata }
+        reader.xml(input)
+        assert_raises(RuntimeError) { reader.parse }
+      end
+
+      def test_serialize
+        writer = Writer.new
+        writer.namespace_map = { 'http://sabredav.org/ns' => nil }
+        writer.open_memory
+        writer.start_document
+        writer.set_indent(true)
+        writer.write('{http://sabredav.org/ns}root' => Element::Cdata.new('<foo&bar>'))
+        output = writer.output_memory
+
+        expected = <<XML
+<?xml version="1.0"?>
+<root xmlns="http://sabredav.org/ns"><![CDATA[<foo&bar>]]></root>
+XML
+
+        assert_equal(expected, output)
+      end
+    end
+  end
+end

data/test/xml/element/eater.rb

@@ -0,0 +1,60 @@
+# The intention for this reader class, is to read past the end element. This
+# should trigger a ParseException
+module Tilia
+  module Xml
+    module Element
+      class Eater
+        include Element
+
+        # The serialize method is called during xml writing.
+        #
+        # It should use the writer argument to encode this object into Xml.
+        #
+        # Important note: it is not needed to create the parent element. The
+        # parent element is already created, and we only have to worry about
+        # attributes, child elements and text (if any).
+        #
+        # Important note 2: If you are writing any new elements, you are also
+        # responsible for closing them.
+        #
+        # @param [Writer] writer
+        # @return [void]
+        def xml_serialize(writer)
+          writer.start_element('{http://sabredav.org/ns}elem1')
+          writer.write_string('hiiii!')
+          writer.end_element
+        end
+
+        # The deserialize method is called during xml parsing.
+        #
+        # This method is called statictly, this is because in theory this method
+        # may be used as a type of constructor, or factory method.
+        #
+        # Often you want to return an instance of the current class, but you are
+        # free to return other data as well.
+        #
+        # Important note 2: You are responsible for advancing the reader to the
+        # next element. Not doing anything will result in a never-ending loop.
+        #
+        # If you just want to skip parsing for this element altogether, you can
+        # just call reader->next();
+        #
+        # reader->parseSubTree() will parse the entire sub-tree, and advance to
+        # the next element.
+        #
+        # @param [Reader] reader
+        # @return mixed
+        def self.xml_deserialize(reader)
+          reader.next
+
+          count = 1
+          while count > 0
+            reader.read
+            count -= 1 if reader.node_type == ::LibXML::XML::Reader::TYPE_END_ELEMENT
+          end
+          reader.read
+        end
+      end
+    end
+  end
+end

data/test/xml/element/elements_test.rb

@@ -0,0 +1,113 @@
+require 'test_helper'
+
+module Tilia
+  module Xml
+    class ElementsTest < Minitest::Test
+      def test_deserialize
+        input = <<BLA
+<?xml version="1.0"?>
+<root xmlns="http://sabredav.org/ns">
+  <listThingy>
+    <elem1 />
+    <elem2 />
+    <elem3 />
+    <elem4 attr="val" />
+    <elem5>content</elem5>
+    <elem6><subnode /></elem6>
+  </listThingy>
+  <listThingy />
+  <otherThing>
+    <elem1 />
+    <elem2 />
+    <elem3 />
+  </otherThing>
+</root>
+BLA
+        reader = Reader.new
+        reader.element_map = { '{http://sabredav.org/ns}listThingy' => Element::Elements }
+        reader.xml(input)
+
+        output = reader.parse
+
+        expected = {
+          'name'  => '{http://sabredav.org/ns}root',
+          'value' => [
+            {
+              'name'  => '{http://sabredav.org/ns}listThingy',
+              'value' => [
+                '{http://sabredav.org/ns}elem1',
+                '{http://sabredav.org/ns}elem2',
+                '{http://sabredav.org/ns}elem3',
+                '{http://sabredav.org/ns}elem4',
+                '{http://sabredav.org/ns}elem5',
+                '{http://sabredav.org/ns}elem6'
+              ],
+              'attributes' => {}
+            },
+            {
+              'name'       => '{http://sabredav.org/ns}listThingy',
+              'value'      => [],
+              'attributes' => {}
+            },
+            {
+              'name'  => '{http://sabredav.org/ns}otherThing',
+              'value' => [
+                {
+                  'name'       => '{http://sabredav.org/ns}elem1',
+                  'value'      => nil,
+                  'attributes' => {}
+                },
+                {
+                  'name'       => '{http://sabredav.org/ns}elem2',
+                  'value'      => nil,
+                  'attributes' => {}
+                },
+                {
+                  'name'       => '{http://sabredav.org/ns}elem3',
+                  'value'      => nil,
+                  'attributes' => {}
+                }
+              ],
+              'attributes' => {}
+            }
+          ],
+          'attributes' => {}
+        }
+
+        assert_equal(expected, output)
+      end
+
+      def test_serialize
+        value = [
+          '{http://sabredav.org/ns}elem1',
+          '{http://sabredav.org/ns}elem2',
+          '{http://sabredav.org/ns}elem3',
+          '{http://sabredav.org/ns}elem4',
+          '{http://sabredav.org/ns}elem5',
+          '{http://sabredav.org/ns}elem6'
+        ]
+
+        writer = Writer.new
+        writer.namespace_map = { 'http://sabredav.org/ns' => nil }
+        writer.open_memory
+        writer.start_document
+        writer.set_indent(true)
+        writer.write('{http://sabredav.org/ns}root' => Element::Elements.new(value))
+        output = writer.output_memory
+
+        expected = <<XML
+<?xml version="1.0"?>
+<root xmlns="http://sabredav.org/ns">
+ <elem1/>
+ <elem2/>
+ <elem3/>
+ <elem4/>
+ <elem5/>
+ <elem6/>
+</root>
+XML
+        assert_equal(expected, output)
+      end
+    end
+  end
+end

data/test/xml/element/key_value_test.rb

@@ -0,0 +1,187 @@
+require 'test_helper'
+
+module Tilia
+  module Xml
+    class KeyValueTest < Minitest::Test
+      def test_deserialize
+        input = <<BLA
+<?xml version="1.0"?>
+<root xmlns="http://sabredav.org/ns">
+  <struct>
+    <elem1 />
+    <elem2>hi</elem2>
+    <elem3>
+       <elem4>foo</elem4>
+       <elem5>foo &amp; bar</elem5>
+    </elem3>
+    <elem6>Hi<!-- ignore me -->there</elem6>
+  </struct>
+  <struct />
+  <otherThing>
+    <elem1 />
+  </otherThing>
+</root>
+BLA
+
+        reader = Tilia::Xml::Reader.new
+        reader.element_map = { '{http://sabredav.org/ns}struct' => Tilia::Xml::Element::KeyValue }
+        reader.xml(input)
+
+        output = reader.parse
+
+        expected = {
+          'name'  => '{http://sabredav.org/ns}root',
+          'value' => [
+            {
+              'name'  => '{http://sabredav.org/ns}struct',
+              'value' => {
+                '{http://sabredav.org/ns}elem1' => nil,
+                '{http://sabredav.org/ns}elem2' => 'hi',
+                '{http://sabredav.org/ns}elem3' => [
+                  {
+                    'name'       => '{http://sabredav.org/ns}elem4',
+                    'value'      => 'foo',
+                    'attributes' => {}
+                  },
+                  {
+                    'name'       => '{http://sabredav.org/ns}elem5',
+                    'value'      => 'foo & bar',
+                    'attributes' => {}
+                  }
+                ],
+                '{http://sabredav.org/ns}elem6' => 'Hithere'
+              },
+              'attributes' => {}
+            },
+            {
+              'name'       => '{http://sabredav.org/ns}struct',
+              'value'      => {},
+              'attributes' => {}
+            },
+            {
+              'name'  => '{http://sabredav.org/ns}otherThing',
+              'value' => [
+                {
+                  'name'       => '{http://sabredav.org/ns}elem1',
+                  'value'      => nil,
+                  'attributes' => {}
+                }
+              ],
+              'attributes' => {}
+            }
+          ],
+          'attributes' => {}
+        }
+
+        assert_equal(expected, output)
+      end
+
+      # This test was added to find out why an element gets eaten by the
+      # SabreDAV MKCOL parser.
+      def test_element_eater
+        input = <<BLA
+<?xml version="1.0"?>
+<mkcol xmlns="DAV:">
+  <set>
+    <prop>
+        <resourcetype><collection /></resourcetype>
+        <displayname>bla</displayname>
+    </prop>
+  </set>
+</mkcol>
+BLA
+
+        reader = Tilia::Xml::Reader.new
+        reader.element_map = {
+          '{DAV:}set'          => Tilia::Xml::Element::KeyValue,
+          '{DAV:}prop'         => Tilia::Xml::Element::KeyValue,
+          '{DAV:}resourcetype' => Tilia::Xml::Element::Elements
+        }
+        reader.xml(input)
+
+        expected = {
+          'name'  => '{DAV:}mkcol',
+          'value' => [
+            {
+              'name'  => '{DAV:}set',
+              'value' => {
+                '{DAV:}prop' => {
+                  '{DAV:}resourcetype' => [
+                    '{DAV:}collection'
+                  ],
+                  '{DAV:}displayname' => 'bla'
+                }
+              },
+              'attributes' => {}
+            }
+          ],
+          'attributes' => {}
+        }
+
+        assert_equal(expected, reader.parse)
+      end
+
+      def test_serialize
+        value = {
+          '{http://sabredav.org/ns}elem1' => nil,
+          '{http://sabredav.org/ns}elem2' => 'textValue',
+          '{http://sabredav.org/ns}elem3' => {
+            '{http://sabredav.org/ns}elem4' => 'text2',
+            '{http://sabredav.org/ns}elem5' => nil
+          },
+          '{http://sabredav.org/ns}elem6' => 'text3'
+        }
+
+        writer = Tilia::Xml::Writer.new
+        writer.namespace_map = { 'http://sabredav.org/ns' => nil }
+        writer.open_memory
+        writer.start_document
+        writer.set_indent(true)
+        writer.write('{http://sabredav.org/ns}root' => Tilia::Xml::Element::KeyValue.new(value))
+        output = writer.output_memory
+
+        expected = <<XML
+<?xml version="1.0"?>
+<root xmlns="http://sabredav.org/ns">
+ <elem1/>
+ <elem2>textValue</elem2>
+ <elem3>
+  <elem4>text2</elem4>
+  <elem5/>
+ </elem3>
+ <elem6>text3</elem6>
+</root>
+XML
+        assert_equal(expected, output)
+      end
+
+      # I discovered that when there's no whitespace between elements, elements
+      # can get skipped.
+      def test_element_skip_problem
+        input = <<BLA
+<?xml version="1.0" encoding="utf-8"?>
+<root xmlns="http://sabredav.org/ns">
+<elem3>val3</elem3><elem4>val4</elem4><elem5>val5</elem5></root>
+BLA
+
+        reader = Tilia::Xml::Reader.new
+        reader.element_map = { '{http://sabredav.org/ns}root' => Tilia::Xml::Element::KeyValue }
+        reader.xml(input)
+
+        output = reader.parse
+
+        expected = {
+          'name'  => '{http://sabredav.org/ns}root',
+          'value' => {
+            '{http://sabredav.org/ns}elem3' => 'val3',
+            '{http://sabredav.org/ns}elem4' => 'val4',
+            '{http://sabredav.org/ns}elem5' => 'val5'
+          },
+          'attributes' => {}
+        }
+
+        assert_equal(expected, output)
+      end
+    end
+  end
+end

data/test/xml/element/mock.rb

@@ -0,0 +1,52 @@
+module Tilia
+  module Xml
+    module Element
+      class Mock
+        include Element
+
+        # The serialize method is called during xml writing.
+        #
+        # It should use the writer argument to encode this object into XML.
+        #
+        # Important note: it is not needed to create the parent element. The
+        # parent element is already created, and we only have to worry about
+        # attributes, child elements and text (if any).
+        #
+        # Important note 2: If you are writing any new elements, you are also
+        # responsible for closing them.
+        #
+        # @param [Writer] writer
+        # @return [void]
+        def xml_serialize(writer)
+          writer.start_element('{http://sabredav.org/ns}elem1')
+          writer.write_string('hiiii!')
+          writer.end_element
+        end
+
+        # The deserialize method is called during xml parsing.
+        #
+        # This method is called statictly, this is because in theory this method
+        # may be used as a type of constructor, or factory method.
+        #
+        # Often you want to return an instance of the current class, but you are
+        # free to return other data as well.
+        #
+        # Important note 2: You are responsible for advancing the reader to the
+        # next element. Not doing anything will result in a never-ending loop.
+        #
+        # If you just want to skip parsing for this element altogether, you can
+        # just call reader->next();
+        #
+        # reader->parseSubTree() will parse the entire sub-tree, and advance to
+        # the next element.
+        #
+        # @param [Reader] reader
+        # @return mixed
+        def self.xml_deserialize(reader)
+          reader.next
+          'foobar'
+        end
+      end
+    end
+  end
+end

data/test/xml/element/uri_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+module Tilia
+  module Xml
+    class UriTest < Minitest::Test
+      def test_deserialize
+        input = <<BLA
+<?xml version="1.0"?>
+<root xmlns="http://sabredav.org/ns">
+  <uri>/foo/bar</uri>
+</root>
+BLA
+        reader = Tilia::Xml::Reader.new
+        reader.context_uri = 'http://example.org/'
+        reader.element_map = { '{http://sabredav.org/ns}uri' => Tilia::Xml::Element::Uri }
+        reader.xml(input)
+        output = reader.parse
+
+        expected = {
+          'name'  => '{http://sabredav.org/ns}root',
+          'value' => [
+            {
+              'name'       => '{http://sabredav.org/ns}uri',
+              'value'      => Tilia::Xml::Element::Uri.new('http://example.org/foo/bar'),
+              'attributes' => {}
+            }
+          ],
+          'attributes' => {}
+        }
+
+        assert_equal(expected, output)
+      end
+
+      def test_serialize
+        writer = Tilia::Xml::Writer.new
+        writer.namespace_map = { 'http://sabredav.org/ns' => nil }
+        writer.open_memory
+        writer.start_document
+        writer.set_indent(true)
+        writer.context_uri = 'http://example.org/'
+        writer.write('{http://sabredav.org/ns}root' => { '{http://sabredav.org/ns}uri' => Tilia::Xml::Element::Uri.new('/foo/bar') })
+        output = writer.output_memory
+
+        expected = <<XML
+<?xml version="1.0"?>
+<root xmlns="http://sabredav.org/ns">
+ <uri>http://example.org/foo/bar</uri>
+</root>
+XML
+
+        assert_equal(expected, output)
+      end
+    end
+  end
+end