xmlcodec 0.3.1 → 0.3.2

data/Rakefile

@@ -105,13 +105,17 @@ end
 #############################################################################
 
 desc "git tag, build and release gem"
-task :release => :build do
-  unless `git branch` =~ /^\* master$/
-    puts "You must be on the master branch to release!"
-    exit!
+task :release => :build do |t|
+  if not File.exists? "pkg/tag-#{version}"
+    unless `git branch` =~ /^\* master$/
+      puts "You must be on the master branch to release!"
+      exit!
+    end
+    sh "git commit --allow-empty -a -m 'Release #{version}'"
+    sh "git tag v#{version}"
+    sh "touch pkg/tag-#{version}"
   end
-  sh "git commit --allow-empty -a -m 'Release #{version}'"
-  sh "git tag v#{version}"
+
   sh "git push origin master"
   sh "git push origin v#{version}"
   sh "gem push pkg/#{name}-#{version}.gem"

data/lib/element.rb

@@ -34,177 +34,6 @@ module XMLCodec
     ## A xmlsubel is any subelement of a given element
 
   private
-    # Class level variable to hold the list of subelements
-    def self.xmlsubels
-      @xmlsubels ||=[]
-    end
-    
-    # Class level variable to hold the list of subelements that are multiple
-    def self.xmlsubelmultiples
-      @xmlsubelmultiples ||=[]
-    end
-    
-    # Class level variable that holds the list of attributes
-    def self.xmlattrs
-      @xmlattrs ||=[]
-    end
-
-    # Add a name as being a subelement (mult or single)
-    def self._xmlsubel(name)
-      self.xmlsubels << name
-    end
-    
-    # Add a xmlsubel type attribute
-    def self.xmlsubel(name) #:doc:
-      name = name.to_sym
-      self._xmlsubel(name)
-      attr_reader name
-      define_method((name.to_s+"=").to_sym) { |value|
-        if value.is_a? String or value.is_a? Fixnum
-          value = self.class.get_element_class(name).new(value)
-        end
-        value.__parent = self if value
-        instance_variable_set "@#{name}", value
-      }
-    end
-    
-    # Add a xmlsubel_mult type attribute (wrapper around attr_accessor)
-    def self.xmlsubel_mult(name) #:doc:
-      name = name.to_sym
-      self._xmlsubel(name)
-      self.xmlsubelmultiples << name
-      define_method(name){
-        if not self.instance_variables.index("@#{name}".to_sym)
-          instance_variable_set "@#{name}", XMLSubElements.new(self)
-        end
-        instance_variable_get "@#{name}"
-      }
-    end
-    
-    # Iterates over the object's XML subelements
-    def self.each_subel
-      if not self.instance_variables.index("@__subel_names".to_sym)
-        names = []
-        # Iterate all the superclasses that are still children of XMLElement
-        # and iterate each of the subelements
-        c = self
-        while c.ancestors.index(XMLCodec::XMLElement)
-          names += c.xmlsubels
-          c = c.superclass
-        end
-        @__subel_names = names
-      end
-      @__subel_names.each {|name| yield name}
-    end
-
-    # Iterate all the superclasses that are still children of XMLElement
-    # and check if any of them have the subelement mult defined
-    def self.subel_mult?(element)
-      if not self.instance_variables.index("@__subel_mult_names".to_sym)
-        names = []
-        c = self
-        while c.ancestors.index(XMLCodec::XMLElement)
-          names += c.xmlsubelmultiples
-          c = c.superclass
-        end
-        @__subel_mult_names = names
-      end
-      return @__subel_mult_names.index(element)? true : false
-    end
-    
-    # Iterate all the superclasses that are still children of XMLElement
-    # and check if any of them have any subelements handled by this class
-    def get_subel(elclass)
-      names = elclass.get_elnames
-      c = self.class
-      while c.ancestors.index(XMLCodec::XMLElement)
-        names.each do |name|
-          if c.xmlsubels.index(name.to_sym)
-            return names[0].to_sym
-          end
-        end
-        c = c.superclass
-      end
-      return nil
-    end
-  
-    # Iterates over the object's XML atributes
-    def self.each_attr    
-      attr_names.each {|name| yield name}
-    end
-
-    def self.attr_names
-      if not self.instance_variables.index("@__attr_names".to_sym)
-        names = []
-        # Iterate all the superclasses that are still children of XMLElement
-        # and iterate each of the attributes
-        c = self
-        while c.ancestors.index(XMLCodec::XMLElement)
-          names += c.xmlattrs
-          c = c.superclass
-        end
-        @__attr_names = names
-      end
-      
-      @__attr_names
-    end
-
-    # Creates the XML for the atributes
-    def create_xml_attr(parent)
-      self.class.each_attr do |a|
-        value = self.send(a)
-        if value
-          parent.set_attribute(a.to_s, value)
-        end
-      end
-    end
-
-    # returns a string with the opening tag for the element
-    def create_open_tag
-      attrs = {}
-      self.class.each_attr do |a|
-        value = self.send(a)
-        if value
-          attrs[a.to_s] = value
-        end
-      end
-      XMLCodec::XMLUtils::create_open_tag(elname.to_s, attrs)
-    end
-    
-    # returns a string with the closing tag for the element
-    def create_close_tag
-      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) {
-        @subelements ||= XMLSubElements.new(self)
-      }
-      define_method('<<') {|value|
-        subelements << value
-      }
-      define_method(:find_first_named) {|name|
-        subelements.find_first_named(name)
-      }
-      define_method('[]') {|name|
-        subelements.find_first_named(name)
-      }
-      define_method(:find_all_named) {|name|
-        subelements.find_all_named(name)
-      }
-      self.class_eval do
-        def self.has_subelements?; true; end
-      end
-    end
-  
-    # Add a xmlattr type attribute (wrapper around attr_accessor)
-    def self.xmlattr(name) #:doc:
-      self.xmlattrs << name.to_sym
-      attr_accessor name
-    end
-    
     # 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)
@@ -238,48 +67,6 @@ module XMLCodec
     def self.get_elnames
       @elnames||=[]
     end
-  
-    # Set the element as having a value. The element will have an initializer
-    # 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
-      self.class_eval do
-        def self.hasvalue?; true; end
-      end
-      self.class_eval do
-        def initialize(value=nil)
-          @value = value
-        end
-      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)
-      self.class.each_subel do |a|
-        if value = self.send(a)
-          value.create_xml(parent)
-        end
-      end
-    end
-    
-    # Create the XML of the SubElements
-    def create_xml_subelements(parent)
-      self.subelements.create_xml(parent)
-    end
     
     # Which level of indentation are we in?
     #
@@ -361,236 +148,5 @@ module XMLCodec
     def self.get_element_names(name)
       get_element_class(name).get_elnames
     end
-    
-    # Method that checks if a given class has subelements. This is usually only
-    # used when exporting stuff.
-    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 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
-    # creating the XML for any subelements. 
-    def create_xml(parent)
-      xmlel = parent.add_child Nokogiri::XML::Element.new(self.elname.to_s, parent)
-      if self.hasvalue?
-        xmlel.add_child self.value
-      end
-      create_xml_attr(xmlel)
-      create_xml_subel(xmlel)
-      
-      if self.has_subelements?
-        create_xml_subelements(xmlel)
-      end
-      
-      xmlel
-    end
-    
-    # Import the XML into an object from a Nokogiri XML Node or Document or from
-    # a string.
-    def self.import_xml(obj)
-      if obj.instance_of? String
-        _import_xml_text(obj)
-      elsif obj.instance_of? Nokogiri::XML::Node or 
-            obj.instance_of? Nokogiri::XML::Document
-        _import_xml_dom(obj)
-      else
-        nil
-      end
-    end
-
-    # Import the XML into an object from a Nokogiri XML Node or Document. 
-    # This call is recursive and imports any subelements found into the 
-    # corresponding objects.
-    def self._import_xml_dom(xmlel)
-      if xmlel.is_a? Nokogiri::XML::Document
-        xmlel = xmlel.root
-      end
-
-      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
-          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
-      
-      attributes = {}
-      xmlel.attributes.each do |name, attr|
-        attributes[name] = attr.value
-      end
-      
-      elclass.new_with_content(attributes, elements)
-    end
-    
-    # Import the XML directly from the text.
-    def self._import_xml_text(text)
-      parser = XMLStreamObjectParser.new(self)
-      parser.parse(text)
-      parser.top_element
-    end
-    
-    # Create a new element passing it all the atributes, children and texts
-    def self.new_with_content(attrs, children)
-      text_children = []
-      element_children = []
-      
-      children.each do |c|
-        if c.is_a? String
-          text_children << c
-        else
-          element_children << c
-        end
-      end
-    
-      obj = self.allocate
-      obj.add_attr(attrs)
-      obj.add_subel(element_children)
-      obj.add_texts(text_children)
-      if obj.has_subelements?
-        obj.add_subelements(children)
-      end
-      obj
-    end
-    
-    # add the attributes passed as a hash to the element
-    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)
-            raise ElementAttributeNotFound, "No attribute '#{name}' defined for class '#{self.class}'" 
-          end
-        else
-          self.send("#{name}=", value)
-        end
-      end
-    end
-    
-    # add the text elements into the element
-    def add_texts(texts)
-      if self.hasvalue?
-        @value = texts.join
-      end
-    end
-    
-    # add the subelements into the element
-    def add_subel(children)
-      children.each do |c|
-        if subel_name = get_subel(c.class)
-          if self.class.subel_mult? subel_name
-            self.send(subel_name) <<  c
-          else
-            self.send(subel_name.to_s+'=', c)
-          end 
-        end
-      end
-    end
-    
-    # If the class is one with many subelements import all of them into the
-    # object.
-    def add_subelements(all_children)
-      all_children.each {|c| self.subelements << c}
-    end
-    
-    
-    # create the XML text of the element
-    def xml_text
-      str = create_open_tag
-      if self.hasvalue?
-        str << XMLCodec::XMLUtils::escape_xml(self.value)
-      end
-      
-      each_subelement do |e|
-        str << e.xml_text
-      end
-      
-      str << create_close_tag
-      str
-    end
-    
-    # Have we already started the partial export of this element?
-    def already_partial_exported?
-      (@already_partial_exported ||= false)
-    end
-    
-    # Have we already ended the partial export of this element?
-    def already_partial_export_ended?
-      (@already_partial_export_ended ||= false)
-    end
-
-    # Export this element into a file. Will also start to export the parents of
-    # the element. It's equivalent to calling start_partial_export followed by
-    # end_partial_export.
-    def partial_export(file)
-      if not already_partial_exported?
-        start_partial_export(file)
-        end_partial_export(file)
-      end
-    end
-    
-    # Starts to export the element to a file. all the existing elements will be
-    # exported. After calling this you should only add stuff that you will 
-    # export explicitly by calling partial_export or start_partial_export.
-    def start_partial_export(file)
-      if not already_partial_exported?
-        @already_partial_exported = true
-        if self.__parent
-          self.__parent.start_partial_export(file)
-        end
-        
-        file << create_open_tag
-        if self.hasvalue?
-          file << XMLCodec::XMLUtils::escape_xml(self.value)
-        end
-        
-        each_subelement do |e|
-          e.partial_export(file)
-        end
-      end
-    end
-    
-    # Ends the partial exporting of the element. 
-    def end_partial_export(file)
-      if not already_partial_export_ended?
-        @already_partial_export_ended = true
-        
-        if not already_partial_exported?
-          raise "<#{self} Trying to end the export of an element that hasn't"+
-                " been started yet"
-        end
-        
-        each_subelement do |e|
-          e.end_partial_export(file)
-        end
-        
-        file << create_close_tag
-
-        if self.__parent
-          self.__parent.delete_element(self)
-        end
-      end
-    end
   end
 end

data/lib/element_attrs.rb

@@ -0,0 +1,36 @@
+module XMLCodec
+  class XMLElement
+    private
+    # Add a xmlattr type attribute (wrapper around attr_accessor)
+    def self.xmlattr(name) #:doc:
+      self.xmlattrs << name.to_sym
+      attr_accessor name
+    end
+
+    # Class level variable that holds the list of attributes
+    def self.xmlattrs
+      @xmlattrs ||=[]
+    end
+
+    # Iterates over the object's XML atributes
+    def self.each_attr    
+      attr_names.each {|name| yield name}
+    end
+
+    def self.attr_names
+      if not self.instance_variables.index("@__attr_names".to_sym)
+        names = []
+        # Iterate all the superclasses that are still children of XMLElement
+        # and iterate each of the attributes
+        c = self
+        while c.ancestors.index(XMLCodec::XMLElement)
+          names += c.xmlattrs
+          c = c.superclass
+        end
+        @__attr_names = names
+      end
+      
+      @__attr_names
+    end
+  end
+end

data/lib/element_creation.rb

@@ -0,0 +1,66 @@
+module XMLCodec
+  class XMLElement
+    public  
+    # Create a new element passing it all the atributes, children and texts
+    def self.new_with_content(attrs, children)
+      text_children = []
+      element_children = []
+      
+      children.each do |c|
+        if c.is_a? String
+          text_children << c
+        else
+          element_children << c
+        end
+      end
+    
+      obj = self.allocate
+      obj.add_attr(attrs)
+      obj.add_subel(element_children)
+      obj.add_texts(text_children)
+      if obj.has_subelements?
+        obj.add_subelements(children)
+      end
+      obj
+    end
+    
+    # add the attributes passed as a hash to the element
+    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)
+            raise ElementAttributeNotFound, "No attribute '#{name}' defined for class '#{self.class}'" 
+          end
+        else
+          self.send("#{name}=", value)
+        end
+      end
+    end
+    
+    # add the text elements into the element
+    def add_texts(texts)
+      if self.hasvalue?
+        @value = texts.join
+      end
+    end
+    
+    # add the subelements into the element
+    def add_subel(children)
+      children.each do |c|
+        if subel_name = get_subel(c.class)
+          if self.class.subel_mult? subel_name
+            self.send(subel_name) <<  c
+          else
+            self.send(subel_name.to_s+'=', c)
+          end 
+        end
+      end
+    end
+    
+    # If the class is one with many subelements import all of them into the
+    # object.
+    def add_subelements(all_children)
+      all_children.each {|c| self.subelements << c}
+    end
+  end
+end

data/lib/element_export.rb

@@ -0,0 +1,78 @@
+module XMLCodec
+  class XMLElement
+    public
+    # 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
+    # creating the XML for any subelements. 
+    def create_xml(parent)
+      xmlel = parent.add_child Nokogiri::XML::Element.new(self.elname.to_s, parent)
+      if self.hasvalue?
+        xmlel.add_child self.value
+      end
+      create_xml_attr(xmlel)
+      create_xml_subel(xmlel)
+      
+      if self.has_subelements?
+        create_xml_subelements(xmlel)
+      end
+      
+      xmlel
+    end
+
+    # Creates the XML subelements
+    def create_xml_subel(parent)
+      self.class.each_subel do |a|
+        if value = self.send(a)
+          value.create_xml(parent)
+        end
+      end
+    end
+    
+    # Create the XML of the SubElements
+    def create_xml_subelements(parent)
+      self.subelements.create_xml(parent)
+    end
+
+    # Creates the XML for the atributes
+    def create_xml_attr(parent)
+      self.class.each_attr do |a|
+        value = self.send(a)
+        if value
+          parent.set_attribute(a.to_s, value)
+        end
+      end
+    end
+
+    # create the XML text of the element
+    def xml_text
+      str = create_open_tag
+      if self.hasvalue?
+        str << XMLCodec::XMLUtils::escape_xml(self.value)
+      end
+      
+      each_subelement do |e|
+        str << e.xml_text
+      end
+      
+      str << create_close_tag
+      str
+    end
+
+    # returns a string with the opening tag for the element
+    def create_open_tag
+      attrs = {}
+      self.class.each_attr do |a|
+        value = self.send(a)
+        if value
+          attrs[a.to_s] = value
+        end
+      end
+      XMLCodec::XMLUtils::create_open_tag(elname.to_s, attrs)
+    end
+    
+    # returns a string with the closing tag for the element
+    def create_close_tag
+      XMLCodec::XMLUtils::create_close_tag(elname.to_s)
+    end
+  end
+end

data/lib/element_import.rb

@@ -0,0 +1,64 @@
+module XMLCodec
+  class XMLElement
+    public
+    # Import the XML into an object from a Nokogiri XML Node or Document or from
+    # a string.
+    def self.import_xml(obj)
+      if obj.instance_of? String
+        _import_xml_text(obj)
+      elsif obj.instance_of? Nokogiri::XML::Node or 
+            obj.instance_of? Nokogiri::XML::Document
+        _import_xml_dom(obj)
+      else
+        nil
+      end
+    end
+
+    private
+    # Import the XML into an object from a Nokogiri XML Node or Document. 
+    # This call is recursive and imports any subelements found into the 
+    # corresponding objects.
+    def self._import_xml_dom(xmlel)
+      if xmlel.is_a? Nokogiri::XML::Document
+        xmlel = xmlel.root
+      end
+
+      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
+          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
+      
+      attributes = {}
+      xmlel.attributes.each do |name, attr|
+        attributes[name] = attr.value
+      end
+      
+      elclass.new_with_content(attributes, elements)
+    end
+    
+    # Import the XML directly from the text.
+    def self._import_xml_text(text)
+      parser = XMLStreamObjectParser.new(self)
+      parser.parse(text)
+      parser.top_element
+    end
+  end
+end

data/lib/element_partial_export.rb

@@ -0,0 +1,68 @@
+module XMLCodec
+  class XMLElement
+    private
+    # Have we already started the partial export of this element?
+    def already_partial_exported?
+      (@already_partial_exported ||= false)
+    end
+    
+    # Have we already ended the partial export of this element?
+    def already_partial_export_ended?
+      (@already_partial_export_ended ||= false)
+    end
+
+    public
+    # Export this element into a file. Will also start to export the parents of
+    # the element. It's equivalent to calling start_partial_export followed by
+    # end_partial_export.
+    def partial_export(file)
+      if not already_partial_exported?
+        start_partial_export(file)
+        end_partial_export(file)
+      end
+    end
+    
+    # Starts to export the element to a file. all the existing elements will be
+    # exported. After calling this you should only add stuff that you will 
+    # export explicitly by calling partial_export or start_partial_export.
+    def start_partial_export(file)
+      if not already_partial_exported?
+        @already_partial_exported = true
+        if self.__parent
+          self.__parent.start_partial_export(file)
+        end
+        
+        file << create_open_tag
+        if self.hasvalue?
+          file << XMLCodec::XMLUtils::escape_xml(self.value)
+        end
+        
+        each_subelement do |e|
+          e.partial_export(file)
+        end
+      end
+    end
+    
+    # Ends the partial exporting of the element. 
+    def end_partial_export(file)
+      if not already_partial_export_ended?
+        @already_partial_export_ended = true
+        
+        if not already_partial_exported?
+          raise "<#{self} Trying to end the export of an element that hasn't"+
+                " been started yet"
+        end
+        
+        each_subelement do |e|
+          e.end_partial_export(file)
+        end
+        
+        file << create_close_tag
+
+        if self.__parent
+          self.__parent.delete_element(self)
+        end
+      end
+    end
+  end
+end

data/lib/element_subel.rb

@@ -0,0 +1,93 @@
+module XMLCodec
+  class XMLElement
+    private
+    # Add a xmlsubel type attribute
+    def self.xmlsubel(name) #:doc:
+      name = name.to_sym
+      self._xmlsubel(name)
+      attr_reader name
+      define_method((name.to_s+"=").to_sym) { |value|
+        if value.is_a? String or value.is_a? Fixnum
+          value = self.class.get_element_class(name).new(value)
+        end
+        value.__parent = self if value
+        instance_variable_set "@#{name}", value
+      }
+    end
+    
+    # Add a xmlsubel_mult type attribute (wrapper around attr_accessor)
+    def self.xmlsubel_mult(name) #:doc:
+      name = name.to_sym
+      self._xmlsubel(name)
+      self.xmlsubelmultiples << name
+      define_method(name){
+        if not self.instance_variables.index("@#{name}".to_sym)
+          instance_variable_set "@#{name}", XMLSubElements.new(self)
+        end
+        instance_variable_get "@#{name}"
+      }
+    end
+
+    # Add a name as being a subelement (mult or single)
+    def self._xmlsubel(name)
+      self.xmlsubels << name
+    end
+
+    # Class level variable to hold the list of subelements
+    def self.xmlsubels
+      @xmlsubels ||=[]
+    end
+    
+    # Class level variable to hold the list of subelements that are multiple
+    def self.xmlsubelmultiples
+      @xmlsubelmultiples ||=[]
+    end
+    
+    # Iterates over the object's XML subelements
+    def self.each_subel
+      if not self.instance_variables.index("@__subel_names".to_sym)
+        names = []
+        # Iterate all the superclasses that are still children of XMLElement
+        # and iterate each of the subelements
+        c = self
+        while c.ancestors.index(XMLCodec::XMLElement)
+          names += c.xmlsubels
+          c = c.superclass
+        end
+        @__subel_names = names
+      end
+      @__subel_names.each {|name| yield name}
+    end
+
+    # Iterate all the superclasses that are still children of XMLElement
+    # and check if any of them have the subelement mult defined
+    def self.subel_mult?(element)
+      if not self.instance_variables.index("@__subel_mult_names".to_sym)
+        names = []
+        c = self
+        while c.ancestors.index(XMLCodec::XMLElement)
+          names += c.xmlsubelmultiples
+          c = c.superclass
+        end
+        @__subel_mult_names = names
+      end
+      return @__subel_mult_names.index(element)? true : false
+    end
+    
+    # Iterate all the superclasses that are still children of XMLElement
+    # and check if any of them have any subelements handled by this class
+    def get_subel(elclass)
+      names = elclass.get_elnames
+      c = self.class
+      while c.ancestors.index(XMLCodec::XMLElement)
+        names.each do |name|
+          if c.xmlsubels.index(name.to_sym)
+            return names[0].to_sym
+          end
+        end
+        c = c.superclass
+      end
+      return nil
+    end
+  end
+end

data/lib/element_subelements.rb

@@ -0,0 +1,33 @@
+module XMLCodec
+  class XMLElement
+    public
+    # Method that checks if a given class has subelements. This is usually only
+    # used when exporting stuff.
+    def self.has_subelements?; false end
+    def has_subelements?; self.class.has_subelements? end
+
+    private
+    # 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) {
+        @subelements ||= XMLSubElements.new(self)
+      }
+      define_method('<<') {|value|
+        subelements << value
+      }
+      define_method(:find_first_named) {|name|
+        subelements.find_first_named(name)
+      }
+      define_method('[]') {|name|
+        subelements.find_first_named(name)
+      }
+      define_method(:find_all_named) {|name|
+        subelements.find_all_named(name)
+      }
+      self.class_eval do
+        def self.has_subelements?; true; end
+      end
+    end
+  end
+end

data/lib/element_value.rb

@@ -0,0 +1,41 @@
+module XMLCodec
+  class XMLElement
+    public
+    # tests if the element is a value element as defined by 'elwithvalue'
+    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
+
+    private
+    # Set the element as having a value. The element will have an initializer
+    # 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
+      self.class_eval do
+        def self.hasvalue?; true; end
+      end
+      self.class_eval do
+        def initialize(value=nil)
+          @value = value
+        end
+      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
+  end
+end

data/lib/xmlcodec.rb

@@ -1,11 +1,19 @@
 require 'nokogiri'
 
 module XMLCodec
-    VERSION = '0.3.1'
+    VERSION = '0.3.2'
 end
 
-require File.dirname(__FILE__) + '/XMLUtils'
-require File.dirname(__FILE__) + '/element'
-require File.dirname(__FILE__) + '/subelements'
-require File.dirname(__FILE__) + '/stream_object_parser'
-require File.dirname(__FILE__) + '/stream_parser'
+require File.join(File.dirname(__FILE__),'XMLUtils')
+require File.join(File.dirname(__FILE__),'element')
+require File.join(File.dirname(__FILE__),'element_creation')
+require File.join(File.dirname(__FILE__),'element_partial_export')
+require File.join(File.dirname(__FILE__),'element_import')
+require File.join(File.dirname(__FILE__),'element_export')
+require File.join(File.dirname(__FILE__),'element_attrs')
+require File.join(File.dirname(__FILE__),'element_value')
+require File.join(File.dirname(__FILE__),'element_subel')
+require File.join(File.dirname(__FILE__),'element_subelements')
+require File.join(File.dirname(__FILE__),'subelements')
+require File.join(File.dirname(__FILE__),'stream_object_parser')
+require File.join(File.dirname(__FILE__),'stream_parser')

data/xmlcodec.gemspec

@@ -6,8 +6,8 @@ Gem::Specification.new do |s|
   s.platform = Gem::Platform::RUBY
 
   s.name              = 'xmlcodec'
-  s.version           = '0.3.1'
-  s.date              = '2013-08-30'
+  s.version           = '0.3.2'
+  s.date              = '2013-09-04'
 
   s.summary     = "Generic Importer/Exporter of XML formats"
   s.description = <<EOF
@@ -17,6 +17,7 @@ EOF
   s.authors  = ["Pedro Côrte-Real"]
   s.email    = 'pedro@pedrocr.net'
   s.homepage = 'https://github.com/pedrocr/xmlcodec'
+  s.license = 'LGPL-2.1'
 
   s.require_paths = %w[lib]
 
@@ -35,6 +36,14 @@ EOF
     Rakefile
     lib/XMLUtils.rb
     lib/element.rb
+    lib/element_attrs.rb
+    lib/element_creation.rb
+    lib/element_export.rb
+    lib/element_import.rb
+    lib/element_partial_export.rb
+    lib/element_subel.rb
+    lib/element_subelements.rb
+    lib/element_value.rb
     lib/stream_object_parser.rb
     lib/stream_parser.rb
     lib/subelements.rb

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: xmlcodec
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-30 00:00:00.000000000 Z
+date: 2013-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
-  requirement: &84598170 !ruby/object:Gem::Requirement
+  requirement: &71026940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *84598170
+  version_requirements: *71026940
 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.
@@ -39,6 +39,14 @@ files:
 - Rakefile
 - lib/XMLUtils.rb
 - lib/element.rb
+- lib/element_attrs.rb
+- lib/element_creation.rb
+- lib/element_export.rb
+- lib/element_import.rb
+- lib/element_partial_export.rb
+- lib/element_subel.rb
+- lib/element_subelements.rb
+- lib/element_value.rb
 - lib/stream_object_parser.rb
 - lib/stream_parser.rb
 - lib/subelements.rb
@@ -57,7 +65,8 @@ files:
 - test/utils_test.rb
 - xmlcodec.gemspec
 homepage: https://github.com/pedrocr/xmlcodec
-licenses: []
+licenses:
+- LGPL-2.1
 post_install_message: 
 rdoc_options:
 - -S