smile-xml 1.0.0-jruby → 1.0.2-jruby

data/src/main/java/smile/xml/util/UtilJ.java

@@ -0,0 +1,424 @@
+package smile.xml.util;
+
+import java.io.StringWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.validation.SchemaFactory;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathFactory;
+
+import jline.Terminal;
+
+import org.jruby.Ruby;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.RubyNil;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.RubySymbol;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyModule;
+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 org.w3c.dom.NodeList;
+
+import smile.xml.EncodingJ;
+
+public class UtilJ {
+	private static final SchemaFactory schemaFactoryInstance = SchemaFactory
+			.newInstance( "http://www.w3.org/2001/XMLSchema");
+
+	private static final DocumentBuilderFactory factory = DocumentBuilderFactory
+			.newInstance();
+	private static final TransformerFactory transformerFactory;
+	private static final XPathFactory xpathFactory;
+	private static final ThreadLocal<DocumentBuilder> builderLocal;
+	private static final ThreadLocal<Transformer> transformerLocal;
+
+	public static TransformerFactory getTransformerFactory() {
+		return transformerFactory;
+	}
+
+	public static DocumentBuilderFactory getDocumentBuilderFactory() {
+		return factory;
+	}
+
+	public static DocumentBuilder getBuilder() {
+		return (DocumentBuilder) builderLocal.get();
+	}
+
+	public static Transformer getTransformer() {
+		return (Transformer) transformerLocal.get();
+	}
+
+	public static XPathFactory getXPathFactory() {
+		return xpathFactory;
+	}
+
+	public static XPath newXPath() {
+		return getXPathFactory().newXPath();
+	}
+
+	public static SchemaFactory getSchemaFactoryInstance() {
+		return schemaFactoryInstance;
+	}
+
+	private static List<String> split( String name ) {
+		List<String> list = new ArrayList<String>();
+		int i=0;
+		for( int j=name.indexOf("::"); j!=-1; j=name.indexOf("::", i )  ) {
+			list.add( name.substring(i,j) );
+			i = j+2;
+		}
+		list.add( name.substring(i) );
+		return list;
+	}
+	
+	public static RubyClass defineClass( Ruby runtime, Class<? extends RubyObject> klass, ObjectAllocator allocator ) {
+
+		JRubyClass anno     = klass.getAnnotation( JRubyClass.class );		
+		List<String> path   = split( anno.name()[0] );
+		String name         = path.remove( path.size()-1 );
+		List<String> parent = split( anno.parent() );
+		
+		RubyModule module = getModule( runtime, path );
+		RubyClass result = module.defineClassUnder( name, getClass(runtime, parent), allocator );
+		
+		for( String i : anno.include() ) {
+			result.includeModule( getModule(runtime, split(i) ) );
+		}
+		
+		result.defineAnnotatedMethods( klass );
+		
+		result.defineAnnotatedConstants( klass );
+		 
+		return result;
+	}
+
+	public static RubyModule defineModule( Ruby runtime, Class<?> klass ) {
+
+		JRubyModule anno    = klass.getAnnotation( JRubyModule.class );		
+		List<String> path   = split( anno.name()[0] );
+		String name         = path.remove( path.size()-1 );
+		
+		RubyModule module = getModule( runtime, path );
+		RubyModule result = module.defineModuleUnder( name );
+		
+		for( String i : anno.include() ) {
+			result.includeModule( getModule(runtime, split(i) ) );
+		}
+		
+		result.defineAnnotatedMethods( klass );
+		result.defineAnnotatedConstants( klass );
+		
+		return result;
+	}
+
+	public static IRubyObject toRubyString( ThreadContext context, Object obj ) {
+		
+		if( obj == null || obj instanceof RubyNil )
+			return context.getRuntime().getNil();
+		
+		if( obj instanceof RubyString )
+			return (RubyString) obj;
+		
+		if( obj instanceof String ) 
+			return context.getRuntime().newString( (String) obj );
+		
+		throw context.getRuntime().newTypeError("");
+	}
+
+	public static String toJavaString( ThreadContext context, Object obj ) {
+		return toJavaString(context, obj, null );
+	}
+	
+	public static <T> T nvl( T obj, T defaultValue ) {
+		return obj == null ? defaultValue : obj;
+	}
+	
+	public static String toJavaString( ThreadContext context, Object obj, String defaultValue ) {
+		
+		if( obj == null || obj instanceof RubyNil )
+			return defaultValue;
+		
+		if( obj instanceof RubyString )
+			return ((RubyString) obj).asJavaString();
+
+		if( obj instanceof RubySymbol )
+			return ((RubySymbol) obj).asJavaString();
+
+		if( obj instanceof String ) 
+			return (String) obj;
+		
+		throw context.getRuntime().newTypeError("");
+	}
+
+	public static RubyModule getModule(Ruby runtime, String...path) {
+		return getModule(runtime, Arrays.asList( path ) );
+	}
+	
+	public static RubyModule getModule(Ruby runtime, List<String> path) {
+		
+		if( path.isEmpty() )
+			return runtime.getObject();
+		
+		RubyModule m = runtime.fastGetModule( path.get(0) ) ;
+
+		for (int i = 1; i < path.size(); i++) {
+			IRubyObject tmp = m.fastGetConstant( path.get(i) );
+			if (tmp == null) {
+				tmp = m.defineModuleUnder( path.get(i) );
+			}
+			m = (RubyModule) tmp;
+		}
+
+		return m;
+	}
+
+	public static RubyClass getClass(Ruby runtime, Class<? extends RubyObject> klass ) {
+		
+		JRubyClass anno     = klass.getAnnotation( JRubyClass.class );		
+		List<String> path   = split( anno.name()[0] );
+		return getClass( runtime, path );
+	}
+	
+	public static RubyClass getClass(Ruby runtime, String...path) {
+		return getClass(runtime, Arrays.asList(path) );
+	}
+	
+	public static RubyClass getClass(Ruby runtime, List<String> path ) {
+		if (path.size() == 1) {
+			return runtime.fastGetClass( path.get(0) );
+		}
+		RubyModule m = runtime.fastGetModule( path.get(0) );
+
+		for (int i = 1; i < path.size() - 1; i++) {
+			IRubyObject tmp = m.fastGetConstant( path.get(i) );
+			if (tmp == null) {
+				tmp = m.defineModuleUnder( path.get(i) );
+			}
+			m = (RubyModule) tmp;
+		}
+
+		return m.fastGetClass( path.get( path.size() - 1) );
+	}
+
+	public static void iterateOver(ThreadContext context, Block block, Iterable<?> it) {
+		for (Iterator i$ = it.iterator(); i$.hasNext();) {
+			Object o = i$.next();
+			block.yield(context, (IRubyObject) o);
+			if (block.isEscaped())
+				break;
+		}
+	}
+
+	public static void write( Writer writer, Node node, boolean intent, String encoding ) {
+		try {
+				StreamResult result = new StreamResult(writer);
+				DOMSource source = new DOMSource(node);
+				Transformer transformer = getTransformer();
+				
+				if( encoding != null ) {
+					transformer.setOutputProperty( OutputKeys.ENCODING, encoding );
+				}
+				
+				
+				transformer.transform( source, result);				
+				
+		} catch( RuntimeException e) {
+			throw e;
+		} catch( Exception e ) {
+			throw new RuntimeException(e);
+		}
+	}
+
+
+	public static String toString(Node node, boolean escape ) {
+		return toString( node, escape, (String) null );
+	}
+	
+	public static String toString(Node node, boolean escape, EncodingJ encoding ) {
+		return toString( node, escape, encoding == null ? null : encoding.asJavaString() );
+	}
+	
+	public static String toString(Node node, boolean escape, String encoding ) {
+		StringWriter writer = new StringWriter();
+		try {
+			try { 
+				StreamResult result = new StreamResult(writer);
+				DOMSource source = new DOMSource(node);
+				Transformer transformer = getTransformer();
+				
+				//OMIT_XML_DECLARATION
+				if( encoding != null )
+					transformer.setOutputProperty( OutputKeys.ENCODING, encoding );
+				
+				transformer.transform(source, result);
+				
+				String str = writer.toString().replace(
+						"<?xml version=\"1.0\" encoding=\"UTF-8\"?>", "");
+				return str;
+			} finally {
+				writer.close();
+			}
+		} catch( RuntimeException e) {
+			throw e;
+		} catch( Exception e ) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	public static IRubyObject[] toStringArray(ThreadContext context,
+			Object array, int offset) {
+		List list;
+		if (array == null) {
+			list = new ArrayList(0);
+		} else {
+			if ((array instanceof List)) {
+				list = (List) array;
+			} else {
+				if (array.getClass().isArray())
+					list = Arrays.asList((Object[]) (Object[]) array);
+				else
+					throw context.getRuntime().newArgumentError(
+							array.getClass().getName() + " unsuported");
+			}
+		}
+		List result = new ArrayList();
+		for (int i = offset; i < list.size(); i++) {
+			if ((list.get(i) instanceof List))
+				result.addAll((List) list.get(i));
+			else if ((list.get(i) instanceof String))
+				result.add(context.getRuntime().newString((String) list.get(i)));
+			else {
+				result.add((IRubyObject) list.get(i));
+			}
+		}
+		ListIterator it = result.listIterator();
+		while (it.hasNext()) {
+			Object obj = it.next();
+			if ((obj instanceof RubyString))
+				continue;
+			it.set(context.getRuntime().newString(obj.toString()));
+		}
+		return (IRubyObject[]) result.toArray(new IRubyObject[result.size()]);
+	}
+
+	public static String toJavaString(Object object) {
+		if ((object instanceof RubyNil)) {
+			return null;
+		}
+		if ((object instanceof String)) {
+			return (String) object;
+		}
+		if ((object instanceof RubyString)) {
+			return ((RubyString) object).asJavaString();
+		}
+		if ((object instanceof RubySymbol)) {
+			return ((RubySymbol) object).asJavaString();
+		}
+		throw new IllegalArgumentException(object.getClass().getName()
+				+ " can not be a String");
+	}
+	
+	public static Boolean toJavaBoolean( ThreadContext context, Object object ) {
+		return toJavaBoolean(context, object, null );
+	}
+	
+	public static Boolean toJavaBoolean( ThreadContext context, Object object, Boolean defaultValue ) {
+
+		if ( object == null || object instanceof RubyNil) 
+			return defaultValue;
+		
+		if (object instanceof Boolean) 
+			return (Boolean) object;
+		
+		if (object instanceof RubyBoolean ) {
+			return ((RubyBoolean) object).isTrue();
+		}
+		
+		throw context.getRuntime().newArgumentError("");
+	}
+
+
+	public static RubyBoolean toBool(ThreadContext context, boolean value) {
+		return value ? context.getRuntime().getTrue() : context.getRuntime()
+				.getFalse();
+	}
+
+	static {
+		factory.setNamespaceAware(true);
+
+		transformerFactory = TransformerFactory.newInstance();
+
+		xpathFactory = XPathFactory.newInstance();
+
+		builderLocal = new ThreadLocal<DocumentBuilder>() {
+			protected DocumentBuilder initialValue() {
+				try {
+					return UtilJ.getDocumentBuilderFactory().newDocumentBuilder();
+				} catch (ParserConfigurationException e) {
+					throw new RuntimeException(e);
+				}
+			}
+
+			public DocumentBuilder get() {
+				DocumentBuilder builder = (DocumentBuilder) super.get();
+				builder.reset();
+				return builder;
+			}
+		};
+		transformerLocal = new ThreadLocal() {
+			protected Transformer initialValue() {
+				try {
+					return UtilJ.getTransformerFactory().newTransformer();
+				} catch (TransformerConfigurationException e) {
+					throw new RuntimeException(e);
+				}
+			}
+
+			public Transformer get() {
+				Transformer builder = (Transformer) super.get();
+				builder.reset();
+				return builder;
+			}
+		};
+	}
+
+	public static Node find( NamedNodeMap map, String name ) {
+		
+		Node node = map.getNamedItem( name );
+
+		if( node != null )
+			return node;
+		
+		for( int i=0;i<map.getLength(); i++ ) {
+			Node item = map.item(i);
+			
+			if( item.getLocalName().equals( name ) ) {
+				return item;
+			}
+		}
+		
+		return null;
+	}
+}

data/src/main/java/smile/xml/xpath/CustomNamespaceContext.java

@@ -0,0 +1,59 @@
+package smile.xml.xpath;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import javax.xml.namespace.NamespaceContext;
+
+import org.w3c.dom.Node;
+
+public class CustomNamespaceContext
+  implements NamespaceContext
+{
+  private final Map<String, String> namespaceMapping = new HashMap<String, String>();
+  private final Class<?> cl;
+  private final Object resolver;
+
+  public CustomNamespaceContext(Node node, String[] namespaces)
+  {
+    try
+    {
+      this.cl = Class.forName("com.sun.org.apache.xml.internal.utils.PrefixResolverDefault", true, getClass().getClassLoader());
+      this.resolver = this.cl.getConstructor(new Class[] { Node.class }).newInstance(new Object[] { node });
+    } catch (RuntimeException e) {
+      throw e;
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+    for (String ns : namespaces) {
+      int i = ns.indexOf(':');
+      this.namespaceMapping.put(ns.substring(0, i), ns.substring(i + 1));
+    }
+  }
+
+  public String getNamespaceURI(String prefix)
+  {
+    String uri = (String)this.namespaceMapping.get(prefix);
+    if (uri != null)
+      return uri;
+    try {
+      String r = (String)this.cl.getMethod("getNamespaceForPrefix", new Class[] { String.class }).invoke(this.resolver, new Object[] { prefix });
+      return r;
+    } catch (RuntimeException e) {
+      throw e; } catch (Exception e) {
+    	  throw new RuntimeException(e);
+    }
+    
+  }
+
+  public String getPrefix(String namespaceURI)
+  {
+    return null;
+  }
+
+  public Iterator<?> getPrefixes(String namespaceURI)
+  {
+    return null;
+  }
+}

data/src/main/java/smile/xml/xpath/XPathContextJ.java

@@ -0,0 +1,154 @@
+package smile.xml.xpath;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyHash;
+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.DocumentJ;
+import smile.xml.NamespaceJ;
+import smile.xml.NamespacesJ;
+import smile.xml.NodeJ;
+import smile.xml.util.UtilJ;
+
+@JRubyClass(name="LibXML::XML::XPath::Context")
+public class XPathContextJ extends RubyObject {
+	
+	private static final long serialVersionUID = -5768331253256181175L;
+	
+	private static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+		public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+			return new XPathContextJ(runtime, klass);
+		}
+	};
+
+	private final Map<String, String> namespaceMapping = new HashMap<String, String>();
+	private DocumentJ document;
+	private NodeJ node;
+
+	public static RubyClass define(Ruby runtime) {
+		return UtilJ.defineClass( runtime, XPathContextJ.class, ALLOCATOR );
+	}
+
+	private static RubyClass getRubyClass(Ruby runtime) {
+		return UtilJ.getClass(runtime, XPathContextJ.class);
+	}
+
+	public static XPathContextJ newInstance(ThreadContext context,
+			DocumentJ document) {
+		IRubyObject[] args = { document };
+		return (XPathContextJ) getRubyClass(context.getRuntime()).newInstance(
+				context, args, null);
+	}
+
+	private XPathContextJ(Ruby runtime, RubyClass metaClass) {
+		super(runtime, metaClass);
+	}
+
+	@JRubyMethod(name = { "initialize" }, optional = 1)
+	public void initialize(ThreadContext context, IRubyObject[] args) {
+		if (args.length > 0)
+			this.document = ((DocumentJ) args[0]);
+	}
+
+	@JRubyMethod(name = { "doc" })
+	public IRubyObject getDocument(ThreadContext context) {
+		return this.document;
+	}
+
+	@JRubyMethod(name = { "register_namespace" })
+	public IRubyObject registerNamespace(ThreadContext context,
+			IRubyObject pPrefix, IRubyObject pUri) {
+		String prefix = pPrefix.asJavaString();
+		String uri = pUri.asJavaString();
+		this.namespaceMapping.put(prefix, uri);
+
+		return context.getRuntime().getTrue();
+	}
+
+	@JRubyMethod(name = { "register_namespaces" }, rest = true)
+	public IRubyObject registerNamespaces(ThreadContext context,
+			IRubyObject[] args) {
+		for (int i = 0; i < args.length; i++) {
+			if ((args[i] instanceof RubyString)) {
+				String str = args[i].asJavaString();
+				int j = str.indexOf(':');
+				this.namespaceMapping.put(str.substring(0, j),
+						str.substring(j + 1));
+			} else {
+				if ((args[i] instanceof RubyHash)) {
+					RubyHash hash = (RubyHash) args[i];
+					for( Object obj : hash.entrySet() ) {
+						Map.Entry<?,?> entry = (Map.Entry<?,?>) obj;
+						String prefix = UtilJ.toJavaString(entry.getKey());
+						String uri = UtilJ.toJavaString(entry.getValue());
+						this.namespaceMapping.put(prefix, uri);
+					}
+				} else if ((args[i] instanceof RubyArray)) {
+					RubyArray array = (RubyArray) args[i];
+
+					for (IRubyObject obj : UtilJ.toStringArray(context, array,
+							0)) {
+						String str = obj.asJavaString();
+						int x = str.indexOf(':');
+						this.namespaceMapping.put(str.substring(0, x),
+								str.substring(x + 1));
+					}
+				} else {
+					throw context.getRuntime().newArgumentError(
+							"unsupported argument type "
+									+ args[i].getMetaClass().getName());
+				}
+			}
+		}
+		return this;
+	}
+
+	@JRubyMethod(name = { "register_namespaces_from_node" })
+	public IRubyObject registerNamespacesFromNode(ThreadContext context,
+			IRubyObject pNode) {
+		NodeJ node = (NodeJ) pNode;
+		NamespacesJ namespaces = node.getNamespaces(context);
+		IRubyObject ns = namespaces.getNamespace(context);
+		if ((ns instanceof NamespaceJ)) {
+			NamespaceJ nss = (NamespaceJ) ns;
+			IRubyObject prefix = nss.getPrefix(context);
+			IRubyObject uri = nss.getHref(context);
+			if ((!prefix.isNil()) && (!uri.isNil())) {
+				this.namespaceMapping.put(prefix.asJavaString(),
+						uri.asJavaString());
+			}
+		}
+		return this;
+	}
+
+	@JRubyMethod(name = "find")
+	public IRubyObject find(ThreadContext context, IRubyObject pXpath) {
+		IRubyObject[] array = new IRubyObject[this.namespaceMapping.size()];
+		int i = 0;
+		for (Map.Entry<String,String> e : this.namespaceMapping.entrySet()) {
+			array[i] = context.getRuntime().newString(
+					(String) e.getKey() + ":" + (String) e.getValue());
+			i++;
+		}
+		if ((this.node instanceof NodeJ)) {
+			return XPathObjectJ.newInstance(context, pXpath, this.node, array);
+		}
+		return XPathObjectJ.newInstance(context, pXpath, this.document, array);
+	}
+
+	@JRubyMethod(name = { "node=" })
+	public void setNode(ThreadContext context, IRubyObject pNode) {
+		this.node = ((NodeJ) pNode);
+	}
+}

data/src/main/java/smile/xml/xpath/XPathExpressionJ.java

@@ -0,0 +1,62 @@
+package smile.xml.xpath;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+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::XPath::Expression" )
+public class XPathExpressionJ extends RubyObject {
+	
+	private static final long serialVersionUID = 9176572911090989553L;
+	
+	private static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+		
+		public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+			return new XPathExpressionJ(runtime, klass);
+		}
+	};
+
+	public static RubyClass define(Ruby runtime) {
+		return UtilJ.defineClass(runtime, XPathExpressionJ.class, ALLOCATOR);
+	}
+
+	private static RubyClass getRubyClass(Ruby runtime) {
+		return UtilJ.getClass(runtime, XPathExpressionJ.class);
+	}
+
+	@JRubyMethod( name="compile", module=true )
+	public static XPathExpressionJ compile(ThreadContext context, IRubyObject self, IRubyObject pString ) {
+		RubyString string = (RubyString) pString;
+		return newInstance(context, string );		
+	}
+	
+	public static XPathExpressionJ newInstance(ThreadContext context, RubyString string ) {
+		IRubyObject[] args = { string };
+		return (XPathExpressionJ) getRubyClass(context.getRuntime()).newInstance(
+				context, args, null);
+	}
+
+	private XPathExpressionJ(Ruby runtime, RubyClass metaClass) {
+		super(runtime, metaClass);
+	}
+
+	private RubyString string;
+	
+	@JRubyMethod(name = "initialize" )
+	public void initialize(ThreadContext context, RubyString pString ) {
+		string = pString;
+	}
+	
+	public RubyString getExpression() {
+		return string;
+	}
+
+}