libxml-jruby 1.0.0

data/History.txt

@@ -0,0 +1,4 @@
+== 1.0.0 / 2008-09-20
+
+* 1 major enhancement
+  * Birthday!

data/README.txt

@@ -0,0 +1,50 @@
+libxml-jruby
+    by Michael Guterl
+    http://diminishing.org
+
+== DESCRIPTION:
+
+LibXMLJRuby is a LibXMLRuby compatibility layer that mimcs the LibXMLRuby 
+interface as closely as possible.  LibXMLJRuby does not use libxml at all 
+it just delegates the methods to the appropriate underlying Java class.
+
+== FEATURES/PROBLEMS:
+
+* FIXME (list of features or problems)
+
+== SYNOPSIS:
+
+  FIXME (code sample of usage)
+
+== REQUIREMENTS:
+
+* FIXME (list of requirements)
+
+== INSTALL:
+
+jruby -S gem install dylanvaughn-libxml-jruby --source=http://gems.github.com
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 FIXME (different license?)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,19 @@
+#require 'libxml-jruby'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "libxml-jruby"
+    s.summary = "Libxml replacement for JRuby"
+    s.email = "uwelk@xhochy.org"
+    s.homepage = "http://github.com/xhochy/libxml-jruby"
+    s.description = "Lixml replacement for JRuby in 100% Java"
+    s.authors = ["Michael Guterl", "Uwe L. Korn"]
+    s.files =  FileList["[A-Z]*", "{lib}/**/*"]
+    #s.add_dependency ''
+  end
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+# EOF

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/VERSION.yml

@@ -0,0 +1,5 @@
+---
+:minor: 0
+:patch: 0
+:major: 1
+

data/lib/libxml-jruby.rb

@@ -0,0 +1,84 @@
+# $Id$
+
+# Equivalent to a header guard in C/C++
+# Used to prevent the class/module from being loaded more than once
+unless defined? LibXMLJRuby
+
+module LibXMLJRuby
+
+  # :stopdoc:
+  VERSION = '1.0.0'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, *args)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, *args)
+  end
+
+  # Utility method used to rquire all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+end  # module LibXMLJRuby
+
+require 'java'
+require 'stringio'
+
+# these use include_class to avoid conflicts with Rake's top-level
+# import method, the issue doesn't seem to occur when not using a
+# string.
+include_class 'com.sun.org.apache.xml.internal.utils.PrefixResolver'
+include_class 'com.sun.org.apache.xml.internal.utils.PrefixResolverDefault'
+include_class 'org.xml.sax.InputSource'
+
+include_class 'java.io.ByteArrayInputStream'
+include_class 'java.io.StringReader'
+include_class 'java.io.StringWriter'
+
+include_class 'javax.xml.parsers.DocumentBuilder'
+include_class 'javax.xml.parsers.DocumentBuilderFactory'
+include_class 'javax.xml.transform.stream.StreamSource'
+include_class 'javax.xml.transform.stream.StreamResult'
+include_class 'javax.xml.transform.TransformerFactory'
+include_class 'javax.xml.transform.dom.DOMSource'
+include_class 'javax.xml.validation.Schema'
+include_class 'javax.xml.validation.SchemaFactory'
+include_class 'javax.xml.xpath.XPath'
+include_class 'javax.xml.xpath.XPathFactory'
+include_class 'javax.xml.xpath.XPathConstants'
+
+
+LibXMLJRuby.require_all_libs_relative_to __FILE__
+::LibXML = ::LibXMLJRuby
+
+end  # unless defined?
+
+# EOF

data/lib/libxml-jruby/xml.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/xml/node'

data/lib/libxml-jruby/xml/attr.rb

@@ -0,0 +1,46 @@
+module LibXMLJRuby
+  module XML
+    class Attr < Node
+      class << self
+        def from_java(java_obj)
+          return nil unless java_obj
+          a = allocate
+          a.java_obj = java_obj
+          a
+        end
+      end
+      
+      attr_accessor :java_obj
+      
+      def initialize(node, name, value, ns = nil)
+        self.java_obj = node.java_obj
+        java_obj.set_attribute(name, value)
+      end
+      
+      def remove!
+        java_obj.owner_element.remove_attribute(name)
+      end
+      
+      def parent?
+        !!parent
+      end
+      
+      def parent
+        XML::Node.from_java(java_obj.owner_element)
+      end
+      
+      def name
+        java_obj.respond_to?(:name) ? java_obj.name : java_obj.node_name
+      end
+      
+      def value
+        java_obj.value
+      end
+      
+      def value=(value)
+        raise TypeError if value.nil?
+        java_obj.value = value
+      end
+    end
+  end
+end

data/lib/libxml-jruby/xml/attributes.rb

@@ -0,0 +1,68 @@
+module LibXMLJRuby
+  module XML
+    class Attributes
+      include Enumerable
+      
+      class << self
+        def from_java(java_obj)
+          attrs = XML::Attributes.new
+          attrs.java_obj = java_obj
+          attrs
+        end
+      end
+      
+      attr_accessor :java_obj
+      
+      def initialize
+        @attribute_cache = {}
+      end
+            
+      def each
+        i = 0
+        while(i < length)
+          yield get_attribute(java_obj.attributes.item(i).name)
+          i += 1
+        end
+      end
+            
+      def length
+        java_obj.attributes.length
+      end
+      
+      def [](name)
+        attr = get_attribute(name)
+        attr ? attr.value : nil
+      end
+      
+      def []=(name, value)
+        attr = get_attribute(name)
+        if attr
+          attr.value = value
+        else
+          java_obj.setAttribute(name.to_s, value.to_s)
+        end
+      end
+      
+      def get_attribute_ns(name, ns)
+        attr = java_obj.get_attribute_node_ns(name, ns)
+        attr ? nil : XML::Attr.from_java(attr)
+      end
+      
+      def get_attribute(name)
+        if @attribute_cache[name.to_s]
+          @attribute_cache[name.to_s]
+        elsif java_obj && java_obj.attributes
+          attr = java_obj.attributes.get_named_item(name.to_s)
+          if attr
+            @attribute_cache[name.to_s] = XML::Attr.from_java(attr)
+            @attribute_cache[name.to_s]
+          else
+            nil
+          end
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/libxml-jruby/xml/document.rb

@@ -0,0 +1,52 @@
+module LibXMLJRuby
+  module XML
+    class Document
+      class << self
+        def file(filename)
+          XML::Parser.file(filename).parse
+        end
+        
+        def string(str)
+          XML::Parser.string(str).parse
+        end
+        
+        def from_java(java_obj)
+          d = new
+          d.java_obj = java_obj
+          d
+        end
+      end
+      
+      attr_accessor :java_obj # org.w3c.dom.Document
+
+      def initialize(xml_version = 1.0)
+        @xml_version = xml_version
+        @xpath_cache = {}
+      end
+      
+      def validate(dtd)
+        dtd.validate(self)
+      end
+      
+      def find(expr, nslist = nil)
+        @xpath_cache[[expr, nslist]] ||= XML::XPath::Object.new(expr, self, nslist)
+      end
+      
+      def find_first(expr, nslist = nil)
+        find(expr, nslist).first
+      end
+      
+      def child?
+        java_obj.hasChildNodes
+      end
+      
+      def parent?
+        !!java_obj.parent_node
+      end
+      
+      def root
+        @root ||= Node.from_java(java_obj.document_element)
+      end
+    end    
+  end
+end

data/lib/libxml-jruby/xml/dtd.rb

@@ -0,0 +1,25 @@
+module LibXMLJRuby
+  module XML
+    class Dtd
+      def initialize(schema)
+        @schema = schema
+      end
+      
+      def validate(doc)
+        validator.validate(doc)
+      end
+      
+      def schema_factory
+        SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema")
+      end
+      
+      def schema
+        schema = schema_factory.newSchema(StreamSource.new(ByteArrayInputStream.new(@schema.to_java_bytes)))        
+      end
+      
+      def validator
+        schema.newValidator
+      end
+    end
+  end
+end

data/lib/libxml-jruby/xml/node.rb

@@ -0,0 +1,285 @@
+module LibXMLJRuby
+  module XML
+    class Node
+      ATTRIBUTE_NODE = org.w3c.dom.Node.ATTRIBUTE_NODE
+      CDATA_SECTION_NODE = org.w3c.dom.Node.CDATA_SECTION_NODE
+      COMMENT_NODE = org.w3c.dom.Node.COMMENT_NODE
+      DOCUMENT_FRAG_NODE = org.w3c.dom.Node.DOCUMENT_FRAGMENT_NODE
+      DOCUMENT_NODE = org.w3c.dom.Node.DOCUMENT_NODE
+      DOCUMENT_TYPE_NODE = org.w3c.dom.Node.DOCUMENT_TYPE_NODE
+      ELEMENT_NODE = org.w3c.dom.Node.ELEMENT_NODE      
+      ENTITY_NODE = org.w3c.dom.Node.ENTITY_NODE
+      ENTITY_REFERENCE_NODE = org.w3c.dom.Node.ENTITY_REFERENCE_NODE
+      NOTATION_NODE = org.w3c.dom.Node.NOTATION_NODE
+      PROCESSING_INSTRUCTION_NODE = org.w3c.dom.Node.PROCESSING_INSTRUCTION_NODE
+      TEXT_NODE = org.w3c.dom.Node.TEXT_NODE
+      
+      class << self
+        def from_java(java_obj)
+          return nil if java_obj.nil?
+          n = allocate
+          n.java_obj = java_obj
+          n
+        end
+      end
+      
+      include Enumerable
+      
+      attr_accessor :java_obj # org.w3c.dom.Element(Node?)
+      
+      def initialize(name, content = nil)
+        jdoc = DocumentBuilderFactory.new_instance.new_document_builder.new_document
+        self.java_obj = jdoc.createElement(name)
+        self.content = content
+      end
+
+      def name
+        java_obj.node_name ||= @name
+      end
+      
+      def content
+        java_obj.text_content ||= @content
+      end
+      
+      def name=(name)
+        @name = name
+        java_obj.node_name = @name if @name
+      end
+
+      def base
+        b = java_obj.getAttributeNS('xml', 'base')
+        b.empty? ? nil : b
+      end
+
+      def content=(content)
+        @content = content
+        java_obj.node_value = @value if @value
+      end
+      
+      def child_add(node)
+        java_obj.getOwnerDocument.adoptNode(node.java_obj)
+        java_obj.appendChild(node.java_obj) # should this be importNode?
+      end
+      
+      def copy(deep = false)
+        XML::Node.from_java(java_obj.cloneNode(deep))
+      end
+      
+      def <<(node)
+        
+      end
+      
+      def each(&block)
+        children.each(&block)
+      end
+      
+      def each_element
+        if block_given?
+          each do |node|
+            yield(node) if node.node_type == ELEMENT_NODE
+          end
+        else
+          select do |node|
+            node.node_type == org.w3c.dom.Node.ELEMENT_NODE
+          end
+        end
+      end
+      
+      def find(expr)
+        XML::XPath::Object.new(expr, java_obj)
+      end
+      
+      def find_first(expr)
+        raise TypeError if java_obj.nil?
+        find(expr).first
+      end
+      
+      def node_type
+        java_obj.node_type
+      end
+      
+      def node_type_name
+        case node_type
+          # Most common choices first
+          when ATTRIBUTE_NODE
+            'attribute'
+          when DOCUMENT_NODE
+            'document_xml'
+          when ELEMENT_NODE
+            'element'
+          when TEXT_NODE
+            'text'
+          
+          # Now the rest  
+          when ATTRIBUTE_DECL
+            'attribute_decl'
+          when CDATA_SECTION_NODE
+            'cdata'
+          when COMMENT_NODE
+            'comment'
+          when DOCB_DOCUMENT_NODE
+            'document_docbook'
+          when DOCUMENT_FRAG_NODE
+            'fragment'
+          when DOCUMENT_TYPE_NODE
+            'doctype'
+          when DTD_NODE
+            'dtd'
+          when ELEMENT_DECL
+            'elem_decl'
+          when ENTITY_DECL
+            'entity_decl'
+          when ENTITY_NODE
+            'entity'
+          when ENTITY_REF_NODE
+            'entity_ref'
+          when HTML_DOCUMENT_NODE
+            'document_html'
+          when NAMESPACE_DECL
+            'namespace'
+          when NOTATION_NODE
+            'notation'
+          when PI_NODE
+            'pi'
+          when XINCLUDE_START
+            'xinclude_start'
+          when XINCLUDE_END
+            'xinclude_end'
+          else
+            raise(UnknownType, "Unknown node type: %n", node.node_type);
+        end          
+      end
+      
+      def first
+        child
+      end
+      
+      def children
+        @children ||= XML::Node::Set.from_java(java_obj.getChildNodes).to_a
+      end
+      
+      def child?
+        !!child
+      end
+      
+      def prev?
+        !!prev
+      end
+      
+      def next?
+        !!self.next
+      end
+      
+      def parent?
+        !!parent
+      end
+      
+      def parent
+        @parent ||= XML::Node.from_java(java_obj.parent_node)
+      end
+      
+      def prev
+        @prev ||= XML::Node.from_java(java_obj.previous_sibling)
+      end
+      
+      def last
+        @last ||= XML::Node.from_java(java_obj.last_child)
+      end
+      
+      def child
+        @child ||= XML::Node.from_java(java_obj.first_child)
+      end
+            
+      def next
+        @next ||= XML::Node.from_java(java_obj.next_sibling)
+      end 
+      
+      def attributes
+        @attributes ||= XML::Attributes.from_java(java_obj)
+      end
+      
+      def [](name)
+        attributes[name]
+      end
+      
+      def []=(name, value)
+        attributes[name] = value
+      end
+      
+      def ==(other)
+        eql?(other)
+      end
+      
+      def eql?(other)
+        return false if other.nil?
+        raise TypeError unless self.class === other
+        (java_obj.eql?(other.java_obj) || self.to_s == other.to_s)
+      end
+      
+      def equal?(other)
+        self.class === other && java_obj.equal?(other.java_obj)
+      end
+            
+      def doc
+        @doc ||= XML::Document.from_java(java_obj.owner_document)
+      end
+      
+      def to_s
+        transformer = TransformerFactory.newInstance.newTransformer
+        result = StreamResult.new(StringWriter.new)
+        source = DOMSource.new(java_obj)
+        transformer.transform(source, result)
+        result.getWriter.toString
+      end
+      
+      def document?
+        doc == self
+      end
+            
+      alias :properties :attributes
+      
+      class Set
+        class << self
+          def from_java(java_obj)
+            s = new
+            s.java_obj = java_obj
+            s
+          end
+        end
+        
+        include Enumerable
+        
+        attr_accessor :java_obj
+        
+        def initialize
+          @java_obj = java_obj
+          @node_cache = {}
+        end
+        
+        def length
+          java_obj.length
+        end
+        
+        def empty?
+          java_obj.length < 1
+        end
+        
+        def [](index)
+          @node_cache[index] ||= XML::Node.from_java(java_obj.item(index))
+        end
+        
+        def first
+          self[0]
+        end
+        
+        def each
+          i = 0
+          while(i < java_obj.length)
+            yield self[i]
+            i += 1
+          end
+        end
+      end
+    end
+  end
+end