xml-smart 0.3.0

data/lib/xml/smart_dom.rb

@@ -0,0 +1,118 @@
+module XML
+  module Smart
+    class Dom
+      def initialize(dom)
+        @dom = dom
+        @save_unformated = false
+      end
+
+      def ===(cls); self.is_a? cls; end
+
+      def root
+        Element.new(@dom.root)
+      end
+      def root=(nr)
+        @dom.root.replace(nr.instance_variable_get(:@element)) if nr.instance_of? Element
+      end
+
+      def find(path)
+        Element.new(@dom.root).find(path)
+      end
+
+      def to_s
+        @dom.to_s
+      end
+
+      def namespaces
+        @dom.custom_namespace_prefixes.merge @dom.user_custom_namespace_prefixes
+      end
+      def register_namespace(a,b)
+        if a.respond_to?(:to_s) && b.respond_to?(:to_s) && !@dom.custom_namespace_prefixes.key?(a.to_s) && @dom.custom_namespace_prefixes.value?(b.to_s)
+          @dom.user_custom_namespace_prefixes[a.to_s] = b.to_s
+          @dom.ns_update
+          true
+        else
+          false
+        end
+      end
+      def unregister_namespace(a)
+        if a.respond_to?(:to_s) && @dom.user_custom_namespace_prefixes.key?(a.to_s)
+          @dom.user_custom_namespace_prefixes.delete(a.to_s)
+          @dom.ns_update
+          true
+        else
+          false
+        end
+      end
+
+      def save_as(name)
+        raise Error, 'first parameter has to be a filename or filehandle' unless name.is_a?(String) || name.is_a?(IO)
+        begin
+          io = name.is_a?(String) ? ::Kernel::open(name,'w') : name
+        rescue
+          raise Error, "could not open #{name}"
+        end
+        ftext = if @save_unformated
+          @dom.root.serialize(:encoding => 'UTF-8', :save_with => Nokogiri::XML::Node::SaveOptions::NO_DECLARATION | Nokogiri::XML::Node::SaveOptions::AS_XML)
+        else
+          @dom.root.serialize(:encoding => 'UTF-8', :save_with => Nokogiri::XML::Node::SaveOptions::FORMAT | Nokogiri::XML::Node::SaveOptions::AS_XML)
+        end
+        io.write ftext
+        io.close
+      end
+
+      def save_unformated=(val); @save_unformated = (val.is_a?(TrueClass) ? true : false); end
+      def save_unformated?; @save_unformated; end
+
+      def xinclude!
+        Element.new(@dom.root).xinclude!
+      end  
+
+      def self::smart_helper(node)
+        if node.instance_of? Nokogiri::XML::Element
+          Element.new(node)
+        elsif node.instance_of? Nokogiri::XML::Attr
+          Attribute.new(node)
+        elsif node.instance_of? Nokogiri::XML::NodeSet  
+          NodeSet.new(node)
+        elsif node.instance_of?(String) || node.instance_of?(TrueClass) || node.instance_of?(FalseClass) || node.instance_of?(Float)  
+          node
+        elsif node.instance_of? Nokogiri::XML::Text  
+          Text.new(node)
+        elsif node.instance_of? Nokogiri::XML::Namespace  
+          Namespace.new(node)
+        elsif node.instance_of? Nokogiri::XML::Document
+          Dom.new(node)
+        elsif node.nil?
+          nil
+        else
+          Other.new(node)
+        end  
+      end
+
+      def validate_against(doc,&errbl)
+        raise Error, 'first parameter has to XML::Smart::Dom document' unless doc.instance_of? Dom
+        res = if doc.root.namespaces.has_ns?("http://relaxng.org/ns/structure/1.0")
+          Nokogiri::XML::RelaxNG.from_document(doc.instance_variable_get(:@dom)).validate(@dom)
+        elsif doc.root.namespaces.has_ns?("http://www.w3.org/2001/XMLSchema")
+          tdoc = Nokogiri::XSLT.parse(File.read(File.expand_path(File.dirname(__FILE__) + '/XSDtoRNG.xsl')))
+          rdoc = tdoc.transform(doc.instance_variable_get(:@dom))
+          Nokogiri::XML::RelaxNG.from_document(rdoc).validate(@dom)
+        end
+        res.each { |err| errbl.call err } if block_given?
+        res.empty?
+      end
+
+      def transform_with(doc,params=nil)
+        raise Error, 'first parameter has to XML::Smart::Dom document' unless doc.instance_of? Dom
+        res = Nokogiri::XSLT::Stylesheet.parse_stylesheet_doc(doc.instance_variable_get(:@dom)).transform(@dom,params)
+        if res.children.length != 0 && res.children.first.class == Nokogiri::XML::Text
+          Text.new(res.children.first).text
+        else 
+          Dom::smart_helper(res)
+        end  
+      end
+
+    end
+  end
+end

data/lib/xml/smart_domattribute.rb

@@ -0,0 +1,34 @@
+module XML
+  module Smart
+    class Dom
+
+      class Attribute
+        def initialize(attr)
+          @attr = attr
+        end
+
+        def ===(cls); self.is_a? cls; end
+
+        def to_s; @attr.content; end
+        def to_i; @attr.content.to_i; end
+        def to_f; @attr.content.to_f; end
+
+        def qname; QName.new @attr; end
+        def path; @attr.path; end
+
+        def value;  @attr.content; end;
+        def value=(val); @attr.content = val; end;
+
+        def ==(other)
+          return false unless other
+          return false unless other.respond_to?(:unique_id)
+          unique_id == other.unique_id
+        end
+        def unique_id; @attr.pointer_id; end
+
+        def parent; Dom::smart_helper(@attr.parent); end
+      end
+
+    end  
+  end  
+end  

data/lib/xml/smart_domattributeset.rb

@@ -0,0 +1,62 @@
+module XML
+  module Smart
+    class Dom
+
+      class AttributeSet
+        include Enumerable
+
+        def initialize(element)
+          @element = element
+          @set = @element.attributes
+        end
+
+        def ===(cls); self.is_a? cls; end
+
+        def has_attr?(a); @set.has_key?(a) end
+        alias :include? :has_attr?
+        alias :attr? :has_attr?
+        alias :member? :has_attr?
+
+        def [](name,attr=false)
+          return nil unless @set[name]
+          if attr == false 
+            @element[name]
+          else  
+            Attribute.new(@set[name])
+          end 
+        end
+        def []=(name,value);
+          @element[name] = value
+        end
+
+        def length;      @set.length; end
+        def empty?;      @set.empty?; end
+        def delete_all!; @set.each { |k,a| a.remove }; end
+
+        def each(&block)
+          @set.each do |k,node|
+            block.call Dom::smart_helper(node)
+          end
+        end
+
+        def delete_at!(name)
+          tmp = @set[name]
+          if tmp === Nokogiri::XML::Attr
+            tmp.remove
+            true
+          else
+            false
+          end
+        end
+
+        def delete_if!(&block)
+          @set.each do |k,node|
+            node.remove if block.call(Dom::smart_helper(node))
+          end
+        end
+      end  
+    
+    end
+  end  
+end  
+

data/lib/xml/smart_domelement.rb

@@ -0,0 +1,213 @@
+module XML
+  module Smart
+    class Dom
+
+      class Element
+        def initialize(element)
+          @element = element
+        end
+
+        def ===(cls); self.is_a? cls; end
+
+        def find(xpath)
+          Dom::smart_helper(@element.xpath_fast(xpath))
+        end
+
+        def add_helper(attrs)
+          if attrs.length>0 && attrs[0].is_a?(String)
+            pfx = ''
+            ns = nil
+            if attrs[0].sub!(/([^:]+):/, '')
+              pfx = $1
+              if @element.document.user_custom_namespace_prefixes.has_key?(pfx)
+                @element.document.custom_namespace_prefixes.each do |k,v|
+                  if @element.document.user_custom_namespace_prefixes[pfx] == v
+                    ns = @element.document.user_custom_namespace_prefixes[pfx]
+                  end
+                end  
+              end
+              if ns.nil? 
+                if @element.document.custom_namespace_prefixes.has_key?(pfx)
+                  ns = @element.document.custom_namespace_prefixes[pfx]
+                else
+                  raise Error, 'No valid namespace' 
+                end
+              end
+            end
+            tmp = Nokogiri::XML::Node.new attrs[0], @element.document
+            unless ns.nil?
+              @element.namespace_scopes.each do |nss|
+                tmp.namespace = nss if nss.href == ns
+              end
+            end
+            [1,2].each do |i|
+              if attrs.length > i
+                case attrs[i]
+                  when Hash
+                    attrs[i].each do |k,v|
+                      if k.respond_to?(:to_s)
+                        tmp[k.to_s] = v.respond_to?(:to_s) ? v.to_s : ''
+                      else
+                        raise Error, 'use something that has provides #to_s'
+                      end
+                    end
+                  else
+                    tmp.content = attrs[i].respond_to?(:to_s) ? attrs[i].to_s : ''
+                end
+              end
+            end
+            return [tmp,false]
+          end
+          if attrs.length == 1 && attrs[0].is_a?(XML::Smart::Dom::Element)
+            ele = attrs[0].instance_variable_get(:@element)
+            same = ele.document.root.pointer_id == @element.document.root.pointer_id
+            return [same ? ele : ele.dup, !same]
+          end
+          if attrs.length == 1 && attrs[0].is_a?(XML::Smart::Dom::NodeSet)
+            nos = attrs[0].instance_variable_get(:@nodeset)
+            if nos.length > 0
+              same = nos.first.document.root.pointer_id == @element.document.root.pointer_id
+              if same
+                return [nos, false]
+              else
+                tnos = nos.map{|e|e.dup}
+                return [Nokogiri::XML::NodeSet.new(nos.first.document,tnos), true]
+              end
+            else
+              return [nos, false]
+            end
+          end
+          if attrs.length == 2 && attrs[0].is_a?(XML::Smart::Dom::Element) && (attrs[1] == XML::Smart::COPY || attrs[1] == XML::Smart::MOVE)
+            ele = attrs[0].instance_variable_get(:@element)
+            same = ele.document.root.pointer_id == @element.document.root.pointer_id
+            return [attrs[1] == XML::Smart::COPY ? ele.dup : ele, !same]
+          end
+          if attrs.length == 2 && attrs[0].is_a?(XML::Smart::Dom::NodeSet) && (attrs[1] == XML::Smart::COPY || attrs[1] == XML::Smart::MOVE)
+            nos = attrs[0].instance_variable_get(:@nodeset)
+            if nos.length > 0
+              same = nos.first.document.root.pointer_id == @element.document.root.pointer_id
+              if attrs[1] == XML::Smart::COPY
+                tnos = nos.map{|e|e.dup}
+                nos = Nokogiri::XML::NodeSet.new(nos.first.document,tnos)
+              end  
+                return [Nokogiri::XML::NodeSet.new(nos.first.document,tnos), true]
+              return [nos, !same]
+            else  
+              return [nos, false]
+            end
+          end
+          return [nil, false]
+        end
+        private :add_helper
+        def add(*attrs)
+          tmp, update = add_helper(attrs)
+          res = Dom::smart_helper(@element.add_child tmp)
+          if update
+            @element.document.custom_namespace_prefixes_update
+            @element.document.ns_update
+          end  
+          res
+        end
+        def add_before(*attrs)
+          tmp, update = add_helper(attrs)
+          res = Dom::smart_helper(@element.add_previous_sibling tmp)
+          if update
+            @element.document.custom_namespace_prefixes_update
+            @element.document.ns_update
+          end  
+          res
+        end
+        def add_after(*attrs)
+          tmp, update = add_helper(attrs)
+          res = Dom::smart_helper(@element.add_next_sibling tmp)
+          if update
+            @element.document.custom_namespace_prefixes_update
+            @element.document.ns_update
+          end  
+          res
+        end
+
+        def dump; @element.to_s; end
+        def to_s; @element.content; end
+        def to_i; @element.content.to_i; end
+        def to_f; @element.content.to_f; end
+
+        def namespace?; !@element.namespace.nil?; end
+        def namespace; namespace? ? Namespace.new(@element.namespace) : nil; end
+        def namespace=(n)
+          n = case n
+            when Namespace
+              n.prefix
+            when String
+              n
+            else
+              return
+          end  
+          tmp = @element.document.custom_namespace_prefixes[n] || @element.document.user_custom_namespace_prefixes[n]
+          unless tmp.nil?
+            @element.namespace_scopes.each do |nss|
+              @element.namespace = nss if nss.href == tmp
+            end
+          end
+        end
+        def namespaces; NamespaceSet.new(self,@element); end
+
+        def xinclude!
+          @element.do_xinclude
+          @element.document.custom_namespace_prefixes_update
+          @element.document.ns_update
+          true
+        end
+
+        def replace_by(n)
+          case n
+            when Element; Element.new @element.replace(n.instance_variable_get(:@element))
+            when NodeSet; NodeSet.new @element.replace(n.instance_variable_get(:@nodeset))
+            else
+              nil
+          end
+        end
+
+        def qname; QName.new @element; end
+        def attributes; AttributeSet.new @element; end
+
+        def text; @element.xpath_fast("string(text())"); end
+        def text=(t); @element.content = t.to_s if t.respond_to? :to_s; end
+
+        def children; find('*'); end
+        def children?; find('*').length > 0 end
+        def parent
+          Dom::smart_helper(@element.parent)
+        end
+        def parent?; !@element.parent.nil?; end
+
+        def empty?; @element.blank?; end
+        def mixed?;
+          @element.xpath_fast('*').length > 0 &&  @element.xpath_fast("string(text())") != '';
+        end
+        def text_only?;
+          @element.xpath_fast('*').length == 0 &&  @element.xpath_fast("string(text())") != '';
+        end
+        def element_only?;
+          @element.xpath_fast('*').length > 0 &&  @element.xpath_fast("string(text())") == '';
+        end
+
+        def path; @element.path; end
+
+        def ==(other)
+          return false unless other
+          return false unless other.respond_to?(:unique_id)
+          unique_id == other.unique_id
+        end
+        def unique_id; @element.pointer_id; end
+
+        def to_doc
+          doc = Nokogiri::XML::Document.new
+          doc.root = @element
+          dom = Dom.new(doc)
+        end
+      end
+
+    end
+  end
+end

data/lib/xml/smart_domnamespace.rb

@@ -0,0 +1,32 @@
+module XML
+  module Smart
+    class Dom
+
+      class Namespace
+        def initialize(ns)
+          @ns = ns
+        end
+
+        def ===(cls); self.is_a? cls; end
+
+        def href; @ns.href; end
+        alias :to_s :href
+
+        def prefix
+          if @ns.prefix
+            @ns.prefix
+          else
+            @ns.document.custom_namespace_prefixes.find{|k,v| v == @ns.href}[0]
+          end
+        end
+
+        def ==(other)
+          return false unless other
+          return false unless other.respond_to?(:to_s)
+          to_s == other.to_s
+        end
+      end
+   
+    end
+  end
+end

data/lib/xml/smart_domnamespaceset.rb

@@ -0,0 +1,125 @@
+module XML
+  module Smart
+    class Dom
+
+      class NamespaceSet
+        include Enumerable
+
+        def initialize(parent,node)
+          @parent = parent
+          @node = node
+        end
+
+        def ===(cls); self.is_a? cls; end
+
+        def has_ns?(a); @node.namespace_definitions.one?{|e| e.href == a || e.prefix == a}; end
+        alias :include? :has_ns?
+        alias :ns? :has_ns?
+        alias :member? :has_ns?
+
+        def [](name)
+          if name.nil? || name.respond_to?(:to_s)
+            name = name.to_s unless name.nil?
+            name = nil if name =~ /^xmlns\d*$/
+            nd = @node.namespace_definitions.find{|n| n.prefix == name}
+            (name.respond_to?(:to_s) || name.nil?) && nd ? Namespace.new(nd) : nil; 
+          end  
+        end
+        def []=(name,value) 
+          self.add(name,value)
+        end
+
+        def add(name,value)
+          if (name.respond_to?(:to_s) || name.nil?) && value.respond_to?(:to_s) 
+            nnod = Nokogiri::XML::Node.new(@node.name,@node.document)
+            nnew = Element.new(nnod)
+            nold = Element.new(@node)
+            nold.attributes.each do |attr|
+              nnew.attributes[attr.qname.name] = attr.value
+            end
+            ns = nnod.add_namespace_definition(name,value)
+            @node.namespace_definitions.each do |ns|
+              nnod.add_namespace_definition(ns.prefix,ns.href)
+            end
+            nnew.add(nold.children)
+            nold.replace_by(nnew)
+            @node = nnod
+            @parent.instance_variable_set(:@element,@node) 
+            @node.document.custom_namespace_prefixes_update
+            @node.document.ns_update
+            Namespace.new(ns)
+          end  
+        end
+
+        def length;      @node.namespace_definitions.length; end
+        def empty?;      @node.namespace_definitions.empty?; end
+        def delete_all!
+          nnod = Nokogiri::XML::Node.new(@node.name,@node.document)
+          nnew = Element.new(nnod)
+          nold = Element.new(@node)
+          nold.attributes.each do |attr|
+            nnew.attributes[attr.qname.name] = attr.value
+          end
+          nnew.add(nold.children)
+          nold.replace_by(nnew)
+          @node = nnod
+          @parent.instance_variable_set(:@element,@node)
+          @node.document.custom_namespace_prefixes_update
+          @node.document.ns_update
+          nil
+        end
+
+        def each(&block)
+          @node.namespace_definitions.each do |ns|
+            block.call Namespace.new(ns)
+          end
+        end
+
+        def delete_at(name)
+          if (name.respond_to?(:to_s) || name.nil?)
+            return false unless @node.namespace_definitions.one?{|e| e.prefix == name}
+
+            nnod = Nokogiri::XML::Node.new(@node.name,@node.document)
+            nnew = Element.new(nnod)
+            nold = Element.new(@node)
+            nold.attributes.each do |attr|
+              nnew.attributes[attr.qname.name] = attr.value
+            end
+            @node.namespace_definitions.each do |ns|
+              nnod.add_namespace_definition(ns.prefix,ns.href) unless ns.prefix == name
+            end
+            nnew.add(nold.children)
+            nold.replace_by(nnew)
+            @node = nnod
+            @parent.instance_variable_set(:@element,@node)
+            @node.document.custom_namespace_prefixes_update
+            @node.document.ns_update
+            true
+          else
+            false
+          end
+        end
+
+        def delete_if(&block)
+          nnod = Nokogiri::XML::Node.new(@node.name,@node.document)
+          nnew = Element.new(nnod)
+          nold = Element.new(@node)
+          nold.attributes.each do |attr|
+            nnew.attributes[attr.qname.name] = attr.value
+          end
+          @node.namespace_definitions.each do |ns| 
+            nnod.add_namespace_definition(ns.prefix,ns.href) unless block.call(Dom::smart_helper(ns))
+          end
+          nnew.add(nold.children)
+          nold.replace_by(nnew)
+          @node = nnod
+          @parent.instance_variable_set(:@element,@node)
+          @node.document.custom_namespace_prefixes_update
+          @node.document.ns_update
+          self
+        end
+      end  
+    
+    end
+  end  
+end  

data/lib/xml/smart_domnodeset.rb

@@ -0,0 +1,59 @@
+module XML
+  module Smart
+    class Dom
+
+      class NodeSet
+        include Enumerable
+
+        def initialize(nodeset)
+          @nodeset = nodeset
+        end
+
+        def ===(cls); self.is_a? cls; end
+
+        def first;        Dom::smart_helper(@nodeset.first); end
+        def last;         Dom::smart_helper(@nodeset.last); end
+        def at(*a);  Dom::smart_helper(@nodeset[*a]); end
+        def [](*a);  Dom::smart_helper(@nodeset[*a]); end
+
+        def length;       @nodeset.length; end
+        def empty?;       @nodeset.empty?; end
+        def delete_all!;  @nodeset.remove; @nodeset.to_a.each { |n| @nodeset.delete(n) }; true  end
+
+        def each(&block) 
+          @nodeset.each do |node| 
+            block.call Dom::smart_helper(node)
+          end
+        end
+
+        def delete_at(*a)
+          tmp = @nodeset[*a]
+          case tmp
+            when Nokogiri::XML::NodeSet
+              tmp.each { |node| @nodeset.delete(node.remove) }
+              true
+            when Nokogiri::XML::Node
+              @nodeset.delete(tmp.remove)
+              true
+            else
+              false
+          end
+        end
+
+        def delete_if(&block) 
+          tmp = []
+          @nodeset.each do |node| 
+            if block.call(Dom::smart_helper(node))
+              tmp << node.remove
+            end  
+          end    
+          tmp.each { |t| @nodeset.delete(t) }
+          self
+        end
+
+      end
+
+    end
+  end
+end  
+

data/lib/xml/smart_domother.rb

@@ -0,0 +1,16 @@
+module XML
+  module Smart
+    class Dom
+
+      class Other < Text
+        def otype
+          case @text
+            when Nokogiri::XML::Comment; :comment
+            else; :unknown
+          end
+        end
+      end
+    
+    end
+  end
+end  

data/lib/xml/smart_domtext.rb

@@ -0,0 +1,25 @@
+module XML
+  module Smart
+    class Dom
+
+      class Text
+        def initialize(text); @text = text; end
+
+        def ===(cls); self.is_a? cls; end
+
+        def dump; to_s; end
+        def to_s; @text.content.to_s; end
+        def to_f; @text.content.to_f; end
+        def to_i; @text.content.to_i; end
+
+        def text; @text.content; end
+        def text=(t); @text.content = t.to_s if t.respond_to? :to_s; end
+
+        def parent; Node.new(@text.parent); end
+
+        def path; @text.path; end
+      end
+    
+    end
+  end
+end