class Nokogiri::XML::SAX::ParserContext - nokogiri-1.15.2 Documentation

# class Nokogiri::XML::SAX::ParserContext

Context for `XML` `SAX` parsers. This class is usually not instantiated by the user. Instead, you should be looking at `Nokogiri::XML::SAX::Parser`

### Public Class Methods

parse_file(filename) click to toggle source

Parse file given `filename`

    static VALUE
    parse_file(VALUE klass, VALUE filename)
    {
      xmlParserCtxtPtr ctxt = xmlCreateFileParserCtxt(StringValueCStr(filename));

      if (ctxt->sax) {
        xmlFree(ctxt->sax);
        ctxt->sax = NULL;
      }

      return noko_xml_sax_parser_context_wrap(klass, ctxt);
    }

parse_io(io, encoding) click to toggle source

Parse `io` object with `encoding`

    static VALUE
    parse_io(VALUE klass, VALUE io, VALUE encoding)
    {
      xmlParserCtxtPtr ctxt;
      xmlCharEncoding enc = (xmlCharEncoding)NUM2INT(encoding);

      if (!rb_respond_to(io, id_read)) {
        rb_raise(rb_eTypeError, "argument expected to respond to :read");
      }

      ctxt = xmlCreateIOParserCtxt(NULL, NULL,
                                   (xmlInputReadCallback)noko_io_read,
                                   (xmlInputCloseCallback)noko_io_close,
                                   (void *)io, enc);
      if (ctxt->sax) {
        xmlFree(ctxt->sax);
        ctxt->sax = NULL;
      }

      return noko_xml_sax_parser_context_wrap(klass, ctxt);
    }

parse_memory(data) click to toggle source

Parse the `XML` stored in memory in `data`

    static VALUE
    parse_memory(VALUE klass, VALUE data)
    {
      xmlParserCtxtPtr ctxt;

      Check_Type(data, T_STRING);

      if (!(int)RSTRING_LEN(data)) {
        rb_raise(rb_eRuntimeError, "data cannot be empty");
      }

      ctxt = xmlCreateMemoryParserCtxt(StringValuePtr(data),
                                       (int)RSTRING_LEN(data));
      if (ctxt->sax) {
        xmlFree(ctxt->sax);
        ctxt->sax = NULL;
      }

      return noko_xml_sax_parser_context_wrap(klass, ctxt);
    }

new(thing, encoding = "UTF-8") click to toggle source

    # File lib/nokogiri/xml/sax/parser_context.rb, line 11
    def self.new(thing, encoding = "UTF-8")
      if [:read, :close].all? { |x| thing.respond_to?(x) }
        io(thing, Parser::ENCODINGS[encoding])
      else
        memory(thing)
      end
    end

### Public Instance Methods

column click to toggle source

Get the current column the parser context is processing.

    static VALUE
    column(VALUE self)
    {
      xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(self);
      xmlParserInputPtr io;

      io = ctxt->input;
      if (io) {
        return INT2NUM(io->col);
      }

      return Qnil;
    }

line click to toggle source

Get the current line the parser context is processing.

    static VALUE
    line(VALUE self)
    {
      xmlParserInputPtr io;
      xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(self);

      io = ctxt->input;
      if (io) {
        return INT2NUM(io->line);
      }

      return Qnil;
    }

parse_with(sax_handler) click to toggle source

Use `sax_handler` and parse the current document

    static VALUE
    parse_with(VALUE self, VALUE sax_handler)
    {
      xmlParserCtxtPtr ctxt;
      xmlSAXHandlerPtr sax;

      if (!rb_obj_is_kind_of(sax_handler, cNokogiriXmlSaxParser)) {
        rb_raise(rb_eArgError, "argument must be a Nokogiri::XML::SAX::Parser");
      }

      ctxt = noko_xml_sax_parser_context_unwrap(self);
      sax = noko_sax_handler_unwrap(sax_handler);

      ctxt->sax = sax;
      ctxt->userData = (void *)NOKOGIRI_SAX_TUPLE_NEW(ctxt, sax_handler);

      xmlSetStructuredErrorFunc(NULL, NULL);

      rb_ensure(parse_doc, (VALUE)ctxt, parse_doc_finalize, (VALUE)ctxt);

      return Qnil;
    }

recovery click to toggle source

Should this parser recover from structural errors? It will not stop processing file on structural errors if set to true

    static VALUE
    get_recovery(VALUE self)
    {
      xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(self);

      if (ctxt->recovery == 0) {
        return Qfalse;
      } else {
        return Qtrue;
      }
    }

recovery=(boolean) click to toggle source

Should this parser recover from structural errors? It will not stop processing file on structural errors if set to true

    static VALUE
    set_recovery(VALUE self, VALUE value)
    {
      xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(self);

      if (value == Qfalse) {
        ctxt->recovery = 0;
      } else {
        ctxt->recovery = 1;
      }

      return value;
    }

replace_entities click to toggle source

Should this parser replace entities? &amp; will get converted to ‘&’ if set to true

    static VALUE
    get_replace_entities(VALUE self)
    {
      xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(self);

      if (0 == ctxt->replaceEntities) {
        return Qfalse;
      } else {
        return Qtrue;
      }
    }

replace_entities=(boolean) click to toggle source

Should this parser replace entities? &amp; will get converted to ‘&’ if set to true

    static VALUE
    set_replace_entities(VALUE self, VALUE value)
    {
      xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(self);

      if (Qfalse == value) {
        ctxt->replaceEntities = 0;
      } else {
        ctxt->replaceEntities = 1;
      }

      return value;
    }