/*
* call-seq:
* reader.expand -> node
*
* Returns the current node and its full subtree. Note the returned node
* is valid ONLY until the next read call.
*/
static VALUE rxml_reader_expand(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
xmlNodePtr xnode = NULL;
/* At this point we need to wrap the reader's document as explained above. */
xmlDocPtr xdoc = xmlTextReaderCurrentDoc(xreader);
if (!xdoc)
rb_raise(rb_eRuntimeError, "The reader does not have a document. Did you forget to call read?");
rxml_document_wrap(xdoc);
/* And now hook in a mark function */
RDATA(self)->dmark = (RUBY_DATA_FUNC)rxml_reader_mark;
xnode = xmlTextReaderExpand(xreader);
if (!xnode)
{
return Qnil;
}
else
{
return rxml_node_wrap(xnode);
}
}
/*
* call-seq:
* context.doc -> document
*
* Obtain the XML::Document this node belongs to.
*/
static VALUE rxml_xpath_context_doc(VALUE self)
{
xmlDocPtr xdoc = NULL;
xmlXPathContextPtr ctxt;
Data_Get_Struct(self, xmlXPathContext, ctxt);
xdoc = ctxt->doc;
return rxml_document_wrap(xdoc);
}
/*
* call-seq:
* attr_decl.doc -> XML::Document
*
* Returns this attribute declaration's document.
*/
static VALUE rxml_attr_decl_doc_get(VALUE self)
{
xmlAttributePtr xattr;
Data_Get_Struct(self, xmlAttribute, xattr);
if (xattr->doc == NULL)
return Qnil;
else
return rxml_document_wrap(xattr->doc);
}
/*
* call-seq:
* parser.parse -> XML::Document
*
* Parse the input XML and create an XML::Document with
* it's content. If an error occurs, XML::Parser::ParseError
* is thrown.
*/
static VALUE rxml_html_parser_parse(VALUE self)
{
xmlParserCtxtPtr ctxt;
VALUE context = rb_ivar_get(self, CONTEXT_ATTR);
Data_Get_Struct(context, xmlParserCtxt, ctxt);
if (htmlParseDocument(ctxt) == -1 && ! ctxt->recovery)
{
if (ctxt->myDoc)
xmlFreeDoc(ctxt->myDoc);
rxml_raise(&ctxt->lastError);
}
return rxml_document_wrap(ctxt->myDoc);
}
/* call-seq:
* stylesheet.apply(document, {params}) -> XML::Document
*
* Apply this stylesheet transformation to the provided document.
* This method may be invoked multiple times.
*
* Params:
* * document - An instance of an XML::Document
* * params - An optional hash table that specifies the values for xsl:param values embedded in the stylesheet.
*
* Example:
*
* stylesheet_doc = XML::Document.file('stylesheet_file')
* stylesheet = XSLT::Stylesheet.new(stylesheet_doc)
*
* xml_doc = XML::Document.file('xml_file')
* result = stylesheet.apply(xml_doc)
* result = stylesheet.apply(xml_doc, {:foo => 'bar'})
*/
static VALUE
ruby_xslt_stylesheet_apply(int argc, VALUE *argv, VALUE self) {
xmlDocPtr xdoc;
xsltStylesheetPtr xstylesheet;
xmlDocPtr result;
VALUE document;
VALUE params;
int i;
char** pParams;
if (argc > 2 || argc < 1)
rb_raise(rb_eArgError, "wrong number of arguments (need 1 or 2)");
document = argv[0];
if (!rb_obj_is_kind_of(document, cXMLDocument))
rb_raise(rb_eTypeError, "Must pass in an XML::Document instance.");
/* Make sure params is a flat array */
params = (argc == 2 ? argv[1]: Qnil);
params = rb_Array(params);
rb_funcall(params, rb_intern("flatten!"), 0);
pParams = ruby_xslt_coerce_params(params);
Data_Get_Struct(document, xmlDoc, xdoc);
Data_Get_Struct(self, xsltStylesheet, xstylesheet);
result = xsltApplyStylesheet(xstylesheet, xdoc, (const char**)pParams);
if (!result)
rb_raise(eXSLTError, "Transformation failed");
/* Free allocated array of *chars. Note we don't have to
free the last array item since its set to NULL. */
for (i=0; i<RARRAY_LEN(params); i++) {
ruby_xfree(pParams[i]);
}
ruby_xfree(pParams);
return rxml_document_wrap(result);
}
/*
* call-seq:
* reader.expand -> node
*
* Read the contents of the current node and the full subtree. It then makes
* the subtree available until the next read call.
*
* Return an XML::Node object, or nil in case of error.
*/
static VALUE rxml_reader_expand(VALUE self)
{
xmlNodePtr node;
xmlDocPtr doc;
xmlTextReaderPtr reader = rxml_text_reader_get(self);
node = xmlTextReaderExpand(reader);
if (!node)
return Qnil;
/* Okay this is tricky. By accessing the returned node, we
take ownership of the reader's document. Thus we need to
tell the reader to not free it. Otherwise it will be
freed twice - once when the Ruby document wrapper goes
out of scope and once when the reader goes out of scope. */
xmlTextReaderPreserve(reader);
doc = xmlTextReaderCurrentDoc(reader);
rxml_document_wrap(doc);
return rxml_node_wrap(node);
}
