smile-xml 1.0.3-java

data/lib/xml/libxml.rb

@@ -0,0 +1 @@
+require 'xml'

data/lib/xml.rb

@@ -0,0 +1,5 @@
+require 'java'
+require File.join( File.dirname( __FILE__), 'smile-xml.jar' )
+
+ruby = JRuby.runtime
+Java::smile.xml.SmileXML.define(ruby);

data/src/main/java/smile/xml/AttrJ.java

@@ -0,0 +1,165 @@
+package smile.xml;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.w3c.dom.Attr;
+import org.w3c.dom.Document;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+
+import smile.xml.util.UtilJ;
+
+@JRubyClass( name="LibXML::XML::Attr" )
+public class AttrJ extends NodeJ {
+
+	private static final long serialVersionUID = -8068663140926376117L;
+
+	private static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+		public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+			return new AttrJ(runtime, klass);
+		}
+	};
+
+	public static RubyClass define(Ruby runtime) {
+		return UtilJ.defineClass( runtime, AttrJ.class, ALLOCATOR );
+	}
+
+	private static RubyClass getRubyClass(Ruby runtime) {
+		return UtilJ.getClass(runtime, AttrJ.class );
+	}
+
+	public static AttrJ newInstance(ThreadContext context) {
+		return (AttrJ) getRubyClass(context.getRuntime()).newInstance(context,
+				new IRubyObject[0], null);
+	}
+	
+	public static AttrJ newInstance(ThreadContext context, NodeJ node, RubyString name, RubyString value, NamespaceJ ns) {
+		IRubyObject[] args = { node, name, value, ns };
+		return (AttrJ) getRubyClass(context.getRuntime()).newInstance(context, args, null);
+	}
+
+	private NodeJ parent;
+	
+	private AttrJ(Ruby ruby, RubyClass clazz) {
+		super(ruby, clazz);
+	}
+
+	public void setParent( NodeJ node ) {
+		this.parent = node;
+	}
+	
+	@JRubyMethod(name = "initialize", optional = 4)
+	public void initialize(ThreadContext context, IRubyObject[] args) {
+		NodeJ node = (NodeJ) (args.length > 0 ? args[0] : null);
+		RubyString name = (RubyString) (args.length > 1 ? args[1] : null);
+		RubyString value = (RubyString) (args.length > 2 ? args[2] : null);
+		NamespaceJ ns = (NamespaceJ) (args.length > 3 ? args[3] : null);
+		
+		this.parent = node;
+		
+		if (node != null) {
+			Document doc = ((Node) node.getJavaObject()).getOwnerDocument();
+			Attr attr = doc.createAttribute(name.asJavaString());
+			attr.setNodeValue(value.asJavaString());
+			setJavaObject(attr);
+			node.getJavaObject().getAttributes().setNamedItem( attr );
+		}
+	}
+
+	@JRubyMethod(name = "next")
+	public IRubyObject getNext(ThreadContext context) {
+		
+		Node n = null;
+		
+		if( parent != null ) {
+			NamedNodeMap aa = parent.getJavaObject().getAttributes();
+		    for( int i=0; i<aa.getLength(); i++ ) {
+		
+		    	if( aa.item(i).equals( getJavaObject() ) ) {
+		    		if( i+1 < aa.getLength() )
+		    			n = aa.item(i+1);
+		    		break;
+		    	}
+		    }
+		}
+		
+		if( n == null )
+			return context.getRuntime().getNil();
+		
+	    AttrJ node = newInstance(context);
+	    node.setDocPresent( isDocPresent() );
+	    node.setJavaObject( n );
+	    node.setParent( parent );
+	    return node;
+ 
+	}
+
+	@JRubyMethod(name = "name")
+	public RubyString getName(ThreadContext context) {
+		if( getJavaObject().getLocalName() != null )
+			return context.getRuntime().newString( getJavaObject().getLocalName() );
+		return context.getRuntime().newString( getJavaObject().getNodeName() );
+	}
+
+	@JRubyMethod(name = "ns")
+	public IRubyObject getNs(ThreadContext context) {
+		if( getJavaObject().getNamespaceURI() != null ) {
+			RubyString prefix = null;
+			if( getJavaObject().getPrefix() != null )
+				prefix = context.getRuntime().newString( getJavaObject().getPrefix() );
+			RubyString uri = null;
+			if( getJavaObject().getNamespaceURI() != null)
+				uri = context.getRuntime().newString( getJavaObject().getNamespaceURI() );
+			return NamespaceJ.newInstance(context, this, prefix, uri );
+		}
+		return context.getRuntime().getNil();
+	}
+
+	@JRubyMethod(name = "parent")
+	public IRubyObject getParent(ThreadContext context) {
+		return parent;
+	}
+
+	@JRubyMethod(name = "parent?")
+	public IRubyObject hasParent(ThreadContext context) {
+		return toRubyBoolean( context, parent != null );
+	}
+
+	@JRubyMethod(name = "remove!")
+	public IRubyObject remove(ThreadContext context) {
+
+		
+		NamedNodeMap aa = parent.getJavaObject().getAttributes();
+		
+		if( aa != null ) {
+			aa.removeNamedItem( getJavaObject().getNodeName() );
+		}
+		
+		parent = null;
+		
+		return this;
+	}
+
+
+	@JRubyMethod(name = "value")
+	public RubyString getValue(ThreadContext context) {
+		return context.getRuntime().newString(
+				((Node) getJavaObject()).getNodeValue());
+	}
+
+	@JRubyMethod(name = "value=")
+	public void setValue(ThreadContext context, IRubyObject obj) {
+		((Node) getJavaObject()).setNodeValue(obj.asJavaString());
+	}
+
+	@JRubyMethod(name = "node_type_name")
+	public RubyString getTypeName(ThreadContext context) {
+		return super.getTypeName(context);
+	}
+}

data/src/main/java/smile/xml/AttributesJ.java

@@ -0,0 +1,219 @@
+package smile.xml;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyHash;
+import org.jruby.RubyString;
+import org.jruby.RubySymbol;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+
+import smile.xml.util.UtilJ;
+
+@JRubyClass(name = "LibXML::XML::Attributes", include = "Enumerable")
+public class AttributesJ extends BaseJ<Node> {
+
+	private static final long serialVersionUID = -2519312417704775509L;
+
+	private static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+		public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+			return new AttributesJ(runtime, klass);
+		}
+	};
+
+	public static RubyClass define(Ruby runtime) {
+		return UtilJ.defineClass(runtime, AttributesJ.class, ALLOCATOR);
+	}
+
+	private NodeJ parent;
+
+	public void setParent(NodeJ node) {
+		this.parent = node;
+	}
+
+	@JRubyMethod(name = { "initialize" })
+	public IRubyObject initialize(ThreadContext context) {
+		return this;
+	}
+
+	private static RubyClass getRubyClass(Ruby runtime) {
+		return UtilJ.getClass(runtime, new String[] { "LibXML", "XML",
+				"Attributes" });
+	}
+
+	public static AttributesJ newInstance(ThreadContext context) {
+		return (AttributesJ) getRubyClass(context.getRuntime()).newInstance(
+				context, new IRubyObject[0], null);
+	}
+
+	public AttributesJ(Ruby ruby, RubyClass clazz) {
+		super(ruby, clazz);
+	}
+
+	@JRubyMethod(name = "[]")
+	public IRubyObject getValue(ThreadContext context, IRubyObject pName) {
+		
+		String name = toJavaString(context, pName );		
+
+		NamedNodeMap aa = getJavaObject().getAttributes();
+		if ( aa == null ) {
+
+			return context.getRuntime().getNil();
+		}
+
+		Node node = aa.getNamedItem( name );
+
+
+
+		if (node == null) {
+
+			for( int i=0;i<aa.getLength(); i++ ) {
+				Node item = aa.item(i);
+//				System.out.println( item.get);
+				
+				if( item.getLocalName().equals( name ) ) {
+					node = item;
+					break;
+				}
+			}
+		}
+		
+		return context.getRuntime().newString(node.getTextContent());
+	}
+
+	@JRubyMethod(name = { "[]=" })
+	public void setValue(ThreadContext context, IRubyObject pName,
+			IRubyObject pValue) {
+		if ((pName instanceof RubySymbol)) {
+			pName = pName.asString();
+		}
+
+		RubyString name = (RubyString) pName;
+
+		RubyString value = (RubyString) pValue;
+
+		Node node = ((Node) getJavaObject()).getAttributes().getNamedItem(
+				name.asJavaString());
+		if (node == null) {
+			node = ((Node) getJavaObject()).getOwnerDocument().createAttribute(
+					name.asJavaString());
+			((Node) getJavaObject()).getAttributes().setNamedItem(node);
+		}
+
+		node.setNodeValue(value.asJavaString());
+	}
+
+	@JRubyMethod(name = { "each" })
+	public void iterateOver(ThreadContext context, Block block) {
+		UtilJ.iterateOver(context, block, attributesAsList(context));
+	}
+
+	@JRubyMethod(name = { "first" })
+	public IRubyObject first(ThreadContext context) {
+		AttrJ attr = null;
+		NamedNodeMap attributes = getJavaObject().getAttributes();
+		for (int i = 0; i < attributes.getLength(); i++) {
+			Node item = attributes.item(i);
+			if (UtilJ.isAttr(item)) {
+				attr = AttrJ.newInstance(context);
+				attr.setJavaObject(item);
+				attr.setParent(parent);
+				break;
+			}
+		}
+		return UtilJ.nvl(attr, context.getRuntime().getNil());
+	}
+
+	@JRubyMethod(name = { "get_attribute" })
+	public IRubyObject getAttribute(ThreadContext context, RubyString name) {
+		NamedNodeMap aa = getJavaObject().getAttributes();
+		String string = name.asJavaString();
+		Node node = aa.getNamedItem(string);
+		if (node == null)
+			for (int i = 0; i < aa.getLength(); i++) {
+				Node a = aa.item(i);
+				if (a.getLocalName().equals(string)) {
+					node = a;
+					break;
+				}
+			}
+		if (node != null) {
+			AttrJ attr = AttrJ.newInstance(context);
+			attr.setParent(parent);
+			attr.setJavaObject(node);
+			return attr;
+		}
+
+		return context.getRuntime().getNil();
+	}
+
+	@JRubyMethod(name = { "get_attribute_ns" })
+	public IRubyObject getAttributeNs(ThreadContext context,
+			RubyString namespace, RubyString name) {
+		Node node = ((Node) getJavaObject()).getAttributes().getNamedItemNS(
+				namespace.asJavaString(), name.asJavaString());
+		if (node != null) {
+			AttrJ attr = AttrJ.newInstance(context);
+			attr.setParent(parent);
+			attr.setJavaObject(node);
+			return attr;
+		}
+
+		return context.getRuntime().getNil();
+	}
+
+	@JRubyMethod(name = { "length" })
+	public RubyFixnum getLength(ThreadContext context) {
+		int length = attributesAsList(context).size();
+		return context.getRuntime().newFixnum(length);
+	}
+
+	@JRubyMethod(name = { "node" })
+	public NodeJ getNode(ThreadContext context) {
+		NodeJ node = NodeJ.newInstance(context);
+		node.setJavaObject(getJavaObject());
+		return node;
+	}
+
+	@JRubyMethod(name = { "to_h" })
+	public RubyHash toHash(ThreadContext context) {
+		Map map = new HashMap();
+
+		for (int i = 0; i < ((Node) getJavaObject()).getAttributes()
+				.getLength(); i++) {
+			Node a = ((Node) getJavaObject()).getAttributes().item(i);
+			map.put(context.getRuntime().newString(a.getNodeName()), context
+					.getRuntime().newString(a.getNodeValue()));
+		}
+		return RubyHash.newHash(context.getRuntime(), map, context.getRuntime()
+				.getNil());
+	}
+
+	private List<AttrJ> attributesAsList(ThreadContext context) {
+		NamedNodeMap attributes = ((Node) getJavaObject()).getAttributes();
+		List<AttrJ> list = new ArrayList<AttrJ>();
+		for (int i = 0; i < attributes.getLength(); i++) {
+			Node item = attributes.item(i);
+			if (! UtilJ.isAttr(item)) {
+				continue;
+			}
+			AttrJ node = AttrJ.newInstance(context);
+			node.setJavaObject(item);
+			node.setParent(parent);
+			list.add(node);
+		}
+		return list;
+	}
+}

data/src/main/java/smile/xml/BaseJ.java

@@ -0,0 +1,60 @@
+package smile.xml;
+
+import org.jruby.Ruby;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyClass;
+import org.jruby.RubyNil;
+import org.jruby.RubyObject;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import smile.xml.util.UtilJ;
+
+public class BaseJ<T> extends RubyObject {
+	
+	private static final long serialVersionUID = 4634403693609027673L;
+
+	private T javaObject;
+
+	public BaseJ(Ruby ruby, RubyClass clazz) {
+		super(ruby, clazz);
+	}
+
+	public T getJavaObject() {
+		return this.javaObject;
+	}
+
+	public void setJavaObject(T javaObject) {
+		this.javaObject = javaObject;
+	}
+	
+	public static <T> T nvl( T obj, T def ) {
+		return obj == null ? def : obj;
+	}
+	
+	public static IRubyObject toRubyBoolean(ThreadContext context, Object obj) {
+		
+		if( obj == null || obj instanceof RubyNil )
+			return context.getRuntime().getNil();
+		
+		if( obj instanceof RubyBoolean )
+			return (IRubyObject) obj;
+		
+		if( obj instanceof Boolean )
+			return ((Boolean)obj) ? context.getRuntime().getTrue() : context.getRuntime().getFalse();
+		
+			throw context.getRuntime().newArgumentError("");
+	}
+
+	public static String toJavaString(ThreadContext context, Object obj) {
+
+		return UtilJ.toJavaString(context, obj);
+	}
+
+	public static IRubyObject toRubyString(ThreadContext context, Object obj) {
+
+		return UtilJ.toRubyString( context, obj);
+	}
+
+
+}