Class: Nokogiri::XML::SAX::ParserContext

Inherits:
Object
  • Object
show all
Defined in:
lib/nokogiri/xml/sax/parser_context.rb,
ext/nokogiri/xml_sax_parser_context.c,
ext/nokogiri/html_sax_parser_context.c

Overview

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

Direct Known Subclasses

HTML::SAX::ParserContext

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.parse_file(filename) ⇒ Object

Parse file given filename



46
47
48
49
50
 
# File 'ext/nokogiri/xml_sax_parser_context.c', line 46

static VALUE parse_file(VALUE klass, VALUE filename)
{
  xmlParserCtxtPtr ctxt = xmlCreateFileParserCtxt(StringValueCStr(filename));
  return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
}

.parse_io(io, encoding) ⇒ Object

Parse io object with encoding



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'ext/nokogiri/xml_sax_parser_context.c', line 22

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

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

    return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
}

.parse_memory(data) ⇒ Object

Parse the XML stored in memory in data



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'ext/nokogiri/xml_sax_parser_context.c', line 58

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

    if (NIL_P(data))
  rb_raise(rb_eArgError, "data cannot be nil");
    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 Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
}

.new(thing, encoding = 'UTF-8') ⇒ Object 



9
10
11
12
 
# File 'lib/nokogiri/xml/sax/parser_context.rb', line 9

def self.new thing, encoding = 'UTF-8'
  [:read, :close].all? { |x| thing.respond_to?(x) } ?
    io(thing, Parser::ENCODINGS[encoding]) : memory(thing)
end

Instance Method Details

#column ⇒ Object

Get the current column the parser context is processing.



190
191
192
193
194
195
196
197
198
199
200
201
202
 
# File 'ext/nokogiri/xml_sax_parser_context.c', line 190

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

  Data_Get_Struct(self, xmlParserCtxt, ctxt);

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

  return Qnil;
}

#line ⇒ Object

Get the current line the parser context is processing.



171
172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'ext/nokogiri/xml_sax_parser_context.c', line 171

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

  Data_Get_Struct(self, xmlParserCtxt, ctxt);

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

  return Qnil;
}

#parse_with(sax_handler) ⇒ Object

Use sax_handler and parse the current document



104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'ext/nokogiri/xml_sax_parser_context.c', line 104

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");

    Data_Get_Struct(self, xmlParserCtxt, ctxt);
    Data_Get_Struct(sax_handler, xmlSAXHandler, sax);

    /* Free the sax handler since we'll assign our own */
    if (ctxt->sax && ctxt->sax != (xmlSAXHandlerPtr)&xmlDefaultSAXHandler)
  xmlFree(ctxt->sax);

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

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

    return Qnil;
}

#recovery ⇒ Object

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



231
232
233
234
235
236
237
238
239
240
 
# File 'ext/nokogiri/xml_sax_parser_context.c', line 231

static VALUE get_recovery(VALUE self)
{
  xmlParserCtxtPtr ctxt;
  Data_Get_Struct(self, xmlParserCtxt, ctxt);

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

#recovery=(boolean) ⇒ Object

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



211
212
213
214
215
216
217
218
219
220
221
222
 
# File 'ext/nokogiri/xml_sax_parser_context.c', line 211

static VALUE set_recovery(VALUE self, VALUE value)
{
  xmlParserCtxtPtr ctxt;
  Data_Get_Struct(self, xmlParserCtxt, ctxt);

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

  return value;
}

#replace_entities ⇒ Object

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



155
156
157
158
159
160
161
162
163
164
 
# File 'ext/nokogiri/xml_sax_parser_context.c', line 155

static VALUE get_replace_entities(VALUE self)
{
  xmlParserCtxtPtr ctxt;
  Data_Get_Struct(self, xmlParserCtxt, ctxt);

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

#replace_entities=(boolean) ⇒ Object

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



135
136
137
138
139
140
141
142
143
144
145
146
 
# File 'ext/nokogiri/xml_sax_parser_context.c', line 135

static VALUE set_replace_entities(VALUE self, VALUE value)
{
  xmlParserCtxtPtr ctxt;
  Data_Get_Struct(self, xmlParserCtxt, ctxt);

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

  return value;
}