tilia-xml 1.2.0.2 → 1.3.0

data/lib/tilia/xml/xml_deserializable.rb

@@ -5,7 +5,7 @@ module Tilia
     module XmlDeserializable
       # The deserialize method is called during xml parsing.
       #
-      # This method is called statictly, this is because in theory this method
+      # This method is called statictlly, 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
@@ -20,9 +20,9 @@ module Tilia
       # $reader->parseInnerTree() will parse the entire sub-tree, and advance to
       # the next element.
       #
-      # @param [Reader] _reader
-      # @return mixed
-      def xml_deserialize(_reader)
+      # @param [Reader] reader
+      # @return [Object]
+      def xml_deserialize(reader)
       end
     end
   end

data/lib/tilia/xml/xml_serializable.rb

@@ -3,7 +3,7 @@ module Tilia
     # Objects implementing XmlSerializable can control how they are represented in
     # Xml.
     module XmlSerializable
-      # The xmlSerialize metod is called during xml writing.
+      # The xmlSerialize method is called during xml writing.
       #
       # Use the $writer argument to write its own xml serialization.
       #
@@ -18,9 +18,9 @@ module Tilia
       #
       # If you are opening new elements, you must also close them again.
       #
-      # @param [Writer] _writer
+      # @param [Writer] writer
       # @return [void]
-      def xml_serialize(_writer)
+      def xml_serialize(writer)
       end
     end
   end

data/test/test_helper.rb

@@ -2,3 +2,80 @@ require 'simplecov'
 require 'minitest/autorun'
 
 require 'tilia/xml'
+
+# Extend the assertions
+require 'minitest/assertions'
+module Minitest
+  module Assertions
+    def assert_xml_equal(expected, actual, message = nil)
+      assert(
+        Hash.from_xml(actual) == Hash.from_xml(expected),
+        message || ">>> expected:\n#{expected}\n<<<\n>>> got:\n#{actual}\n<<<"
+      )
+    end
+
+    def assert_instance_equal(expected, actual, message = nil)
+      assert(
+        compare_instances(expected, actual),
+        message || ">>> expected:\n#{expected.inspect}\n<<<\n>>> got:\n#{actual.inspect}\n<<<"
+      )
+    end
+
+    def assert_has_key(key, hash, message = nil)
+      assert(
+        hash.key?(key),
+        message || "expected #{hash.inspect} to have key #{key.inspect}"
+      )
+    end
+
+    def assert_v_object_equals(expected, actual, message = nil)
+      get_obj = lambda do |input|
+        input = input.read if input.respond_to?(:read)
+
+        input = Tilia::VObject::Reader.read(input) if input.is_a?(String)
+
+        unless input.is_a?(Tilia::VObject::Component)
+          raise ArgumentError, 'Input must be a string, stream or VObject component'
+        end
+
+        input.delete('PRODID')
+        if input.is_a?(Tilia::VObject::Component::VCalendar) && input['CALSCALE'].to_s == 'GREGORIAN'
+          input.delete('CALSCALE')
+        end
+        input
+      end
+
+      assert_equal(
+        get_obj.call(expected).serialize,
+        get_obj.call(actual).serialize,
+        message
+      )
+    end
+
+    private
+
+    def compare_instances(a, b)
+      return true if b.__id__ == a.__id__
+
+      # check class
+      return false unless a.class == b.class
+
+      # Instance variables should be the same
+      return false unless a.instance_variables.sort == b.instance_variables.sort
+
+      # compare all instance variables
+      a.instance_variables.each do |var|
+        if a.instance_variable_get(var) == a
+          # Referencing self
+          return false unless b.instance_variable_get(var) == b
+        else
+          unless a.instance_variable_get(var) == b.instance_variable_get(var) ||
+                 compare_instances(a.instance_variable_get(var), b.instance_variable_get(var))
+            return false
+          end
+        end
+      end
+      true
+    end
+  end
+end

data/test/xml/context_stack_test.rb

@@ -32,9 +32,6 @@ module Tilia
 
     class ContextStackMock
       include ContextStackTrait
-      def initialize
-        initialize_context_stack_attributes
-      end
     end
   end
 end

data/test/xml/deserializer/enum_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+module Tilia
+  module Xml
+    module Deserializer
+      class EnumTest < Minitest::Test
+        def test_deserialize
+          service = Service.new
+          service.element_map['{urn:test}root'] = Deserializer.method(:enum)
+
+          xml = <<XML
+<?xml version="1.0"?>
+<root xmlns="urn:test">
+   <foo1/>
+   <foo2/>
+</root>
+XML
+
+          result = service.parse(xml)
+
+          expected = [
+            '{urn:test}foo1',
+            '{urn:test}foo2'
+          ]
+
+          assert_equal(expected, result)
+        end
+
+        def test_deserialize_default_namespace
+          service = Service.new
+          service.element_map['{urn:test}root'] = lambda do |reader|
+            return Deserializer.enum(reader, 'urn:test')
+          end
+
+          xml = <<XML
+<?xml version="1.0"?>
+<root xmlns="urn:test">
+   <foo1/>
+   <foo2/>
+</root>
+XML
+
+          result = service.parse(xml)
+
+          expected = [
+            'foo1',
+            'foo2'
+          ]
+
+          assert_equal(expected, result)
+        end
+      end
+    end
+  end
+end

data/test/xml/deserializer/key_value_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+module Tilia
+  module Xml
+    module Deserializer
+      class KeyValueTest < Minitest::Test
+        def test_key_value
+          input = <<BLA
+<?xml version="1.0"?>
+<root xmlns="http://sabredav.org/ns">
+  <struct>
+    <elem1 />
+    <elem2>hi</elem2>
+    <elem3 xmlns="http://sabredav.org/another-ns">
+       <elem4>foo</elem4>
+       <elem5>foo &amp; bar</elem5>
+    </elem3>
+  </struct>
+</root>
+BLA
+
+          reader = Reader.new
+          reader.element_map = {
+            '{http://sabredav.org/ns}struct' => lambda do |reader|
+              return Deserializer.key_value(reader, 'http://sabredav.org/ns')
+            end
+          }
+          reader.xml(input)
+          output = reader.parse
+
+          assert_equal(
+            {
+              'name'  => '{http://sabredav.org/ns}root',
+              'value' => [
+                {
+                  'name'  => '{http://sabredav.org/ns}struct',
+                  'value' => {
+                    'elem1'                                 => nil,
+                    'elem2'                                 => 'hi',
+                    '{http://sabredav.org/another-ns}elem3' => [
+                      {
+                        'name'       => '{http://sabredav.org/another-ns}elem4',
+                        'value'      => 'foo',
+                        'attributes' => {}
+                      },
+                      {
+                        'name'       => '{http://sabredav.org/another-ns}elem5',
+                        'value'      => 'foo & bar',
+                        'attributes' => {}
+                      }
+                    ]
+                  },
+                  'attributes' => {}
+                }
+              ],
+              'attributes' => {}
+            },
+            output
+          )
+        end
+      end
+    end
+  end
+end

data/test/xml/deserializer/repeating_elements_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+module Tilia
+  module Xml
+    module Deserializer
+      class RepeatingElementsTest < Minitest::Test
+        def test_read
+          service = Service.new
+          service.element_map['{urn:test}collection'] = lambda do |reader|
+            return Deserializer.repeating_elements(reader, '{urn:test}item')
+          end
+
+          xml = <<XML
+<?xml version="1.0"?>
+<collection xmlns="urn:test">
+    <item>foo</item>
+    <item>bar</item>
+</collection>
+XML
+
+          result = service.parse(xml)
+
+          expected = [
+            'foo',
+            'bar'
+          ]
+
+          assert_equal(expected, result)
+        end
+      end
+    end
+  end
+end

data/test/xml/deserializer/value_object_test.rb

@@ -0,0 +1,163 @@
+require 'test_helper'
+
+module Tilia
+  module Xml
+    module Deserializer
+      class ValueObjectTest < Minitest::Test
+        def test_deserialize_value_object
+          input = <<XML
+<?xml version="1.0"?>
+<foo xmlns="urn:foo">
+   <firstName>Harry</firstName>
+   <lastName>Turtle</lastName>
+</foo>
+XML
+
+          reader = Reader.new
+          reader.xml(input)
+          reader.element_map = {
+            '{urn:foo}foo' => lambda do |reader|
+              return Deserializer.value_object(reader, TestVo, 'urn:foo')
+            end
+          }
+
+          output = reader.parse
+
+          vo = TestVo.new
+          vo.first_name = 'Harry'
+          vo.last_name = 'Turtle'
+
+          expected = {
+            'name'       => '{urn:foo}foo',
+            'value'      => vo,
+            'attributes' => []
+          }
+
+          assert_instance_equal(
+            expected,
+            output
+          )
+        end
+
+        def test_deserialize_value_object_ignored_element
+          input = <<XML
+<?xml version="1.0"?>
+<foo xmlns="urn:foo">
+   <firstName>Harry</firstName>
+   <lastName>Turtle</lastName>
+   <email>harry@example.org</email>
+</foo>
+XML
+
+          reader = Reader.new
+          reader.xml(input)
+          reader.element_map = {
+            '{urn:foo}foo' => lambda do |reader|
+              return Deserializer.value_object(reader, TestVo, 'urn:foo')
+            end
+          }
+
+          output = reader.parse
+
+          vo = TestVo.new
+          vo.first_name = 'Harry'
+          vo.last_name = 'Turtle'
+
+          expected = {
+            'name'       => '{urn:foo}foo',
+            'value'      => vo,
+            'attributes' => []
+          }
+
+          assert_instance_equal(
+            expected,
+            output
+          )
+        end
+
+        def test_deserialize_value_object_auto_array
+          input = <<XML
+<?xml version="1.0"?>
+<foo xmlns="urn:foo">
+   <firstName>Harry</firstName>
+   <lastName>Turtle</lastName>
+   <link>http://example.org/</link>
+   <link>http://example.net/</link>
+</foo>
+XML
+
+          reader = Reader.new
+          reader.xml(input)
+          reader.element_map = {
+            '{urn:foo}foo' => lambda do |reader|
+              return Deserializer.value_object(reader, TestVo, 'urn:foo')
+            end
+          }
+
+          output = reader.parse
+
+          vo = TestVo.new
+          vo.first_name = 'Harry'
+          vo.last_name = 'Turtle'
+          vo.link = [
+            'http://example.org/',
+            'http://example.net/'
+          ]
+
+          expected = {
+            'name'       => '{urn:foo}foo',
+            'value'      => vo,
+            'attributes' => []
+          }
+
+          assert_instance_equal(
+            expected,
+            output
+          )
+        end
+
+        def test_deserialize_value_object_empty
+          input = <<XML
+<?xml version="1.0"?>
+<foo xmlns="urn:foo" />
+XML
+
+          reader = Reader.new
+          reader.xml(input)
+          reader.element_map = {
+            '{urn:foo}foo' => lambda do |reader|
+              return Deserializer.value_object(reader, TestVo, 'urn:foo')
+            end
+          }
+
+          output = reader.parse
+
+          vo = TestVo.new
+
+          expected = {
+            'name'       => '{urn:foo}foo',
+            'value'      => vo,
+            'attributes' => []
+          }
+
+          assert_instance_equal(
+            expected,
+            output
+          )
+        end
+      end
+
+      class TestVo
+        attr_accessor :first_name
+        attr_accessor :last_name
+        attr_accessor :link
+
+        def initialize
+          @first_name = nil
+          @last_name = nil
+          @link = []
+        end
+      end
+    end
+  end
+end