xmlcodec 0.3.0 → 0.3.1

data/lib/XMLUtils.rb

@@ -42,6 +42,11 @@ module XMLCodec
       str << ">"
       str
     end
+
+    # Create a close tag.
+    def self.create_close_tag(name)
+      "</"+name.to_s+">"
+    end
     
     # Escape a string so that it can be included in a XML document
     def self.escape_xml(string)

data/lib/element.rb

@@ -173,17 +173,14 @@ module XMLCodec
     
     # returns a string with the closing tag for the element
     def create_close_tag
-      "</"+elname.to_s+">"
+      XMLCodec::XMLUtils::create_close_tag(elname.to_s)
     end
   
     # Declare the class as having many subelements. Instances will have a 
     # method called #subelements that will return an instance of XMLSubElements
     def self.xmlsubelements #:doc:
       define_method(:subelements) {
-        if not self.instance_variables.index("@subelements".to_sym)
-          @subelements = XMLSubElements.new(self)
-        end
-        @subelements
+        @subelements ||= XMLSubElements.new(self)
       }
       define_method('<<') {|value|
         subelements << value
@@ -197,7 +194,9 @@ module XMLCodec
       define_method(:find_all_named) {|name|
         subelements.find_all_named(name)
       }
-      define_method(:has_subelements?) {true}
+      self.class_eval do
+        def self.has_subelements?; true; end
+      end
     end
   
     # Add a xmlattr type attribute (wrapper around attr_accessor)
@@ -209,16 +208,16 @@ module XMLCodec
     # Defines a new xml format (like XHTML or DocBook). This should be used in 
     # a class that's the super class of all the elements of a format
     def self.xmlformat(name=nil)
-      class_variable_set('@@elclasses', {})
-      class_variable_set('@@strict_parsing', false)
+      class_variable_set(:@@elclasses, {})
+      class_variable_set(:@@strict_parsing, false)
     end
 
     def self.xml_strict_parsing
-      class_variable_set('@@strict_parsing', true)
+      class_variable_set(:@@strict_parsing, true)
     end
     
     def self.elclasses
-      class_variable_get('@@elclasses')
+      class_variable_get(:@@elclasses)
     end
     
     # Sets the element name for the element
@@ -244,7 +243,9 @@ module XMLCodec
     # that takes a value as argument and an accessor named #value. This should
     # be used for elements that contain only text and no subelements
     def self.elwithvalue
-      define_method(:hasvalue?){true}
+      self.class_eval do
+        def self.hasvalue?; true; end
+      end
       self.class_eval do
         def initialize(value=nil)
           @value = value
@@ -252,6 +253,19 @@ module XMLCodec
       end
       attr_accessor :value
     end
+
+    # Set the element as having a value that eats up any subelements as if they
+    # were text. The element will behave similarly to "elwithvalue" with an 
+    # initializar that takes a value as argument and an accessor named #value
+    # and will consume all its subelements as if they were text. This should
+    # be used for elements that contain subelements that you want to treat as
+    # text like <content> in Atom
+    def self.elallvalue
+      self.elwithvalue
+      self.class_eval do
+        def self.allvalue?; true; end
+      end
+    end
   
     # Creates the XML subelements
     def create_xml_subel(parent)
@@ -337,7 +351,7 @@ module XMLCodec
     # Gets the class for a certain element name.
     def self.get_element_class(name)
       cl = elclasses[name.to_sym]
-  	  if not cl and class_variable_get('@@strict_parsing')
+  	  if not cl and class_variable_get(:@@strict_parsing)
   		  raise ElementClassNotFound, "No class defined for element type: '" + name.to_s + "'"
   		end
   		cl
@@ -350,13 +364,16 @@ module XMLCodec
     
     # Method that checks if a given class has subelements. This is usually only
     # used when exporting stuff.
-    def has_subelements?; false; end
+    def self.has_subelements?; false end
+    def has_subelements?; self.class.has_subelements? end
 
     # tests if the element is a value element as defined by 'elwithvalue'
-    def hasvalue?
-      false
-    end
-  
+    def self.hasvalue?; false end
+    def hasvalue?; self.class.hasvalue? end
+
+    # tests if the element is a value element as defined by 'elallvalue'
+    def self.allvalue?; false end
+    def allvalue?; self.class.allvalue?; end
 
     # Creates the xml for the element inside the parent element. The parent
     # passed should be a Nokogiri XML Node or Document. This call is recursive
@@ -369,7 +386,7 @@ module XMLCodec
       create_xml_attr(xmlel)
       create_xml_subel(xmlel)
       
-      if has_subelements?
+      if self.has_subelements?
         create_xml_subelements(xmlel)
       end
       
@@ -396,19 +413,26 @@ module XMLCodec
       if xmlel.is_a? Nokogiri::XML::Document
         xmlel = xmlel.root
       end
-      
-      elements = []
-      xmlel.children.each do |e|
-        if e.text?
-          elements << e.text
+
+      elclass = get_element_class(xmlel.name)
+      if not elclass
+        if class_variable_get(:@@strict_parsing)
+    		  raise ElementClassNotFound, "No class defined for element type: '#{e.name}'"  
         else
-          elclass = get_element_class(e.name)
-          if not elclass
-            if class_variable_get('@@strict_parsing')
-  		        raise ElementClassNotFound, "No class defined for element type: '#{e.name}'"  
-            end
-  		    else
-            elements << elclass._import_xml_dom(e)
+          return nil
+        end
+      end
+    
+      if elclass.allvalue?
+        elements = [xmlel.children.map{|c| c.to_xml(:save_with=>0)}.join]
+      else
+        elements = []
+        xmlel.children.each do |e|
+          if e.text?
+            elements << e.text
+          else
+            element = _import_xml_dom(e)
+            elements << element if element
           end
         end
       end
@@ -418,8 +442,6 @@ module XMLCodec
         attributes[name] = attr.value
       end
       
-      elclass = get_element_class(xmlel.name)
-      return nil if not elclass
       elclass.new_with_content(attributes, elements)
     end
     
@@ -457,7 +479,7 @@ module XMLCodec
     def add_attr(attrs)
       attrs.each do |name, value|
         if not self.class.attr_names.include?(name.to_sym)
-          if self.class.class_variable_get('@@strict_parsing')
+          if self.class.class_variable_get(:@@strict_parsing)
             raise ElementAttributeNotFound, "No attribute '#{name}' defined for class '#{self.class}'" 
           end
         else
@@ -468,7 +490,7 @@ module XMLCodec
     
     # add the text elements into the element
     def add_texts(texts)
-      if hasvalue?
+      if self.hasvalue?
         @value = texts.join
       end
     end

data/lib/stream_object_parser.rb

@@ -70,6 +70,7 @@ module XMLCodec
       @elements = [XMLSOParserElement.new(nil, nil, nil, nil, nil, 0)]
       @id = 0
       @top_element = nil
+      @allvalue = 0
     end
     
   private
@@ -104,35 +105,54 @@ module XMLCodec
     end
     
     def start_element(name, attrs) #:nodoc:
-      @elements << XMLSOParserElement.new(name, attrs, get_elclass(name), 
-                                          curr_element, next_id, 
-                                          curr_element.depth+1)
-      @currel += 1
+      elclass =  get_elclass(name)
+      if @allvalue > 0
+        curr_element.get_object.value << XMLUtils.create_open_tag(name,attrs)
+        @allvalue += 1
+      else
+        @elements << XMLSOParserElement.new(name, attrs, elclass, 
+                                            curr_element, next_id, 
+                                            curr_element.depth+1)
+        @currel += 1
+        @allvalue = 1 if elclass && elclass.allvalue?
+      end
     end
 
     def characters(text) #:nodoc:
-      curr_element.add_child(text)
+      if @allvalue > 0
+        curr_element.get_object.value << text
+      else
+        curr_element.add_child(text)
+      end
     end
     
     def end_element(name) #:nodoc:
-      obj = curr_element
-      
-      if @listener.respond_to?("el_"+name)
-        @listener.send("el_"+name, obj)
-      end
-      
-      if not obj.consumed
-        real_obj = obj.get_object
-
-        if prev_element && real_obj
-          prev_element.add_child(real_obj)
+      elclass =  get_elclass(name)
+      if @allvalue > 1
+        # We're closing an allvalue subelement, just output it and pop
+        curr_element.get_object.value << XMLUtils.create_close_tag(name) 
+        @allvalue -= 1  
+      else
+        obj = curr_element
+        
+        if @listener.respond_to?("el_"+name)
+          @listener.send("el_"+name, obj)
         end
         
-        @top_element = obj
-      end
+        if not obj.consumed
+          real_obj = obj.get_object
+
+          if prev_element && real_obj
+            prev_element.add_child(real_obj)
+          end
           
-      @elements.pop
-      @currel -= 1
+          @top_element = obj
+        end
+            
+        @elements.pop
+        @currel -= 1
+        @allvalue = 0
+      end
     end
   end
 end

data/lib/xmlcodec.rb

@@ -1,7 +1,7 @@
 require 'nokogiri'
 
 module XMLCodec
-    VERSION = '0.3.0'
+    VERSION = '0.3.1'
 end
 
 require File.dirname(__FILE__) + '/XMLUtils'

data/test/consume_all_as_text_test.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+require 'nokogiri'
+
+class ConsumeAllAsTextTest < Test::Unit::TestCase
+  class BaseFormat < XMLElement
+    xmlformat 'Base Format'
+  end
+
+  class SimpleElement < BaseFormat
+    elallvalue
+    elname 'abc'
+    xmlattr :myattr
+  end
+
+  double_import_test(:test_import_elements, BaseFormat,
+              "<abc myattr='real'><otherel>foo</otherel>text</abc>") do |sel|
+    assert_equal 'real', sel.myattr
+    assert_equal "<otherel>foo</otherel>text", sel.value
+  end
+
+  double_import_test(:test_nested_elements, BaseFormat,
+              "<abc myattr='real'><otherel><abc>foo</abc></otherel>text</abc>") do |sel|
+    assert_equal 'real', sel.myattr
+    assert_equal "<otherel><abc>foo</abc></otherel>text", sel.value
+  end
+end

data/test/element_types_test.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+require 'nokogiri'
+
+class TestElementTypes < Test::Unit::TestCase
+  class ElementTypesBaseFormat < XMLElement
+    xmlformat 'Base Format'
+  end
+
+  class EmptyElement < ElementTypesBaseFormat
+    elname 'empty'
+  end
+
+  class ValueElement < ElementTypesBaseFormat
+    elwithvalue
+    elname 'value'
+  end
+
+  class AllValueElement < ElementTypesBaseFormat
+    elallvalue
+    elname 'allvalue'
+  end
+
+  class SubelementsElement < ElementTypesBaseFormat
+    elname 'subelements'
+    xmlsubelements
+  end
+
+  def test_elwithvalue
+    assert_equal true, ValueElement.hasvalue?
+    assert_equal true, ValueElement.new.hasvalue?
+    assert_equal false, EmptyElement.hasvalue?
+    assert_equal false, EmptyElement.new.hasvalue?
+  end
+
+  def test_elallvaluevalue
+    assert_equal true, AllValueElement.allvalue?
+    assert_equal true, AllValueElement.new.allvalue?
+    assert_equal false, EmptyElement.allvalue?
+    assert_equal false, EmptyElement.new.allvalue?
+  end
+
+  def test_xmlsubelements
+    assert_equal true, SubelementsElement.has_subelements?
+    assert_equal true, SubelementsElement.has_subelements?
+    assert_equal false, EmptyElement.has_subelements?
+    assert_equal false, EmptyElement.has_subelements?
+  end
+end

data/test/partial_import_test.rb

@@ -1,38 +1,30 @@
 require File.dirname(__FILE__) + '/test_helper.rb'
 require 'nokogiri'
 
-class PartialBaseFormat < XMLElement
-  xmlformat 'Base Format'
-end
-
-class PartialSimpleElement < PartialBaseFormat
-  elwithvalue
-  elname 'abc'
-  xmlattr :myattr
-end
-
 class TestPartialImport < Test::Unit::TestCase
-  def test_partial_elements_in_text
-    sel = PartialBaseFormat.import_xml "<abc><otherel></otherel>text</abc>"
-    assert_equal "text", sel.value
+  class PartialBaseFormat < XMLElement
+    xmlformat 'Base Format'
   end
 
-  def test_partial_elements_in_dom
-    xml_text = "<abc><otherel></otherel>text</abc>"
-    sel = PartialBaseFormat.import_xml Nokogiri::XML::Document.parse(xml_text)
-    assert_equal "text", sel.value
+  class PartialSimpleElement < PartialBaseFormat
+    elwithvalue
+    elname 'abc'
+    xmlattr :myattr
   end
 
-  def test_partial_attributes_in_text
-    sel = PartialBaseFormat.import_xml "<abc myattr='real' someattr='xpto'>text</abc>"
+  double_import_test(:test_partial_elements, PartialBaseFormat,
+              "<abc><otherel></otherel>text</abc>") do |sel|
     assert_equal "text", sel.value
-    assert_equal "real", sel.myattr
   end
 
-  def test_partial_attributes_in_dom
-    xml_text = "<abc myattr='real' someattr='xpto'>text</abc>"
-    sel = PartialBaseFormat.import_xml Nokogiri::XML::Document.parse(xml_text)
+  double_import_test(:test_partial_attributes_in_text, PartialBaseFormat,
+              "<abc myattr='real' someattr='xpto'>text</abc>") do |sel|
     assert_equal "text", sel.value
     assert_equal "real", sel.myattr
   end
+
+  double_import_test(:test_stress_valid_subelements_in_text, PartialBaseFormat,
+              "<abc><otherel><abc></abc></otherel>text</abc>") do |sel|
+    assert_equal "<abc>text</abc>", sel.xml_text
+  end
 end

data/test/test_helper.rb

@@ -27,4 +27,16 @@ class Test::Unit::TestCase
   def compare_xpath(value, path)
 		assert_equal(value.strip, XMLCodec::XMLUtils::select_path(path, @temp_path).strip)
 	end
+
+  # Tests both through DOM and text to make sure both code paths are working
+  def self.double_import_test(name, klass, text,&block)
+    define_method(name.to_s+"_text") do 
+      sel = klass.import_xml text
+      instance_exec(sel,&block)
+    end
+    define_method(name.to_s+"_dom") do 
+      sel = klass.import_xml Nokogiri::XML::Document.parse(text)
+      instance_exec(sel,&block)
+    end
+  end
 end

data/xmlcodec.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |s|
   s.platform = Gem::Platform::RUBY
 
   s.name              = 'xmlcodec'
-  s.version           = '0.3.0'
+  s.version           = '0.3.1'
   s.date              = '2013-08-30'
 
   s.summary     = "Generic Importer/Exporter of XML formats"
@@ -39,7 +39,9 @@ EOF
     lib/stream_parser.rb
     lib/subelements.rb
     lib/xmlcodec.rb
+    test/consume_all_as_text_test.rb
     test/element_test.rb
+    test/element_types_test.rb
     test/multi_format_test.rb
     test/partial_export_test.rb
     test/partial_import_test.rb

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: xmlcodec
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2013-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
-  requirement: &79189020 !ruby/object:Gem::Requirement
+  requirement: &84598170 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *79189020
+  version_requirements: *84598170
 description: ! 'A framework to write object to XML mappers in Ruby that can then function
   both in whole-document manipulation as well as constant memory unlimited size importing
   and exporting of XML.
@@ -43,7 +43,9 @@ files:
 - lib/stream_parser.rb
 - lib/subelements.rb
 - lib/xmlcodec.rb
+- test/consume_all_as_text_test.rb
 - test/element_test.rb
+- test/element_types_test.rb
 - test/multi_format_test.rb
 - test/partial_export_test.rb
 - test/partial_import_test.rb
@@ -83,7 +85,9 @@ signing_key:
 specification_version: 2
 summary: Generic Importer/Exporter of XML formats
 test_files:
+- test/consume_all_as_text_test.rb
 - test/element_test.rb
+- test/element_types_test.rb
 - test/multi_format_test.rb
 - test/partial_export_test.rb
 - test/partial_import_test.rb