smile-xml 1.0.0-jruby → 1.0.2-jruby

data/src/main/java/smile/xml/sax/CallbackHandler.java

@@ -0,0 +1,113 @@
+package smile.xml.sax;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.jruby.RubyHash;
+import org.jruby.RubyString;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.xml.sax.Attributes;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+import org.xml.sax.ext.DefaultHandler2;
+
+import smile.xml.ErrorJ;
+
+public class CallbackHandler extends DefaultHandler2 {
+
+	private final IRubyObject callback;
+	private final ThreadContext context;
+	private boolean cdata = false;
+
+	public CallbackHandler( ThreadContext context, IRubyObject callback ) {
+		this.context = context;
+		this.callback = callback;
+	}
+
+	private void call( String method, IRubyObject...args ) {
+		callback.callMethod( context, method, args );
+	}
+	
+	private RubyString toString( String string ) {
+		return context.getRuntime().newString( string );
+	}
+
+	private RubyHash toHash( Map<?,?> map ) {
+		return RubyHash.newHash( context.getRuntime(), map, context.getRuntime().getNil() );
+	}
+
+	@Override
+	public void startDocument() throws SAXException {
+		call( "on_start_document" );
+	}
+
+	@Override
+	public void endDocument() throws SAXException {
+		call( "on_end_document" );
+	}
+
+	@Override
+	public void error(SAXParseException e) throws SAXException {
+		call( "on_error", ErrorJ.newInstance( context, e.getMessage()) );
+	}
+	
+	@Override
+	public void startElement(String uri, String localName, String qName, Attributes atts) throws SAXException {
+			
+//		System.out.println( uri );
+//		System.out.println( localName );
+//		System.out.println( qName );
+//		System.out.println("---------");
+		Map<IRubyObject, IRubyObject> map = new HashMap<IRubyObject,IRubyObject>();
+		for (int i = 0; i < atts.getLength(); i++)
+			map.put( toString( atts.getLocalName(i) ), toString( atts.getValue(i) ) );
+
+		call( "on_start_element", toString(qName), toHash(map) );
+//		if( localName.equals( qName ) )  {	
+//			
+//		} else {			
+//			System.err.println( "on_start_element_ns ");
+//			call( "on_start_element_ns", toString(localName), toHash(map), toString(""), toString(uri), context.getRuntime().getNil() );
+//		}
+	}
+	
+	@Override
+	public void endElement(String uri, String localName, String qName) throws SAXException {
+		call( "on_end_element", toString( qName ) );
+	}
+
+	@Override
+	public void characters(char[] ch, int start, int length) throws SAXException {
+		
+		RubyString string = toString( String.valueOf(ch, start, length) );
+		if (this.cdata) {
+			call( "on_cdata_block", string );
+		} else {
+			call( "on_characters", string );
+		}
+	}
+
+	@Override
+	public void processingInstruction(String target, String data) throws SAXException {			
+		call( "on_processing_instruction", toString(target), toString(data));
+	}
+
+	@Override
+	public void startCDATA() {
+		this.cdata = true;
+	}
+
+	@Override
+	public void endCDATA() {
+		this.cdata = false;
+	}
+
+	@Override
+	public void comment(char[] ch, int start, int length) throws SAXException {
+		call( "on_comment", toString( String.valueOf(ch, start, length) ) );
+	}
+
+}
+
+

data/src/main/java/smile/xml/sax/SaxParserCallbacksJ.java

@@ -0,0 +1,71 @@
+package smile.xml.sax;
+
+import org.jruby.Ruby;
+import org.jruby.RubyModule;
+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::SaxParser::Callbacks")
+public class SaxParserCallbacksJ {
+	public static RubyModule define(Ruby runtime) {
+		return UtilJ.defineModule(runtime, SaxParserCallbacksJ.class);
+	}
+
+	@JRubyMethod(name = "on_start_document")
+	public static void onStartDocument(ThreadContext context, IRubyObject self) {
+	}
+
+	@JRubyMethod(name = "on_start_element")
+	public static void onStartElement(ThreadContext context, IRubyObject self,
+			IRubyObject name, IRubyObject attr) {
+	}
+
+	@JRubyMethod(name = "on_characters")
+	public static void onCharacter(ThreadContext context, IRubyObject self,
+			IRubyObject arg) {
+	}
+
+	@JRubyMethod(name = "on_comment")
+	public static void onComment(ThreadContext context, IRubyObject self,
+			IRubyObject arg) {
+	}
+
+	@JRubyMethod(name = "on_processing_instruction")
+	public static void onProcessingInstruction(ThreadContext context,
+			IRubyObject self, IRubyObject target, IRubyObject data) {
+	}
+
+	@JRubyMethod(name = "on_cdata_block")
+	public static void onCDataBlock(ThreadContext context, IRubyObject self,
+			IRubyObject cdata) {
+	}
+
+	@JRubyMethod(name = "on_end_element")
+	public static void onEndElement(ThreadContext context, IRubyObject self,
+			IRubyObject name) {
+	}
+
+	@JRubyMethod(name = "on_end_document")
+	public static void onEndDocument(ThreadContext context, IRubyObject self) {
+	}
+
+	@JRubyMethod(name = "on_start_element_ns", rest = true)
+	public static void onStartElementNS(ThreadContext context,
+			IRubyObject self, IRubyObject[] args) {
+	}
+
+	@JRubyMethod(name = "on_end_element_ns")
+	public static void onEndElementNS(ThreadContext context, IRubyObject self,
+			IRubyObject name, IRubyObject prefix, IRubyObject uri) {
+	}
+
+	@JRubyMethod(name = "on_error")
+	public static void onError(ThreadContext context, IRubyObject self,
+			IRubyObject error) {
+	}
+
+}

data/src/main/java/smile/xml/sax/SaxParserJ.java

@@ -0,0 +1,153 @@
+package smile.xml.sax;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.StringReader;
+
+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 org.xml.sax.EntityResolver;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.XMLReader;
+import org.xml.sax.helpers.XMLReaderFactory;
+
+import smile.xml.ErrorJ;
+import smile.xml.ParserJ;
+import smile.xml.util.UtilJ;
+
+@JRubyClass(name="LibXML::XML::SaxParser")
+public class SaxParserJ extends RubyObject {
+	
+	private static final long serialVersionUID = -8712513236401964568L;
+	
+	public static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+		public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+			return new SaxParserJ(runtime, klass);
+		}
+	};
+	
+	public static RubyClass define(Ruby runtime) {
+		return UtilJ.defineClass( runtime, SaxParserJ.class, ALLOCATOR );
+	}
+
+	public static RubyClass getRubyClass(Ruby runtime) {
+		return UtilJ.getClass(runtime, SaxParserJ.class );
+	}
+
+	@JRubyMethod(name = { "string" }, module = true)
+	public static IRubyObject fromString(ThreadContext context, IRubyObject self, IRubyObject pString) {
+		
+		if (pString.isNil())
+			throw context.getRuntime().newTypeError( "wrong argument type nil (expected String)" );
+
+		SaxParserJ parser = new SaxParserJ(context);
+		parser.string = ((RubyString) pString);
+		return parser;
+	}
+
+	@JRubyMethod(name = "file", module = true)
+	public static IRubyObject fromFile(ThreadContext context, IRubyObject self,
+			IRubyObject pFile) {
+
+		if (pFile.isNil())
+			throw context.getRuntime().newTypeError( "can't convert nil into String" );
+
+		if (new File(pFile.asJavaString()).exists() == false)
+			throw ErrorJ.newRaiseException( context, "Warning: failed to load external entity \"" + pFile.asJavaString() + "\".");
+
+		SaxParserJ parser = new SaxParserJ(context);
+		parser.fileName = ((RubyString) pFile);
+		return parser;
+	}
+
+	private RubyString string;
+	private RubyString fileName;
+	private IRubyObject callbacks;
+
+	@JRubyMethod(name = { "io" }, module = true)
+	public static IRubyObject fromIo(ThreadContext context, IRubyObject self, IRubyObject pIo) {
+		SaxParserJ parser = new SaxParserJ(context);
+		parser.string = ((RubyString) pIo.callMethod(context, "read"));
+		return parser;
+	}
+
+	public SaxParserJ(Ruby runtime, RubyClass metaClass) {
+		super(runtime, metaClass);
+	}
+
+	public SaxParserJ(ThreadContext context) {
+		this(context.getRuntime(), getRubyClass(context.getRuntime()));
+	}
+
+	@JRubyMethod(name = { "initialize" }, optional = 1)
+	public IRubyObject initialize(ThreadContext context, IRubyObject[] args) {
+		return this;
+	}
+
+	@JRubyMethod(name = { "filename=" })
+	public void setFilename(ThreadContext context, IRubyObject pFileName) {
+		this.fileName = ((RubyString) pFileName);
+	}
+
+	@JRubyMethod(name = { "string=" })
+	public void setString(ThreadContext context, IRubyObject pFileName) {
+		this.string = ((RubyString) pFileName);
+	}
+
+	@JRubyMethod(name = { "string" })
+	public IRubyObject getString(ThreadContext context) {
+		return this.string;
+	}
+
+	@JRubyMethod(name = { "callbacks=" })
+	public void setCallbacks(ThreadContext context, IRubyObject pCallbacks) {
+		this.callbacks = pCallbacks;
+	}
+
+	@JRubyMethod(name = { "callbacks" })
+	public IRubyObject getCallbacks(ThreadContext context) {
+		return this.callbacks;
+	}
+
+	@JRubyMethod(name = { "parse" })
+	public IRubyObject parse(ThreadContext context) throws SAXException,
+			IOException {
+		XMLReader xmlReader = XMLReaderFactory.createXMLReader();
+		InputSource inputSource;
+		if (this.string != null) {
+			inputSource = new InputSource(new StringReader(
+					this.string.asJavaString()));
+		} else {
+			FileReader reader = new FileReader(this.fileName.asJavaString());
+			inputSource = new InputSource(reader);
+		}
+
+		xmlReader.setEntityResolver(new EntityResolver() {
+			public InputSource resolveEntity(String publicId, String systemId)
+					throws SAXException, IOException {
+				return new InputSource(new StringReader(""));
+			}
+		});
+		if (callbacks != null && callbacks.isNil() == false)
+			xmlReader.setContentHandler(new CallbackHandler(context, callbacks));
+		
+		xmlReader.setProperty("http://xml.org/sax/properties/lexical-handler",xmlReader.getContentHandler());
+		try {
+			xmlReader.parse(inputSource);
+		} catch (SAXException e) {
+			throw ErrorJ.newRaiseException(context, e.getMessage());
+		}
+
+		return context.getRuntime().getTrue();
+	}
+
+}