nokogiri 1.5.0.beta.1 → 1.5.0.beta.2

data/ext/java/nokogiri/internals/ReaderNode.java

@@ -0,0 +1,431 @@
+package nokogiri.internals;
+
+import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
+import static nokogiri.internals.NokogiriHelpers.isNamespace;
+import static nokogiri.internals.NokogiriHelpers.isXmlBase;
+import static nokogiri.internals.NokogiriHelpers.stringOrBlank;
+import static nokogiri.internals.NokogiriHelpers.stringOrNil;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Stack;
+
+import nokogiri.XmlAttr;
+import nokogiri.XmlDocument;
+import nokogiri.XmlSyntaxError;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyHash;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.w3c.dom.Attr;
+import org.xml.sax.Attributes;
+import org.xml.sax.SAXParseException;
+
+public abstract class ReaderNode {
+
+    Ruby ruby;
+    public ReaderAttributeList attributeList;
+    public Map<String, String> namespaces;
+    public int depth, nodeType;
+    public String lang, localName, xmlBase, prefix, name, uri, value, xmlVersion = "1.0";
+    public boolean hasChildren = false;
+    public abstract String getString();
+
+    public IRubyObject getAttributeByIndex(IRubyObject index){
+        if(index.isNil()) return index;
+        
+        long i = index.convertToInteger().getLongValue();
+        if(i > Integer.MAX_VALUE) {
+            throw ruby.newArgumentError("value too long to be an array index");
+        }
+
+        if (attributeList == null) return ruby.getNil();
+        if (i<0 || attributeList.length <= i) return ruby.getNil();
+        return stringOrBlank(ruby, attributeList.values.get(((Long)i).intValue()));
+    }
+
+    public IRubyObject getAttributeByName(IRubyObject name){
+        if(attributeList == null) return ruby.getNil();
+        String value = attributeList.getByName((String)name.toJava(String.class));
+        return stringOrNil(ruby, value);
+    }
+    
+    public IRubyObject getAttributeByName(String name){
+        if(attributeList == null) return ruby.getNil();
+        String value = attributeList.getByName(name);
+        return stringOrNil(ruby, value);
+    }
+
+    public IRubyObject getAttributeCount(){
+        if(attributeList == null) return ruby.newFixnum(0);
+        return ruby.newFixnum(attributeList.length);
+    }
+
+    public IRubyObject getAttributesNodes() {
+        RubyArray array = RubyArray.newArray(ruby);
+        if (attributeList != null && attributeList.length > 0) {
+            // XmlDocument is used to create XmlAttr type of attribute nodes. Since the attribute nodes
+            // should have name and to_s methods, using XmlAttr would be convenient.
+            XmlDocument xmlDoc = 
+                (XmlDocument)XmlDocument.rbNew(ruby.getCurrentContext(), getNokogiriClass(ruby, "Nokogiri::XML::Document"), new IRubyObject[0]);        
+            for (int i=0; i<attributeList.length; i++) {
+                if (!isNamespace(attributeList.names.get(i))) {
+                    Attr attr = xmlDoc.getDocument().createAttributeNS(attributeList.namespaces.get(i), attributeList.names.get(i));
+                    attr.setValue(attributeList.values.get(i));
+                    array.append(new XmlAttr(ruby, attr));
+                }
+            }
+        }
+        return array;
+    }
+    
+    public IRubyObject getAttributes(ThreadContext context) {
+        if(attributeList == null) return context.getRuntime().getNil();
+        RubyHash hash = RubyHash.newHash(context.getRuntime());
+        for (int i=0; i<attributeList.length; i++) {
+            IRubyObject k = stringOrBlank(context.getRuntime(), attributeList.names.get(i));
+            IRubyObject v = stringOrBlank(context.getRuntime(), attributeList.values.get(i));
+            if (context.getRuntime().is1_9()) hash.op_aset19(context, k, v);
+            else hash.op_aset(context, k, v);
+        }
+        return hash;
+    }
+
+    public IRubyObject getDepth() {
+        return ruby.newFixnum(depth);
+    }
+
+    public IRubyObject getLang() {
+        return stringOrNil(ruby, lang);
+    }
+
+    public IRubyObject getLocalName() {
+        return stringOrNil(ruby, localName);
+    }
+
+    public IRubyObject getName() {
+        return stringOrNil(ruby, name);
+    }
+
+    public IRubyObject getNamespaces(ThreadContext context) {
+        if(namespaces == null) return ruby.getNil();
+        RubyHash hash = RubyHash.newHash(ruby);
+        Set<String> keys = namespaces.keySet();
+        for (String key : keys) {
+            String stringValue = namespaces.get(key);
+            IRubyObject k = stringOrBlank(context.getRuntime(), key);
+            IRubyObject v = stringOrBlank(context.getRuntime(), stringValue);
+            if (context.getRuntime().is1_9()) hash.op_aset19(context, k, v);
+            else hash.op_aset(context, k, v);
+        }
+        return hash;
+    }
+    
+    public IRubyObject getXmlBase() {
+        return stringOrNil(ruby, xmlBase);
+    }
+
+    public IRubyObject getPrefix() {
+        return stringOrNil(ruby, prefix);
+    }
+
+    public IRubyObject getUri() {
+        return stringOrNil(ruby, uri);
+    }
+
+    public IRubyObject getValue() {
+        return stringOrNil(ruby, value);
+    }
+
+    public IRubyObject getXmlVersion() {
+        return ruby.newString(xmlVersion);
+    }
+
+    public RubyBoolean hasAttributes() {
+        if (attributeList == null || attributeList.length == 0) return ruby.getFalse();
+        return ruby.getTrue();
+    }
+
+    public abstract RubyBoolean hasValue();
+
+    public RubyBoolean isDefault(){
+        // TODO Implement.
+        return ruby.getFalse();
+    }
+
+    public boolean isError() { return false; }
+
+    protected void parsePrefix(String qName) {
+        int index = qName.indexOf(':');
+        if(index != -1) prefix = qName.substring(0, index);
+    }
+
+    public void setLang(String lang) {
+        lang = (lang != null) ? lang : null;
+    }
+
+    public IRubyObject toSyntaxError() { return ruby.getNil(); }
+    
+    public IRubyObject getNodeType() { return ruby.newFixnum(nodeType); }
+
+    public static enum ReaderNodeType {
+        NODE(0),
+        ELEMENT(1),
+        ATTRIBUTE(2),
+        TEXT(3),
+        CDATA(4),
+        ENTITY_REFERENCE(5),
+        ENTITY(6),
+        PROCESSING_INSTRUCTION(7),
+        COMMENT(8),
+        DOCUMENT(9),
+        DOCUMENT_TYPE(10),
+        DOCUMENTFRAGMENT(11),
+        NOTATION(12),
+        WHITESPACE(13),
+        SIGNIFICANT_WHITESPACE(14),
+        END_ELEMENT(15),
+        END_ENTITY(16),
+        XML_DECLARATION(17);
+        
+        private final int value;
+        ReaderNodeType(int value) {
+            this.value = value;
+        }
+        
+        public int getValue() {
+            return value;
+        }
+    }
+
+    public static class ClosingNode extends ReaderNode {
+
+        public ClosingNode(Ruby ruby, String uri, String localName, String qName, int depth, Stack<String> langStack, Stack<String> xmlBaseStack) {
+            this.ruby = ruby;
+            nodeType = ReaderNodeType.END_ELEMENT.getValue();
+            this.uri = "".equals(uri) ? null : uri;
+            this.localName = localName.trim().length() > 0 ? localName : qName;
+            this.name = qName;
+            parsePrefix(qName);
+            this.depth = depth;
+            if (!langStack.isEmpty()) this.lang = langStack.peek();
+            if (!xmlBaseStack.isEmpty()) this.xmlBase = xmlBaseStack.peek();
+        }
+
+        @Override
+        public IRubyObject getAttributeCount() {
+            return ruby.newFixnum(0);
+        }
+
+        @Override
+        public RubyBoolean hasValue() {
+            return ruby.getFalse();
+        }
+
+        @Override
+        public String getString() {
+            StringBuffer sb = new StringBuffer();
+            sb.append("</").append(name).append(">");
+            return new String(sb);
+        }
+    }
+    
+    public static class ElementNode extends ReaderNode {
+        private List<String> attributeStrings = new ArrayList<String>();
+        
+        public ElementNode(Ruby ruby, String uri, String localName, String qName, Attributes attrs, int depth, Stack<String> langStack, Stack<String> xmlBaseStack) {
+            this.ruby = ruby;
+            this.nodeType = ReaderNodeType.ELEMENT.getValue();
+            this.uri = "".equals(uri) ? null : uri;
+            this.localName = localName.trim().length() > 0 ? localName : qName;
+            this.name = qName;
+            parsePrefix(qName);
+            this.depth = depth;
+            hasChildren = true;
+            parseAttributes(attrs, langStack, xmlBaseStack);
+        }
+
+        @Override
+        public RubyBoolean hasValue() {
+            return ruby.getFalse();
+        }
+
+        private void parseAttributes(Attributes attrs, Stack<String> langStack, Stack<String> xmlBaseStack) {
+            if (attrs.getLength() > 0) attributeList = new ReaderAttributeList();
+            String u, n, v;
+            for (int i = 0; i < attrs.getLength(); i++) {
+                u = attrs.getURI(i);
+                n = attrs.getQName(i);
+                v = attrs.getValue(i);
+                if (isNamespace(n)) {
+                    if (namespaces == null) namespaces = new HashMap<String, String>();
+                    namespaces.put(n, v);
+                } else {
+                    if (lang == null) lang = resolveLang(n, v, langStack);
+                    if (xmlBase == null) xmlBase = resolveXmlBase(n, v, xmlBaseStack);
+                }
+                attributeList.add(u, n, v);
+                attributeStrings.add(n + "=\"" + v + "\"");
+            }
+        }
+        
+        private String resolveLang(String n, String v, Stack<String> langStack) {
+            if ("xml:lang".equals(n)) {
+                return v;
+            } else if (!langStack.isEmpty()) {
+                return langStack.peek();
+            } else {
+                return null;
+            }
+        }
+        
+        private String resolveXmlBase(String n, String v, Stack<String> xmlBaseStack) {
+            if (isXmlBase(n)) {
+                return getXmlBaseUri(n, v, xmlBaseStack);
+            } else if (!xmlBaseStack.isEmpty()) {
+                return xmlBaseStack.peek();
+            } else {
+                return null;
+            }
+        }
+        
+        private String getXmlBaseUri(String n, String v, Stack<String> xmlBaseStack) {
+            if ("xml:base".equals(n)) {
+                if (v.startsWith("http://")) {
+                    return v;
+                } else if (v.startsWith("/") && v.endsWith("/")) {
+                    String sub = v.substring(1, v.length() - 2);
+                    String base = xmlBaseStack.peek();
+                    if (base.endsWith("/")) {
+                        base = base.substring(0, base.length() - 1);
+                    }
+                    int pos = base.lastIndexOf("/");
+                    return base.substring(0, pos).concat(sub);
+                } else {
+                    String base = xmlBaseStack.peek();
+                    if (base.endsWith("/")) return base.concat(v);
+                    else return base.concat("/").concat(v);
+                }
+            } else if ("xlink:href".equals(n)) {
+                String base = xmlBaseStack.peek();
+                if (base.endsWith("/")) return base.concat(v);
+                else return base.concat("/").concat(v);
+            }
+            return null;
+        }
+
+        @Override
+        public String getString() {
+            StringBuffer sb = new StringBuffer();
+            sb.append("<").append(name);
+            if (attributeList != null) {
+                for (int i=0; i<attributeList.length; i++) {
+                    sb.append(" ").append(attributeStrings.get(i));
+                }
+            }
+            if (hasChildren) sb.append(">");
+            else sb.append("/>");
+            return new String(sb);
+        }
+    }
+    
+    public static class ReaderAttributeList {
+        List<String> namespaces  = new ArrayList<String>();
+        List<String> names  = new ArrayList<String>();
+        List<String> values = new ArrayList<String>();
+        int length = 0;
+        
+        void add(String namespace, String name, String value) {
+            namespace = namespace != null ? namespace : "";
+            namespaces.add(namespace);
+            name = name != null ? name : "";
+            names.add(name);
+            value = value != null ? value : "";
+            values.add(value);
+            length++;
+        }
+        
+        String getByName(String name) {
+            for (int i=0; i<names.size(); i++) {
+                if (name.equals(names.get(i))) {
+                    return values.get(i);
+                }
+            }
+            return null;
+        }
+    }
+
+    public static class EmptyNode extends ReaderNode {
+
+        public EmptyNode(Ruby ruby) {
+            this.ruby = ruby;
+            this.nodeType = ReaderNodeType.NODE.getValue();
+        }
+
+        @Override
+        public IRubyObject getXmlVersion() {
+            return this.ruby.getNil();
+        }
+
+        @Override
+        public RubyBoolean hasValue() {
+            return ruby.getFalse();
+        }
+
+        @Override
+        public String getString() {
+            return null;
+        }
+    }
+
+    public static class ExceptionNode extends EmptyNode {
+        private final XmlSyntaxError exception;
+
+        // Still don't know what to do with ex.
+        public ExceptionNode(Ruby ruby, SAXParseException ex) {
+            super(ruby);
+            this.exception = new XmlSyntaxError(ruby);
+        }
+
+        @Override
+        public boolean isError() {
+            return true;
+        }
+
+        @Override
+        public IRubyObject toSyntaxError() {
+            return this.exception;
+        }
+    }
+
+    public static class TextNode extends ReaderNode {
+
+        public TextNode(Ruby ruby, String content, int depth, Stack<String> langStack, Stack<String> xmlBaseStack) {
+            this.ruby = ruby;
+            this.value = content;
+            this.localName = "#text";
+            this.name = "#text";
+            this.depth = depth;
+            if (content.trim().length() > 0) nodeType = ReaderNodeType.TEXT.getValue();
+            else nodeType = ReaderNodeType.SIGNIFICANT_WHITESPACE.getValue();
+            if (!langStack.isEmpty()) this.lang = langStack.peek();
+            if (!xmlBaseStack.isEmpty()) this.xmlBase = xmlBaseStack.peek();
+        }
+
+        @Override
+        public RubyBoolean hasValue() {
+            return ruby.getTrue();
+        }
+
+        @Override
+        public String getString() {
+            return value;
+        }
+    }
+}

data/ext/java/nokogiri/internals/SaveContext.java

@@ -0,0 +1,249 @@
+package nokogiri.internals;
+
+import java.lang.Character;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyString;
+import org.jruby.javasupport.util.RuntimeHelpers;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ *
+ * @author sergio
+ */
+public class SaveContext {
+
+    private final ThreadContext context;
+    private final RubyClass elementDescription;
+    private StringBuffer buffer;
+    private int options;
+    private int level=0;
+    private String encoding, indentString;
+    private boolean format, noDecl, noEmpty, noXhtml, xhtml, asXml, asHtml;
+
+    /*
+     * U can't touch this.
+     * http://www.youtube.com/watch?v=WJ2ZFVx6A4Q
+     *
+     * Taken from libxml save options.
+     */
+
+    public static final int FORMAT = 1;
+    public static final int NO_DECL = 2;
+    public static final int NO_EMPTY = 4;
+    public static final int NO_XHTML = 8;
+    public static final int XHTML = 16;
+    public static final int AS_XML = 32;
+    public static final int AS_HTML = 64;
+
+    public SaveContext(ThreadContext context, int options, String indentString,
+                       String encoding) {
+        this.context = context;
+        this.elementDescription =
+            (RubyClass) context.getRuntime().getClassFromPath(
+                "Nokogiri::HTML::ElementDescription");
+        this.options = options;
+        this.encoding = encoding;
+        this.indentString = indentString;
+        this.buffer = new StringBuffer();
+        format = (options & FORMAT) == FORMAT;
+        noDecl = (options & NO_DECL) == NO_DECL;
+        noEmpty = (options & NO_EMPTY) == NO_EMPTY;
+        noXhtml = (options & NO_XHTML) == NO_XHTML;
+        xhtml = (options & XHTML) == XHTML;
+        asXml = (options & AS_XML) == AS_XML;
+        asHtml = (options & AS_HTML) == AS_HTML;
+    }
+
+
+    public void append(String s) {
+        this.buffer.append(s);
+    }
+
+    public void append(char c) {
+        buffer.append(c);
+    }
+
+    public void append(StringBuffer sb) {
+        this.buffer.append(sb);
+    }
+
+    public void appendQuoted(String s) {
+        this.append("\"");
+        this.append(s);
+        this.append("\"");
+    }
+
+    public void appendQuoted(StringBuffer sb) {
+        this.append("\"");
+        this.append(sb);
+        this.append("\"");
+    }
+
+    public void emptyTag(String name) {
+        emptyTagStart(name);
+        emptyTagEnd(name);
+    }
+
+    public void emptyTagStart(String name) {
+        openTagInlineStart(name);
+    }
+
+    public void emptyTagEnd(String name) {
+        if (asHtml) {
+            if (isEmpty(name) && noEmpty()) {
+                append(">");
+            } else {
+                openTagInlineEnd();
+                closeTagInline(name);
+            }
+        } else if (xhtml) {
+            append(" />");
+        } else {
+            append("/>");
+        }
+    }
+
+    public void openTag(String name) {
+        openTagStart(name);
+        openTagEnd();
+    }
+
+    public void openTagStart(String name) {
+        maybeBreak();
+        indent();
+        append("<");
+        append(name);
+    }
+
+    public void openTagEnd() {
+        append(">");
+        maybeBreak();
+        increaseLevel();
+    }
+
+    public void closeTag(String name) {
+        decreaseLevel();
+        maybeBreak();
+        indent();
+        append("</");
+        append(name);
+        append(">");
+        maybeBreak();
+    }
+
+    public void openTagInline(String name) {
+        openTagInlineStart(name);
+        openTagInlineEnd();
+    }
+
+    public void openTagInlineStart(String name) {
+        maybeIndent();
+        append("<");
+        append(name);
+    }
+
+    public void openTagInlineEnd() {
+        append(">");
+    }
+
+    public void closeTagInline(String name) {
+        append("</");
+        append(name);
+        append(">");
+    }
+
+    public void maybeBreak() {
+        if (format && !endsInNewline()) append('\n');
+    }
+
+    public void maybeSpace() {
+        if (format && !endsInWhitespace()) append(' ');
+    }
+
+    /**
+     * Indent if this is the start of a fresh line.
+     */
+    public void maybeIndent() {
+        if (format && endsInNewline()) indent();
+    }
+
+    public void indent() {
+        if (format) append(getCurrentIndentString());
+    }
+
+    public boolean endsInWhitespace() {
+        return (Character.isWhitespace(lastChar()));
+    }
+
+    public boolean endsInNewline() {
+        return (lastChar() == '\n');
+    }
+
+    public char lastChar() {
+        if (buffer.length() == 0) return '\n'; // logically, the char
+                                               // *before* a text file
+                                               // is a newline
+        return buffer.charAt(buffer.length() - 1);
+    }
+
+    public boolean asHtml() { return this.asHtml; }
+
+    public boolean asXml() { return this.asXml; }
+    
+    public void decreaseLevel() {
+        if(this.level > 0) this.level--;
+    }
+
+    public String encoding() { return this.encoding; }
+
+    public boolean format() { return this.format; }
+
+    public String getCurrentIndentString() {
+        StringBuffer res = new StringBuffer();
+        for(int i = 0; i < this.level; i++) {
+            res.append(this.indentString());
+        }
+        return res.toString();
+    }
+
+    public String getEncoding() { return this.encoding; }
+
+    public void increaseLevel() {
+        if(this.level >= 0) this.level++;
+    }
+
+    public String indentString() { return this.indentString; }
+
+    public boolean noDecl() { return this.noDecl; }
+
+    public boolean noEmpty() { return this.noEmpty; }
+
+    public boolean noXhtml() { return this.noXhtml; }
+
+    public void setFormat(boolean format) { this.format = format; }
+
+    public void setLevel(int level) { this.level = level; }
+
+    @Override
+    public String toString() { return this.buffer.toString(); }
+
+    public RubyString toRubyString(Ruby runtime) {
+        return new RubyString(runtime, runtime.getString(), buffer);
+    }
+
+    public boolean Xhtml() { return this.xhtml; }
+
+    /**
+     * Looks up the HTML ElementDescription and tests if it is an
+     * empty element.
+     */
+    protected boolean isEmpty(String name) {
+        IRubyObject desc =
+            RuntimeHelpers.invoke(context,
+                                  elementDescription, "[]",
+                                  context.getRuntime().newString(name));
+        return RuntimeHelpers.invoke(context, desc, "empty?").isTrue();
+    }
+}