smile-xml 1.0.0-jruby → 1.0.2-jruby

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

@@ -0,0 +1,90 @@
+package smile.xml;
+
+import javax.xml.xpath.XPathExpressionException;
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyNumeric;
+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 smile.xml.util.UtilJ;
+
+@JRubyClass(name = "LibXML::XML::Node::Set", include = "Enumerable") 
+public class NodeSetJ extends RubyObject {
+	
+	private static final long serialVersionUID = 8212708453693594157L;
+	
+	public static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+		public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+			return new NodeSetJ(runtime, klass);
+		}
+	};
+	
+	private RubyArray array;
+
+	public static RubyClass define(Ruby runtime) {
+		return UtilJ.defineClass(runtime, NodeSetJ.class, ALLOCATOR);
+	}
+
+	private static RubyClass getRubyClass(Ruby runtime) {
+		return UtilJ.getClass(runtime, NodeSetJ.class);
+	}
+
+	public static NodeSetJ newInstance(ThreadContext context, RubyArray array) {
+		return (NodeSetJ) getRubyClass(context.getRuntime()).newInstance(
+				context, new IRubyObject[] { array }, null);
+	}
+
+	private NodeSetJ(Ruby runtime, RubyClass metaClass) {
+		super(runtime, metaClass);
+	}
+
+	@JRubyMethod(name = { "initialize" })
+	public void initialize(ThreadContext context, IRubyObject pArray) {
+		this.array = ((RubyArray) pArray);
+	}
+
+	@JRubyMethod(name = { "[]" })
+	public IRubyObject get(ThreadContext context, IRubyObject pIndex)
+			throws XPathExpressionException {
+		RubyNumeric index = (RubyNumeric) pIndex;
+		return (IRubyObject) this.array.get((int) index.getLongValue());
+	}
+
+	@JRubyMethod(name = { "each" })
+	public void each(ThreadContext context, Block block) {
+		for (int i = 0; i < this.array.getLength(); i++) {
+			IRubyObject obj = (IRubyObject) this.array.get(i);
+			block.yield(context, obj);
+			if (block.isEscaped())
+				break;
+		}
+	}
+
+	@JRubyMethod(name = { "empty?" })
+	public RubyBoolean isEmpty(ThreadContext context)
+			throws XPathExpressionException {
+		return UtilJ.toBool(context, this.array.isEmpty());
+	}
+
+	@JRubyMethod(name = { "first" })
+	public IRubyObject getFirst(ThreadContext context)
+			throws XPathExpressionException {
+		if (this.array.isEmpty())
+			return context.getRuntime().getNil();
+		return (NodeJ) this.array.get(0);
+	}
+
+	@JRubyMethod(name = { "length" }, alias = { "size" })
+	public RubyFixnum getLength(ThreadContext context)
+			throws XPathExpressionException {
+		return context.getRuntime().newFixnum(this.array.getLength());
+	}
+}

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

@@ -0,0 +1,44 @@
+package smile.xml;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyClass;
+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::Parser::Context" )
+public class ParserContextJ extends RubyObject {
+
+
+	private static final long serialVersionUID = -1085726141041314973L;
+	
+	private static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+		public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+			return new ParserContextJ(runtime, klass);
+		}
+	};
+
+	public static RubyClass define(Ruby runtime) {
+		return UtilJ.defineClass(runtime, ParserContextJ.class, ALLOCATOR);
+	}
+
+	private static RubyClass getRubyClass( ThreadContext context ) {
+		return UtilJ.getClass( context.getRuntime(), ParserContextJ.class );
+	}
+
+	private ParserContextJ(Ruby runtime, RubyClass metaClass) {
+		super(runtime, metaClass);
+	}
+
+	public static IRubyObject newInstance(ThreadContext context) {
+		IRubyObject[] args = {};
+		return getRubyClass(context).newInstance( context, args, null );
+	}
+
+
+
+}

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

@@ -0,0 +1,196 @@
+package smile.xml;
+
+import java.io.File;
+import java.io.StringReader;
+
+import javax.xml.parsers.DocumentBuilder;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyHash;
+import org.jruby.RubyModule;
+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 org.w3c.dom.Document;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXParseException;
+
+import smile.xml.util.UtilJ;
+
+@JRubyClass(name = "LibXML::XML::Parser" )
+public class ParserJ extends RubyObject {
+	
+	private static final long serialVersionUID = 4634367713101505188L;
+	
+	private static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+		public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+			return new ParserJ(runtime, klass);
+		}
+	};
+	
+	private RubyString fileName;
+	private RubyString string;
+
+	public static RubyClass define(Ruby runtime) {
+		return UtilJ.defineClass(runtime, ParserJ.class, ALLOCATOR );
+	}
+
+	private static RubyClass getRubyClass(ThreadContext context) {
+		return UtilJ.getClass(context.getRuntime(), ParserJ.class);
+	}
+
+	private static ParserJ newInstance(ThreadContext context) {
+		IRubyObject[] args = {};
+		return (ParserJ) getRubyClass( context ).newInstance(context, args, null);
+	}
+
+	public ParserJ(Ruby runtime, RubyClass metaClass) {
+		super(runtime, metaClass);
+	}
+
+	public static ParserJ fromFile(ThreadContext context, IRubyObject pName,
+			IRubyObject pHash) {
+		IRubyObject[] args = { pName, pHash };
+		return fromFile(context, getRubyClass(context), args );
+	}
+
+	@JRubyMethod(name = "file", module = true, required=1, optional=1)
+	public static ParserJ fromFile(ThreadContext context, IRubyObject klass, IRubyObject[] args ) {
+		
+		if( args.length == 0 || args[0].isNil() )
+			throw context.getRuntime().newTypeError("can't convert nil into String");
+		
+		RubyString name = (RubyString) args[0];
+
+		if( new File( name.asJavaString() ).exists() == false )
+			throw ErrorJ.newRaiseException(context, "Warning: failed to load external entity \"" + name.asJavaString() + "\".");
+		
+		if( args.length > 1 && args[1].isNil()==false ) {
+			RubyHash hash = (RubyHash) args[1];
+			hash.get(context.getRuntime().newSymbol("encoding"));
+			hash.get(context.getRuntime().newSymbol("options"));
+		}
+
+		ParserJ parser = ParserJ.newInstance(context);
+		parser.fileName = name;
+		return parser;
+	}
+
+
+	@JRubyMethod(name = { "initialize" }, optional = 1)
+	public void initialize(ThreadContext context, IRubyObject[] args) {
+	}
+
+	@JRubyMethod(name = { "io=" })
+	public void setIo(ThreadContext context, IRubyObject io) {
+		if( io.isNil() )
+			throw context.getRuntime().newTypeError("Must pass in an IO object");
+		RubyString string = (RubyString) io.callMethod(context, "read");
+		this.string = string;
+	}
+
+	@JRubyMethod(name = { "string=" })
+	public void setString(ThreadContext context, IRubyObject pString) {
+		if( pString.isNil() ) {
+			throw context.getRuntime().newTypeError("");
+		}
+		this.string = ((RubyString) pString);
+	}
+
+	@JRubyMethod(name = "context" )
+	public IRubyObject getContext(ThreadContext context) throws Exception {
+		return ParserContextJ.newInstance( context );
+	}
+
+	@JRubyMethod(name = { "document=" })
+	public void setDocument(ThreadContext context, IRubyObject pDocument) throws Exception {
+		DocumentJ document = (DocumentJ) pDocument;
+		string = document.toString(context, new IRubyObject[]{} );
+	}
+
+	@JRubyMethod(name ="file=" )
+	public void setFile(ThreadContext context, IRubyObject pDocument) throws Exception {
+		string = (RubyString) UtilJ.toRubyString( context, pDocument );
+	}
+
+	@JRubyMethod(name = "parse")
+	public DocumentJ parse(ThreadContext context) throws Exception {
+
+		DocumentBuilder builder = UtilJ.getBuilder();
+		Document doc = null;
+		
+		if (this.fileName != null) {
+			doc = builder.parse(this.fileName.asJavaString());
+
+		} else if (this.string != null) {
+			StringReader reader = new StringReader(string.asJavaString());
+			try {				
+				doc = builder.parse(new InputSource(reader));
+			} catch( SAXParseException e ) {
+				throw ErrorJ.newRaiseException(context, e.getMessage() );
+			} finally {
+				reader.close();
+			}
+		} else {
+			throw context.getRuntime().newTypeError("");
+		}
+		DocumentJ document = DocumentJ.newInstance(context);
+		document.setJavaObject(doc);
+		
+		if (doc.getXmlEncoding() != null)
+			document.setEncoding(context, context.getRuntime().newString(doc.getXmlEncoding()));
+		
+		return document;
+	}
+
+	@JRubyMethod(name = "document", module = true)
+	public static ParserJ fromDocument(ThreadContext context, IRubyObject self, IRubyObject pDocument) throws Exception {
+		if( pDocument.isNil() )
+			throw context.getRuntime().newTypeError("Must pass an XML::Document object");
+		
+		DocumentJ document = (DocumentJ) pDocument;
+		
+		ParserJ parser = ParserJ.newInstance(context);
+		parser.setDocument(context, document );
+		return parser;
+
+	}
+
+	@JRubyMethod(name = "io", module = true)
+	public static ParserJ fromIo(ThreadContext context, IRubyObject klass, IRubyObject io) throws Exception {
+		if( io.isNil() )
+			throw context.getRuntime().newTypeError("Must pass in an IO object");
+		RubyString string = (RubyString) io.callMethod(context, "read");
+		ParserJ parser = ParserJ.newInstance(context);
+		parser.string = string;
+		return parser;
+	}
+
+	@JRubyMethod(name ="io")
+	public IRubyObject getIo(ThreadContext context) throws Exception {
+		return context.getRuntime().getNil();
+	}
+
+	@JRubyMethod(name = "string", module = true, required=1, optional = 1)
+	public static ParserJ fromString(ThreadContext context, IRubyObject klass, IRubyObject[] args) throws Exception {
+		
+		if( args.length == 0 || args[0].isNil() ) 
+			throw context.getRuntime().newTypeError("wrong argument type nil (expected String)");
+		
+		RubyString string = (RubyString) args[0];
+		RubyHash hash;
+		if (args.length > 1) {
+			hash = (RubyHash) args[1];
+		}
+
+		ParserJ parser = ParserJ.newInstance(context);
+		parser.string = string;
+		return parser;
+	}
+
+}

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

@@ -0,0 +1,58 @@
+package smile.xml;
+
+import org.jruby.Ruby;
+import org.jruby.RubyModule;
+import org.jruby.anno.JRubyConstant;
+import org.jruby.anno.JRubyModule;
+
+import smile.xml.util.UtilJ;
+
+@JRubyModule(name = "LibXML::XML::Parser::Options")
+public class ParserOptionsJ {
+
+	@JRubyConstant
+	public static final String RECOVER = null;
+	@JRubyConstant
+	public static final String NOENT = null;
+	@JRubyConstant
+	public static final String DTDLOAD = null;
+	@JRubyConstant
+	public static final String DTDATTR = null;
+	@JRubyConstant
+	public static final String DTDVALID = null;
+	@JRubyConstant
+	public static final String NOERROR = null;
+	@JRubyConstant
+	public static final String NOWARNING = null;
+	@JRubyConstant
+	public static final String PEDANTIC = null;
+	@JRubyConstant
+	public static final String NOBLANKS = null;
+	@JRubyConstant
+	public static final String SAX1 = null;
+	@JRubyConstant
+	public static final String XINCLUDE = null;
+	@JRubyConstant
+	public static final String NONET = null;
+	@JRubyConstant
+	public static final String NODICT = null;
+	@JRubyConstant
+	public static final String NSCLEAN = null;
+	@JRubyConstant
+	public static final String NOCDATA = null;
+	@JRubyConstant
+	public static final String NOXINCNODE = null;
+	@JRubyConstant
+	public static final String COMPACT = null;
+	@JRubyConstant
+	public static final String PARSE_OLD10 = null;
+	@JRubyConstant
+	public static final String NOBASEFIX = null;
+	@JRubyConstant
+	public static final String HUGE = null;
+
+	public static RubyModule define(Ruby runtime) {
+		return UtilJ.defineModule(runtime, ParserOptionsJ.class);
+	}
+
+}

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

@@ -0,0 +1,34 @@
+package smile.xml;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.builtin.IRubyObject;
+import smile.xml.util.UtilJ;
+
+public class ReaderJ extends RubyObject
+{
+  private static final long serialVersionUID = -120431027715516425L;
+  private static final ObjectAllocator ALLOCATOR = new ObjectAllocator()
+  {
+    public IRubyObject allocate(Ruby runtime, RubyClass klass)
+    {
+      return new ReaderJ(runtime, klass);
+    }
+  };
+
+  private ReaderJ(Ruby runtime, RubyClass metaClass)
+  {
+    super(runtime, metaClass);
+  }
+
+  public static RubyClass define(Ruby runtime)
+  {
+    RubyModule module = UtilJ.getModule(runtime, new String[] { "LibXML", "XML" });
+    RubyClass result = module.defineClassUnder("Reader", runtime.getObject(), ALLOCATOR);
+    result.defineAnnotatedMethods(ReaderJ.class);
+    return result;
+  }
+}

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

@@ -0,0 +1,66 @@
+package smile.xml;
+
+import javax.xml.transform.Source;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.validation.Schema;
+import javax.xml.validation.SchemaFactory;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+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.Node;
+import org.xml.sax.SAXException;
+import smile.xml.util.UtilJ;
+
+public class SchemaJ extends BaseJ<Schema>
+{
+  private static final long serialVersionUID = -6424527398086774781L;
+  private static final ObjectAllocator ALLOCATOR = new ObjectAllocator()
+  {
+    public IRubyObject allocate(Ruby runtime, RubyClass klass)
+    {
+      return new SchemaJ(runtime, klass);
+    }
+  };
+
+  public static RubyClass define(Ruby runtime)
+  {
+    RubyModule module = UtilJ.getModule(runtime, new String[] { "LibXML", "XML" });
+    RubyClass result = module.defineClassUnder("Schema", runtime.getObject(), ALLOCATOR);
+    result.defineAnnotatedMethods(SchemaJ.class);
+    return result;
+  }
+
+  private static RubyClass getRubyClass(Ruby runtime)
+  {
+    return UtilJ.getClass(runtime, new String[] { "LibXML", "XML", "Schema" });
+  }
+
+  @JRubyMethod(name={"document"}, meta=true)
+  public static SchemaJ fromDocument(ThreadContext context, IRubyObject klass, IRubyObject pDocument) throws SAXException {
+    DocumentJ document = (DocumentJ)pDocument;
+    SchemaFactory schemaFactory = UtilJ.getSchemaFactoryInstance();
+    Source schemaFile = new DOMSource((Node)document.getJavaObject());
+    Schema schema = schemaFactory.newSchema(schemaFile);
+
+    SchemaJ result = newInstance(context);
+    result.setJavaObject(schema);
+    return result;
+  }
+
+  public static SchemaJ newInstance(ThreadContext context) {
+    return (SchemaJ)getRubyClass(context.getRuntime()).newInstance(context, new IRubyObject[0], null);
+  }
+
+  private SchemaJ(Ruby ruby, RubyClass clazz) {
+    super(ruby, clazz);
+  }
+
+  @JRubyMethod(name={"initialize"}, rest=true)
+  public void initialize(ThreadContext context, IRubyObject[] args)
+  {
+  }
+}

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

@@ -0,0 +1,65 @@
+package smile.xml;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.compiler.ir.instructions.THROW_EXCEPTION_Instr;
+
+import smile.xml.sax.SaxParserCallbacksJ;
+import smile.xml.sax.SaxParserJ;
+import smile.xml.xpath.XPathContextJ;
+import smile.xml.xpath.XPathExpressionJ;
+import smile.xml.xpath.XPathJ;
+import smile.xml.xpath.XPathObjectJ;
+import smile.xml.xpath.XPointerJ;
+
+public class SmileXML {
+	public static void define(Ruby runtime) {
+		
+		try {
+		RubyModule libxml = runtime.fastGetModule("LibXML");
+		if (libxml == null) {
+			libxml = runtime.defineModule("LibXML");
+		}
+
+		RubyModule xml = XmlJ.define(runtime);
+
+		ParserJ.define(runtime);
+		ParserContextJ.define(runtime);
+		ParserOptionsJ.define(runtime);
+		DocumentJ.define(runtime);
+		NodeJ.define(runtime);
+		NodeSetJ.define(runtime);
+		AttributesJ.define(runtime);
+		AttrJ.define(runtime);
+
+		SaxParserJ.define(runtime);
+		SaxParserCallbacksJ.define(runtime);
+
+		XPathJ.define(runtime);
+		XPathObjectJ.define(runtime);
+		XPathContextJ.define(runtime);		
+		XPathExpressionJ.define(runtime);
+		XPointerJ.define(runtime);
+		
+		EncodingJ.define(runtime);
+		
+		ErrorJ.define(runtime);
+
+		RubyClass ns = NamespaceJ.define(runtime);
+		NamespacesJ.define(runtime);
+
+		SchemaJ.define(runtime);
+
+		runtime.addModule(xml);
+
+		xml.setConstant("NS", ns);
+		
+		runtime.defineGlobalConstant( "XML", xml );
+		
+		} catch( RuntimeException e ) {
+			e.printStackTrace();
+			throw e;
+		}
+	}
+}

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

@@ -0,0 +1,58 @@
+package smile.xml;
+
+import org.jruby.Ruby;
+import org.jruby.RubyModule;
+import org.jruby.anno.JRubyConstant;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyModule;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import smile.xml.util.UtilJ;
+
+@JRubyModule(name="LibXML::XML")
+public class XmlJ {
+
+  public static RubyModule define(Ruby runtime) {
+	  return UtilJ.defineModule(runtime, XmlJ.class);
+  }
+
+  @JRubyConstant
+  public static final String VERSION = "1";
+  
+  @JRubyConstant
+  public static final String VERNUM = "1";
+  
+  @JRubyMethod( name="default_substitute_entities=", module=true )
+  public static void setDefaultSubstituteEntities( ThreadContext context, IRubyObject self, IRubyObject pValue ) {
+	  
+  }
+
+  @JRubyMethod( name="indent_tree_output=", module=true )
+  public static void setIndentTreeOutput( ThreadContext context, IRubyObject self, IRubyObject pValue ) {
+	  
+  }
+
+  @JRubyMethod( name="indent_tree_output", module=true )
+  public static IRubyObject getIndentTreeOutput( ThreadContext context, IRubyObject self ) {
+	  return context.getRuntime().getFalse();
+  }
+
+  @JRubyMethod( name="default_keep_blanks=", module=true )
+  public static void setDefaultKeepBlanks( ThreadContext context, IRubyObject self, IRubyObject pValue ) {
+	  
+  }
+
+  @JRubyMethod( name="enabled_zlib?", module=true )
+  public static IRubyObject isEnabledZlib( ThreadContext context, IRubyObject self ) {
+	// TODO
+	  return context.getRuntime().getFalse();
+  }
+
+  @JRubyMethod( name="enabled_zlib=", module=true )
+  public static void setEnabledZlib( ThreadContext context, IRubyObject self, IRubyObject pValue ) {
+	  // TODO
+  }
+
+  
+}