smile-xml 1.0.3-java

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

@@ -0,0 +1,132 @@
+package smile.xml;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyObject;
+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 smile.xml.util.UtilJ;
+
+@JRubyClass( name="LibXML::XML::Namespace" )
+public class NamespaceJ extends RubyObject {
+	
+	private static final long serialVersionUID = 4128551928821799987L;
+	
+	private static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+		public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+			return new NamespaceJ(runtime, klass);
+		}
+	};
+
+	public static RubyClass define(Ruby runtime) {
+		return UtilJ.defineClass(runtime, NamespaceJ.class, ALLOCATOR);
+	}
+
+	private static RubyClass getRubyClass(Ruby runtime) {
+		return UtilJ.getClass(runtime, NamespaceJ.class);
+	}
+	
+	public static NamespaceJ newInstance(ThreadContext context) {
+		return new NamespaceJ(context.getRuntime(), getRubyClass(context.getRuntime()));
+	}
+
+	public static NamespaceJ newInstance(ThreadContext context,	IRubyObject node, IRubyObject prefix, IRubyObject href) {
+		IRubyObject[] args = { node, prefix, href };
+		return (NamespaceJ) getRubyClass(context.getRuntime()).newInstance(context, args, null);
+	}
+	
+	private NodeJ node;
+	private RubyString prefix;
+	private RubyString href;
+
+	public NamespaceJ(Ruby runtime, RubyClass metaClass) {
+		super(runtime, metaClass);
+	}
+
+	@JRubyMethod(name = { "initialize" })
+	public void initialize(ThreadContext context, IRubyObject pNode, IRubyObject pPrefix, IRubyObject pHref) {
+		if ( ! (pNode instanceof NodeJ)) {
+			throw context.getRuntime().newTypeError("wrong argument type " + UtilJ.getRubyClassName(pNode) + " (expected Data)");
+		}
+		
+		node = ((NodeJ) pNode);
+		if (! pPrefix.isNil()) {
+			prefix = (RubyString) pPrefix;	
+		}
+		href = (RubyString) pHref;
+		
+		// define namespace as "xmlns" attribute
+		String name = prefix == null ? "xmlns" : "xmlns:" + prefix.asJavaString();
+		String value = href.asJavaString();
+		AttrJ.newInstance(context, node, UtilJ.toRubyString(context, name).asString(), 
+				UtilJ.toRubyString(context, value).asString(), this);
+	}
+
+	@JRubyMethod(name = { "prefix" })
+	public IRubyObject getPrefix(ThreadContext context) {
+		return UtilJ.nvl(this.prefix, context.getRuntime().getNil());
+	}
+
+	@JRubyMethod(name = { "href" })
+	public IRubyObject getHref(ThreadContext context) {
+		return UtilJ.nvl(this.href, context.getRuntime().getNil());
+	}
+
+	@JRubyMethod(name = { "node" })
+	public IRubyObject getNode(ThreadContext context) {
+		return this.node;
+	}
+	
+	@JRubyMethod(name = { "node_type" })
+	public IRubyObject getNodeType(ThreadContext context) {
+		return new RubyFixnum(context.getRuntime(), NodeJ.NAMESPACE_DECL);
+	}
+	
+	@JRubyMethod(name = { "next" })
+	public IRubyObject getNext(ThreadContext context) {
+		// TODO
+		return context.getRuntime().getNil();
+	}
+	
+	@JRubyMethod(name = { "==" })
+	public IRubyObject isEqual(ThreadContext context, IRubyObject pOther) {
+		if (pOther instanceof NamespaceJ) {
+			NamespaceJ otherNS = (NamespaceJ) pOther;
+			if (href.equals(otherNS.href) && node.equals(otherNS.node)
+					&& (prefix == null && otherNS.prefix == null 
+					|| prefix.equals(otherNS.prefix))) {
+				return context.getRuntime().getTrue();
+			}
+		}
+		return context.getRuntime().getFalse();
+	}
+	
+	@JRubyMethod(name = { "to_s" })
+	public IRubyObject toS(ThreadContext context) {
+		String str;
+		if (prefix != null) {
+			str = prefix.asJavaString() + ":" + href.asJavaString();
+		} else {
+			str = href.asJavaString();
+		}		
+		return context.getRuntime().newString(str);
+	}
+	
+	public void setNode(NodeJ node) {
+		this.node = node;
+	}
+	
+	public void setPrefix(RubyString prefix) {
+		this.prefix = prefix;
+	}
+	
+	public void setHref(RubyString href) {
+		this.href = href;
+	}
+}

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

@@ -0,0 +1,158 @@
+package smile.xml;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+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.Document;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+
+import smile.xml.util.UtilJ;
+
+@JRubyClass( name = "LibXML::XML::Namespaces", include = "Enumerable" )
+public class NamespacesJ extends RubyObject {
+	
+	private static final long serialVersionUID = 4673137342270845475L;
+	
+	private static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+		public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+			return new NamespacesJ(runtime, klass);
+		}
+	};
+
+	public static RubyClass define(Ruby runtime) {
+		return UtilJ.defineClass(runtime, NamespacesJ.class, ALLOCATOR);
+	}
+
+	private static RubyClass getRubyClass(Ruby runtime) {
+		return UtilJ.getClass(runtime, NamespacesJ.class);
+	}
+
+	public static NamespacesJ newInstance(ThreadContext context, NodeJ node) {
+		IRubyObject[] args = { node };
+		return (NamespacesJ) getRubyClass(context.getRuntime()).newInstance(context, args, null);
+	}
+	
+	private NodeJ node;
+
+	public NamespacesJ(Ruby runtime, RubyClass metaClass) {
+		super(runtime, metaClass);
+	}
+
+	@JRubyMethod(name = { "initialize" })
+	public void initialize(ThreadContext context, IRubyObject pNode) {
+		this.node = (NodeJ) pNode;
+	}
+	
+	@JRubyMethod(name = { "default" })
+	public IRubyObject getDefault(ThreadContext context) {
+		return findByPrefix(context, context.getRuntime().getNil());
+	}
+	
+	@JRubyMethod(name = { "default_prefix=" })
+	public void setDefaultPrefix(ThreadContext context, IRubyObject pPrefix) {
+		// TODO
+		throw context.getRuntime().newRuntimeError("not yet implemented");
+	}
+	
+	@JRubyMethod(name = { "definitions" })
+	public IRubyObject getDefinitions(ThreadContext context) {
+		// TODO
+		throw context.getRuntime().newRuntimeError("not yet implemented");
+	}
+	
+	@JRubyMethod(name = { "each" })
+	public void iterateOver(ThreadContext context, Block block) {
+		UtilJ.iterateOver(context, block, namespacesAsList(context));
+	}
+	
+	@JRubyMethod(name = { "find_by_href" })
+	public IRubyObject findByHref(ThreadContext context, IRubyObject pHref) {
+		// TODO
+		throw context.getRuntime().newRuntimeError("not yet implemented");
+	}
+	
+	@JRubyMethod(name = { "find_by_prefix" }, optional = 1)
+	public IRubyObject findByPrefix(ThreadContext context, IRubyObject pPrefix) {
+		// TODO
+		throw context.getRuntime().newRuntimeError("not yet implemented");
+	}
+
+	@JRubyMethod(name = { "namespace" })
+	public IRubyObject getNamespace(ThreadContext context) {
+		Ruby run = context.getRuntime();
+
+		String prefixStr = ((Node) node.getJavaObject()).getPrefix();
+		IRubyObject prefix = prefixStr == null ? run.getNil() : run.newString(prefixStr);
+
+		String uriStr = ((Node) node.getJavaObject()).getNamespaceURI();
+		IRubyObject uri = uriStr == null ? run.getNil() : run.newString(uriStr);
+		
+		if (uri.isNil()) {
+			return run.getNil();
+		} else {
+			return NamespaceJ.newInstance(context, node, prefix, uri);
+		}
+	}
+	
+	@JRubyMethod(name = { "namespace=" })
+	public void setNamespace(ThreadContext context, IRubyObject pNamespace) {
+		if ( ! (pNamespace instanceof NamespaceJ)) {
+			throw context.getRuntime().newTypeError("wrong argument type " + UtilJ.getRubyClassName(pNamespace) + " (expected Data)");
+		}
+		
+		NamespaceJ namespace = (NamespaceJ) pNamespace;
+		Document doc = node.getJavaObject().getOwnerDocument();
+		
+		String namespaceURI = "";
+		String qualifiedName = node.getJavaObject().getNodeName();
+		if (! namespace.getHref(context).isNil()) {
+			namespaceURI = namespace.getHref(context).asJavaString();
+		}
+		if (! namespace.getPrefix(context).isNil()) {
+			qualifiedName = namespace.getPrefix(context).asJavaString() + ":" + node.getJavaObject().getNodeName();
+		}
+		node.setJavaObject(doc.renameNode(node.getJavaObject(), namespaceURI, qualifiedName));
+	}
+	
+	@JRubyMethod(name = { "node" })
+	public IRubyObject getNode(ThreadContext context) {
+		return this.node;
+	}
+	
+	private List<NamespaceJ> namespacesAsList(ThreadContext context) {
+		NamedNodeMap attributes = node.getJavaObject().getAttributes();
+		List<NamespaceJ> list = new ArrayList<NamespaceJ>();
+		for (int i = 0; i < attributes.getLength(); i++) {
+			Node item = attributes.item(i);
+			String name = item.getNodeName();
+			if (name.startsWith("xmlns")) {
+				NamespaceJ ns = NamespaceJ.newInstance(context);
+				String prefix;
+				if (name.startsWith("xmlns:")) {
+					prefix = name.substring("xmlns:".length());
+					ns.setPrefix(context.getRuntime().newString(prefix));
+				} else if (name.equals("xmlns")) {
+					prefix = null;
+					ns.setPrefix(null);
+				} else {
+					continue;
+				}
+				ns.setNode(node);
+				String href = item.getNodeValue();
+				ns.setHref(context.getRuntime().newString(href));
+				list.add(ns);
+			}
+		}
+		return list;
+	}
+}