nokogiri 1.11.0.rc1-x86-linux

Sign up to get free protection for your applications and to get access to all the features.

Potentially problematic release.


This version of nokogiri might be problematic. Click here for more details.

Files changed (145) hide show
  1. checksums.yaml +7 -0
  2. data/LICENSE-DEPENDENCIES.md +1614 -0
  3. data/LICENSE.md +9 -0
  4. data/README.md +200 -0
  5. data/bin/nokogiri +118 -0
  6. data/dependencies.yml +74 -0
  7. data/ext/nokogiri/depend +358 -0
  8. data/ext/nokogiri/extconf.rb +695 -0
  9. data/ext/nokogiri/html_document.c +170 -0
  10. data/ext/nokogiri/html_document.h +10 -0
  11. data/ext/nokogiri/html_element_description.c +279 -0
  12. data/ext/nokogiri/html_element_description.h +10 -0
  13. data/ext/nokogiri/html_entity_lookup.c +32 -0
  14. data/ext/nokogiri/html_entity_lookup.h +8 -0
  15. data/ext/nokogiri/html_sax_parser_context.c +116 -0
  16. data/ext/nokogiri/html_sax_parser_context.h +11 -0
  17. data/ext/nokogiri/html_sax_push_parser.c +87 -0
  18. data/ext/nokogiri/html_sax_push_parser.h +9 -0
  19. data/ext/nokogiri/nokogiri.c +147 -0
  20. data/ext/nokogiri/nokogiri.h +122 -0
  21. data/ext/nokogiri/xml_attr.c +103 -0
  22. data/ext/nokogiri/xml_attr.h +9 -0
  23. data/ext/nokogiri/xml_attribute_decl.c +70 -0
  24. data/ext/nokogiri/xml_attribute_decl.h +9 -0
  25. data/ext/nokogiri/xml_cdata.c +62 -0
  26. data/ext/nokogiri/xml_cdata.h +9 -0
  27. data/ext/nokogiri/xml_comment.c +69 -0
  28. data/ext/nokogiri/xml_comment.h +9 -0
  29. data/ext/nokogiri/xml_document.c +617 -0
  30. data/ext/nokogiri/xml_document.h +23 -0
  31. data/ext/nokogiri/xml_document_fragment.c +48 -0
  32. data/ext/nokogiri/xml_document_fragment.h +10 -0
  33. data/ext/nokogiri/xml_dtd.c +202 -0
  34. data/ext/nokogiri/xml_dtd.h +10 -0
  35. data/ext/nokogiri/xml_element_content.c +123 -0
  36. data/ext/nokogiri/xml_element_content.h +10 -0
  37. data/ext/nokogiri/xml_element_decl.c +69 -0
  38. data/ext/nokogiri/xml_element_decl.h +9 -0
  39. data/ext/nokogiri/xml_encoding_handler.c +79 -0
  40. data/ext/nokogiri/xml_encoding_handler.h +8 -0
  41. data/ext/nokogiri/xml_entity_decl.c +110 -0
  42. data/ext/nokogiri/xml_entity_decl.h +10 -0
  43. data/ext/nokogiri/xml_entity_reference.c +52 -0
  44. data/ext/nokogiri/xml_entity_reference.h +9 -0
  45. data/ext/nokogiri/xml_io.c +61 -0
  46. data/ext/nokogiri/xml_io.h +11 -0
  47. data/ext/nokogiri/xml_libxml2_hacks.c +112 -0
  48. data/ext/nokogiri/xml_libxml2_hacks.h +12 -0
  49. data/ext/nokogiri/xml_namespace.c +111 -0
  50. data/ext/nokogiri/xml_namespace.h +14 -0
  51. data/ext/nokogiri/xml_node.c +1773 -0
  52. data/ext/nokogiri/xml_node.h +13 -0
  53. data/ext/nokogiri/xml_node_set.c +486 -0
  54. data/ext/nokogiri/xml_node_set.h +12 -0
  55. data/ext/nokogiri/xml_processing_instruction.c +56 -0
  56. data/ext/nokogiri/xml_processing_instruction.h +9 -0
  57. data/ext/nokogiri/xml_reader.c +668 -0
  58. data/ext/nokogiri/xml_reader.h +10 -0
  59. data/ext/nokogiri/xml_relax_ng.c +161 -0
  60. data/ext/nokogiri/xml_relax_ng.h +9 -0
  61. data/ext/nokogiri/xml_sax_parser.c +310 -0
  62. data/ext/nokogiri/xml_sax_parser.h +39 -0
  63. data/ext/nokogiri/xml_sax_parser_context.c +262 -0
  64. data/ext/nokogiri/xml_sax_parser_context.h +10 -0
  65. data/ext/nokogiri/xml_sax_push_parser.c +159 -0
  66. data/ext/nokogiri/xml_sax_push_parser.h +9 -0
  67. data/ext/nokogiri/xml_schema.c +205 -0
  68. data/ext/nokogiri/xml_schema.h +9 -0
  69. data/ext/nokogiri/xml_syntax_error.c +64 -0
  70. data/ext/nokogiri/xml_syntax_error.h +13 -0
  71. data/ext/nokogiri/xml_text.c +52 -0
  72. data/ext/nokogiri/xml_text.h +9 -0
  73. data/ext/nokogiri/xml_xpath_context.c +298 -0
  74. data/ext/nokogiri/xml_xpath_context.h +10 -0
  75. data/ext/nokogiri/xslt_stylesheet.c +266 -0
  76. data/ext/nokogiri/xslt_stylesheet.h +14 -0
  77. data/lib/nokogiri.rb +127 -0
  78. data/lib/nokogiri/2.4/nokogiri.so +0 -0
  79. data/lib/nokogiri/2.5/nokogiri.so +0 -0
  80. data/lib/nokogiri/2.6/nokogiri.so +0 -0
  81. data/lib/nokogiri/2.7/nokogiri.so +0 -0
  82. data/lib/nokogiri/css.rb +28 -0
  83. data/lib/nokogiri/css/node.rb +53 -0
  84. data/lib/nokogiri/css/parser.rb +751 -0
  85. data/lib/nokogiri/css/parser.y +272 -0
  86. data/lib/nokogiri/css/parser_extras.rb +92 -0
  87. data/lib/nokogiri/css/syntax_error.rb +8 -0
  88. data/lib/nokogiri/css/tokenizer.rb +154 -0
  89. data/lib/nokogiri/css/tokenizer.rex +55 -0
  90. data/lib/nokogiri/css/xpath_visitor.rb +232 -0
  91. data/lib/nokogiri/decorators/slop.rb +43 -0
  92. data/lib/nokogiri/html.rb +38 -0
  93. data/lib/nokogiri/html/builder.rb +36 -0
  94. data/lib/nokogiri/html/document.rb +336 -0
  95. data/lib/nokogiri/html/document_fragment.rb +50 -0
  96. data/lib/nokogiri/html/element_description.rb +24 -0
  97. data/lib/nokogiri/html/element_description_defaults.rb +672 -0
  98. data/lib/nokogiri/html/entity_lookup.rb +14 -0
  99. data/lib/nokogiri/html/sax/parser.rb +63 -0
  100. data/lib/nokogiri/html/sax/parser_context.rb +17 -0
  101. data/lib/nokogiri/html/sax/push_parser.rb +37 -0
  102. data/lib/nokogiri/jruby/dependencies.rb +20 -0
  103. data/lib/nokogiri/syntax_error.rb +5 -0
  104. data/lib/nokogiri/version.rb +149 -0
  105. data/lib/nokogiri/xml.rb +76 -0
  106. data/lib/nokogiri/xml/attr.rb +15 -0
  107. data/lib/nokogiri/xml/attribute_decl.rb +19 -0
  108. data/lib/nokogiri/xml/builder.rb +447 -0
  109. data/lib/nokogiri/xml/cdata.rb +12 -0
  110. data/lib/nokogiri/xml/character_data.rb +8 -0
  111. data/lib/nokogiri/xml/document.rb +280 -0
  112. data/lib/nokogiri/xml/document_fragment.rb +161 -0
  113. data/lib/nokogiri/xml/dtd.rb +33 -0
  114. data/lib/nokogiri/xml/element_content.rb +37 -0
  115. data/lib/nokogiri/xml/element_decl.rb +14 -0
  116. data/lib/nokogiri/xml/entity_decl.rb +20 -0
  117. data/lib/nokogiri/xml/entity_reference.rb +19 -0
  118. data/lib/nokogiri/xml/namespace.rb +14 -0
  119. data/lib/nokogiri/xml/node.rb +916 -0
  120. data/lib/nokogiri/xml/node/save_options.rb +62 -0
  121. data/lib/nokogiri/xml/node_set.rb +372 -0
  122. data/lib/nokogiri/xml/notation.rb +7 -0
  123. data/lib/nokogiri/xml/parse_options.rb +121 -0
  124. data/lib/nokogiri/xml/pp.rb +3 -0
  125. data/lib/nokogiri/xml/pp/character_data.rb +19 -0
  126. data/lib/nokogiri/xml/pp/node.rb +57 -0
  127. data/lib/nokogiri/xml/processing_instruction.rb +9 -0
  128. data/lib/nokogiri/xml/reader.rb +116 -0
  129. data/lib/nokogiri/xml/relax_ng.rb +33 -0
  130. data/lib/nokogiri/xml/sax.rb +5 -0
  131. data/lib/nokogiri/xml/sax/document.rb +172 -0
  132. data/lib/nokogiri/xml/sax/parser.rb +123 -0
  133. data/lib/nokogiri/xml/sax/parser_context.rb +17 -0
  134. data/lib/nokogiri/xml/sax/push_parser.rb +61 -0
  135. data/lib/nokogiri/xml/schema.rb +64 -0
  136. data/lib/nokogiri/xml/searchable.rb +231 -0
  137. data/lib/nokogiri/xml/syntax_error.rb +71 -0
  138. data/lib/nokogiri/xml/text.rb +10 -0
  139. data/lib/nokogiri/xml/xpath.rb +11 -0
  140. data/lib/nokogiri/xml/xpath/syntax_error.rb +12 -0
  141. data/lib/nokogiri/xml/xpath_context.rb +17 -0
  142. data/lib/nokogiri/xslt.rb +57 -0
  143. data/lib/nokogiri/xslt/stylesheet.rb +26 -0
  144. data/lib/xsd/xmlparser/nokogiri.rb +103 -0
  145. metadata +482 -0
@@ -0,0 +1,12 @@
1
+ #ifndef HAVE_XMLFIRSTELEMENTCHILD
2
+
3
+ #ifndef XML_LIBXML2_HACKS
4
+ #define XML_LIBXML2_HACKS
5
+
6
+ xmlNodePtr xmlFirstElementChild(xmlNodePtr parent);
7
+ xmlNodePtr xmlNextElementSibling(xmlNodePtr node);
8
+ xmlNodePtr xmlLastElementChild(xmlNodePtr parent);
9
+
10
+ #endif
11
+
12
+ #endif
@@ -0,0 +1,111 @@
1
+ #include <xml_namespace.h>
2
+
3
+ VALUE cNokogiriXmlNamespace ;
4
+
5
+ static void dealloc_namespace(xmlNsPtr ns)
6
+ {
7
+ /*
8
+ *
9
+ * this deallocator is only used for namespace nodes that are part of an xpath
10
+ * node set.
11
+ *
12
+ * see Nokogiri_wrap_xml_namespace() for more details.
13
+ *
14
+ */
15
+ NOKOGIRI_DEBUG_START(ns) ;
16
+ if (ns->href) {
17
+ xmlFree((xmlChar *)(uintptr_t)ns->href);
18
+ }
19
+ if (ns->prefix) {
20
+ xmlFree((xmlChar *)(uintptr_t)ns->prefix);
21
+ }
22
+ xmlFree(ns);
23
+ NOKOGIRI_DEBUG_END(ns) ;
24
+ }
25
+
26
+
27
+ /*
28
+ * call-seq:
29
+ * prefix
30
+ *
31
+ * Get the prefix for this namespace. Returns +nil+ if there is no prefix.
32
+ */
33
+ static VALUE prefix(VALUE self)
34
+ {
35
+ xmlNsPtr ns;
36
+
37
+ Data_Get_Struct(self, xmlNs, ns);
38
+ if(!ns->prefix) return Qnil;
39
+
40
+ return NOKOGIRI_STR_NEW2(ns->prefix);
41
+ }
42
+
43
+ /*
44
+ * call-seq:
45
+ * href
46
+ *
47
+ * Get the href for this namespace
48
+ */
49
+ static VALUE href(VALUE self)
50
+ {
51
+ xmlNsPtr ns;
52
+
53
+ Data_Get_Struct(self, xmlNs, ns);
54
+ if(!ns->href) return Qnil;
55
+
56
+ return NOKOGIRI_STR_NEW2(ns->href);
57
+ }
58
+
59
+ static int part_of_an_xpath_node_set_eh(xmlNsPtr node)
60
+ {
61
+ return (node->next && ! NOKOGIRI_NAMESPACE_EH(node->next));
62
+ }
63
+
64
+ VALUE Nokogiri_wrap_xml_namespace(xmlDocPtr doc, xmlNsPtr node)
65
+ {
66
+ VALUE ns = 0, document, node_cache;
67
+
68
+ assert(doc->type == XML_DOCUMENT_NODE || doc->type == XML_HTML_DOCUMENT_NODE);
69
+
70
+ if (node->_private) return (VALUE)node->_private;
71
+
72
+ if (doc->type == XML_DOCUMENT_FRAG_NODE) doc = doc->doc;
73
+
74
+ if (DOC_RUBY_OBJECT_TEST(doc)) {
75
+ document = DOC_RUBY_OBJECT(doc);
76
+
77
+ if (part_of_an_xpath_node_set_eh(node)) {
78
+ /*
79
+ * this is a duplicate returned as part of an xpath query node set, and so
80
+ * we need to make sure we manage this memory.
81
+ *
82
+ * see comments in xml_node_set.c for more details.
83
+ */
84
+ ns = Data_Wrap_Struct(cNokogiriXmlNamespace, 0, dealloc_namespace, node);
85
+ } else {
86
+ ns = Data_Wrap_Struct(cNokogiriXmlNamespace, 0, 0, node);
87
+ node_cache = rb_iv_get(document, "@node_cache");
88
+ rb_ary_push(node_cache, ns);
89
+ }
90
+
91
+ rb_iv_set(ns, "@document", document);
92
+ } else {
93
+ ns = Data_Wrap_Struct(cNokogiriXmlNamespace, 0, 0, node);
94
+ }
95
+
96
+ node->_private = (void *)ns;
97
+
98
+ return ns;
99
+ }
100
+
101
+ void init_xml_namespace()
102
+ {
103
+ VALUE nokogiri = rb_define_module("Nokogiri");
104
+ VALUE xml = rb_define_module_under(nokogiri, "XML");
105
+ VALUE klass = rb_define_class_under(xml, "Namespace", rb_cObject);
106
+
107
+ cNokogiriXmlNamespace = klass;
108
+
109
+ rb_define_method(klass, "prefix", prefix, 0);
110
+ rb_define_method(klass, "href", href, 0);
111
+ }
@@ -0,0 +1,14 @@
1
+ #ifndef NOKOGIRI_XML_NAMESPACE
2
+ #define NOKOGIRI_XML_NAMESPACE
3
+
4
+ #include <nokogiri.h>
5
+
6
+ void init_xml_namespace();
7
+
8
+ extern VALUE cNokogiriXmlNamespace ;
9
+
10
+ VALUE Nokogiri_wrap_xml_namespace(xmlDocPtr doc, xmlNsPtr node);
11
+
12
+ #define NOKOGIRI_NAMESPACE_EH(node) ((node)->type == XML_NAMESPACE_DECL)
13
+
14
+ #endif
@@ -0,0 +1,1773 @@
1
+ #include <xml_node.h>
2
+
3
+ static ID decorate, decorate_bang;
4
+
5
+ #ifdef DEBUG
6
+ static void debug_node_dealloc(xmlNodePtr x)
7
+ {
8
+ NOKOGIRI_DEBUG_START(x)
9
+ NOKOGIRI_DEBUG_END(x)
10
+ }
11
+ #else
12
+ # define debug_node_dealloc 0
13
+ #endif
14
+
15
+ static void mark(xmlNodePtr node)
16
+ {
17
+ xmlDocPtr doc = node->doc;
18
+ if(doc->type == XML_DOCUMENT_NODE || doc->type == XML_HTML_DOCUMENT_NODE) {
19
+ if(DOC_RUBY_OBJECT_TEST(doc)) {
20
+ rb_gc_mark(DOC_RUBY_OBJECT(doc));
21
+ }
22
+ } else if(node->doc->_private) {
23
+ rb_gc_mark((VALUE)doc->_private);
24
+ }
25
+ }
26
+
27
+ /* :nodoc: */
28
+ typedef xmlNodePtr (*pivot_reparentee_func)(xmlNodePtr, xmlNodePtr);
29
+
30
+ /* :nodoc: */
31
+ static void relink_namespace(xmlNodePtr reparented)
32
+ {
33
+ xmlNodePtr child;
34
+
35
+ if (reparented->type != XML_ATTRIBUTE_NODE &&
36
+ reparented->type != XML_ELEMENT_NODE) { return; }
37
+
38
+ if (reparented->ns == NULL || reparented->ns->prefix == NULL) {
39
+ xmlNsPtr ns = NULL;
40
+ xmlChar *name = NULL, *prefix = NULL;
41
+
42
+ name = xmlSplitQName2(reparented->name, &prefix);
43
+
44
+ if (reparented->type == XML_ATTRIBUTE_NODE) {
45
+ if (prefix == NULL || strcmp((char*)prefix, XMLNS_PREFIX) == 0) {
46
+ xmlFree(name);
47
+ xmlFree(prefix);
48
+ return;
49
+ }
50
+ }
51
+
52
+ ns = xmlSearchNs(reparented->doc, reparented, prefix);
53
+
54
+ if (ns != NULL) {
55
+ xmlNodeSetName(reparented, name);
56
+ xmlSetNs(reparented, ns);
57
+ }
58
+
59
+ xmlFree(name);
60
+ xmlFree(prefix);
61
+ }
62
+
63
+ /* Avoid segv when relinking against unlinked nodes. */
64
+ if (reparented->type != XML_ELEMENT_NODE || !reparented->parent) { return; }
65
+
66
+ /* Make sure that our reparented node has the correct namespaces */
67
+ if (!reparented->ns && reparented->doc != (xmlDocPtr)reparented->parent) {
68
+ xmlSetNs(reparented, reparented->parent->ns);
69
+ }
70
+
71
+ /* Search our parents for an existing definition */
72
+ if (reparented->nsDef) {
73
+ xmlNsPtr curr = reparented->nsDef;
74
+ xmlNsPtr prev = NULL;
75
+
76
+ while (curr) {
77
+ xmlNsPtr ns = xmlSearchNsByHref(
78
+ reparented->doc,
79
+ reparented->parent,
80
+ curr->href
81
+ );
82
+ /* If we find the namespace is already declared, remove it from this
83
+ * definition list. */
84
+ if (ns && ns != curr && xmlStrEqual(ns->prefix, curr->prefix)) {
85
+ if (prev) {
86
+ prev->next = curr->next;
87
+ } else {
88
+ reparented->nsDef = curr->next;
89
+ }
90
+ nokogiri_root_nsdef(curr, reparented->doc);
91
+ } else {
92
+ prev = curr;
93
+ }
94
+ curr = curr->next;
95
+ }
96
+ }
97
+
98
+ /*
99
+ * Search our parents for an existing definition of current namespace,
100
+ * because the definition it's pointing to may have just been removed nsDef.
101
+ *
102
+ * And although that would technically probably be OK, I'd feel better if we
103
+ * referred to a namespace that's still present in a node's nsDef somewhere
104
+ * in the doc.
105
+ */
106
+ if (reparented->ns) {
107
+ xmlNsPtr ns = xmlSearchNs(reparented->doc, reparented, reparented->ns->prefix);
108
+ if (ns
109
+ && ns != reparented->ns
110
+ && xmlStrEqual(ns->prefix, reparented->ns->prefix)
111
+ && xmlStrEqual(ns->href, reparented->ns->href)
112
+ ) {
113
+ xmlSetNs(reparented, ns);
114
+ }
115
+ }
116
+
117
+ /* Only walk all children if there actually is a namespace we need to */
118
+ /* reparent. */
119
+ if (NULL == reparented->ns) { return; }
120
+
121
+ /* When a node gets reparented, walk it's children to make sure that */
122
+ /* their namespaces are reparented as well. */
123
+ child = reparented->children;
124
+ while (NULL != child) {
125
+ relink_namespace(child);
126
+ child = child->next;
127
+ }
128
+
129
+ if (reparented->type == XML_ELEMENT_NODE) {
130
+ child = (xmlNodePtr)((xmlElementPtr)reparented)->attributes;
131
+ while(NULL != child) {
132
+ relink_namespace(child);
133
+ child = child->next;
134
+ }
135
+ }
136
+ }
137
+
138
+ /* :nodoc: */
139
+ static xmlNodePtr xmlReplaceNodeWrapper(xmlNodePtr pivot, xmlNodePtr new_node)
140
+ {
141
+ xmlNodePtr retval ;
142
+
143
+ retval = xmlReplaceNode(pivot, new_node) ;
144
+
145
+ if (retval == pivot) {
146
+ retval = new_node ; /* return semantics for reparent_node_with */
147
+ }
148
+
149
+ /* work around libxml2 issue: https://bugzilla.gnome.org/show_bug.cgi?id=615612 */
150
+ if (retval && retval->type == XML_TEXT_NODE) {
151
+ if (retval->prev && retval->prev->type == XML_TEXT_NODE) {
152
+ retval = xmlTextMerge(retval->prev, retval);
153
+ }
154
+ if (retval->next && retval->next->type == XML_TEXT_NODE) {
155
+ retval = xmlTextMerge(retval, retval->next);
156
+ }
157
+ }
158
+
159
+ return retval ;
160
+ }
161
+
162
+ /* :nodoc: */
163
+ static VALUE reparent_node_with(VALUE pivot_obj, VALUE reparentee_obj, pivot_reparentee_func prf)
164
+ {
165
+ VALUE reparented_obj ;
166
+ xmlNodePtr reparentee, pivot, reparented, next_text, new_next_text, parent ;
167
+ int original_ns_prefix_is_default = 0 ;
168
+
169
+ if(!rb_obj_is_kind_of(reparentee_obj, cNokogiriXmlNode)) {
170
+ rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node");
171
+ }
172
+ if(rb_obj_is_kind_of(reparentee_obj, cNokogiriXmlDocument)) {
173
+ rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node");
174
+ }
175
+
176
+ Data_Get_Struct(reparentee_obj, xmlNode, reparentee);
177
+ Data_Get_Struct(pivot_obj, xmlNode, pivot);
178
+
179
+ /*
180
+ * Check if nodes given are appropriate to have a parent-child
181
+ * relationship, based on the DOM specification.
182
+ *
183
+ * cf. http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#ID-1590626202
184
+ */
185
+ if (prf == xmlAddChild) {
186
+ parent = pivot;
187
+ } else {
188
+ parent = pivot->parent;
189
+ }
190
+
191
+ if (parent) {
192
+ switch (parent->type) {
193
+ case XML_DOCUMENT_NODE:
194
+ case XML_HTML_DOCUMENT_NODE:
195
+ switch (reparentee->type) {
196
+ case XML_ELEMENT_NODE:
197
+ case XML_PI_NODE:
198
+ case XML_COMMENT_NODE:
199
+ case XML_DOCUMENT_TYPE_NODE:
200
+ /*
201
+ * The DOM specification says no to adding text-like nodes
202
+ * directly to a document, but we allow it for compatibility.
203
+ */
204
+ case XML_TEXT_NODE:
205
+ case XML_CDATA_SECTION_NODE:
206
+ case XML_ENTITY_REF_NODE:
207
+ goto ok;
208
+ default:
209
+ break;
210
+ }
211
+ break;
212
+ case XML_DOCUMENT_FRAG_NODE:
213
+ case XML_ENTITY_REF_NODE:
214
+ case XML_ELEMENT_NODE:
215
+ switch (reparentee->type) {
216
+ case XML_ELEMENT_NODE:
217
+ case XML_PI_NODE:
218
+ case XML_COMMENT_NODE:
219
+ case XML_TEXT_NODE:
220
+ case XML_CDATA_SECTION_NODE:
221
+ case XML_ENTITY_REF_NODE:
222
+ goto ok;
223
+ default:
224
+ break;
225
+ }
226
+ break;
227
+ case XML_ATTRIBUTE_NODE:
228
+ switch (reparentee->type) {
229
+ case XML_TEXT_NODE:
230
+ case XML_ENTITY_REF_NODE:
231
+ goto ok;
232
+ default:
233
+ break;
234
+ }
235
+ break;
236
+ case XML_TEXT_NODE:
237
+ /*
238
+ * xmlAddChild() breaks the DOM specification in that it allows
239
+ * adding a text node to another, in which case text nodes are
240
+ * coalesced, but since our JRuby version does not support such
241
+ * operation, we should inhibit it.
242
+ */
243
+ break;
244
+ default:
245
+ break;
246
+ }
247
+
248
+ rb_raise(rb_eArgError, "cannot reparent %s there", rb_obj_classname(reparentee_obj));
249
+ }
250
+
251
+ ok:
252
+ xmlUnlinkNode(reparentee);
253
+
254
+ if (reparentee->doc != pivot->doc || reparentee->type == XML_TEXT_NODE) {
255
+ /*
256
+ * if the reparentee is a text node, there's a very good chance it will be
257
+ * merged with an adjacent text node after being reparented, and in that case
258
+ * libxml will free the underlying C struct.
259
+ *
260
+ * since we clearly have a ruby object which references the underlying
261
+ * memory, we can't let the C struct get freed. let's pickle the original
262
+ * reparentee by rooting it; and then we'll reparent a duplicate of the
263
+ * node that we don't care about preserving.
264
+ *
265
+ * alternatively, if the reparentee is from a different document than the
266
+ * pivot node, libxml2 is going to get confused about which document's
267
+ * "dictionary" the node's strings belong to (this is an otherwise
268
+ * uninteresting libxml2 implementation detail). as a result, we cannot
269
+ * reparent the actual reparentee, so we reparent a duplicate.
270
+ */
271
+ if (reparentee->type == XML_TEXT_NODE && reparentee->_private) {
272
+ /*
273
+ * additionally, since we know this C struct isn't going to be related to
274
+ * a Ruby object anymore, let's break the relationship on this end as
275
+ * well.
276
+ *
277
+ * this is not absolutely necessary unless libxml-ruby is also in effect,
278
+ * in which case its global callback `rxml_node_deregisterNode` will try
279
+ * to do things to our data.
280
+ *
281
+ * for more details on this particular (and particularly nasty) edge
282
+ * case, see:
283
+ *
284
+ * https://github.com/sparklemotion/nokogiri/issues/1426
285
+ */
286
+ reparentee->_private = NULL ;
287
+ }
288
+
289
+ if (reparentee->ns != NULL && reparentee->ns->prefix == NULL) {
290
+ original_ns_prefix_is_default = 1;
291
+ }
292
+
293
+ nokogiri_root_node(reparentee);
294
+
295
+ if (!(reparentee = xmlDocCopyNode(reparentee, pivot->doc, 1))) {
296
+ rb_raise(rb_eRuntimeError, "Could not reparent node (xmlDocCopyNode)");
297
+ }
298
+
299
+ if (original_ns_prefix_is_default && reparentee->ns != NULL && reparentee->ns->prefix != NULL) {
300
+ /*
301
+ * issue #391, where new node's prefix may become the string "default"
302
+ * see libxml2 tree.c xmlNewReconciliedNs which implements this behavior.
303
+ */
304
+ xmlFree(reparentee->ns->prefix);
305
+ reparentee->ns->prefix = NULL;
306
+ }
307
+ }
308
+
309
+ if (prf != xmlAddPrevSibling && prf != xmlAddNextSibling
310
+ && reparentee->type == XML_TEXT_NODE && pivot->next && pivot->next->type == XML_TEXT_NODE) {
311
+ /*
312
+ * libxml merges text nodes in a right-to-left fashion, meaning that if
313
+ * there are two text nodes who would be adjacent, the right (or following,
314
+ * or next) node will be merged into the left (or preceding, or previous)
315
+ * node.
316
+ *
317
+ * and by "merged" I mean the string contents will be concatenated onto the
318
+ * left node's contents, and then the node will be freed.
319
+ *
320
+ * which means that if we have a ruby object wrapped around the right node,
321
+ * its memory would be freed out from under it.
322
+ *
323
+ * so, we detect this edge case and unlink-and-root the text node before it gets
324
+ * merged. then we dup the node and insert that duplicate back into the
325
+ * document where the real node was.
326
+ *
327
+ * yes, this is totally lame.
328
+ */
329
+ next_text = pivot->next ;
330
+ new_next_text = xmlDocCopyNode(next_text, pivot->doc, 1) ;
331
+
332
+ xmlUnlinkNode(next_text);
333
+ nokogiri_root_node(next_text);
334
+
335
+ xmlAddNextSibling(pivot, new_next_text);
336
+ }
337
+
338
+ if(!(reparented = (*prf)(pivot, reparentee))) {
339
+ rb_raise(rb_eRuntimeError, "Could not reparent node");
340
+ }
341
+
342
+ /*
343
+ * make sure the ruby object is pointed at the just-reparented node, which
344
+ * might be a duplicate (see above) or might be the result of merging
345
+ * adjacent text nodes.
346
+ */
347
+ DATA_PTR(reparentee_obj) = reparented ;
348
+
349
+ relink_namespace(reparented);
350
+
351
+ reparented_obj = Nokogiri_wrap_xml_node(Qnil, reparented);
352
+
353
+ rb_funcall(reparented_obj, decorate_bang, 0);
354
+
355
+ return reparented_obj ;
356
+ }
357
+
358
+
359
+ /*
360
+ * call-seq:
361
+ * document
362
+ *
363
+ * Get the document for this Node
364
+ */
365
+ static VALUE document(VALUE self)
366
+ {
367
+ xmlNodePtr node;
368
+ Data_Get_Struct(self, xmlNode, node);
369
+ return DOC_RUBY_OBJECT(node->doc);
370
+ }
371
+
372
+ /*
373
+ * call-seq:
374
+ * pointer_id
375
+ *
376
+ * Get the internal pointer number
377
+ */
378
+ static VALUE pointer_id(VALUE self)
379
+ {
380
+ xmlNodePtr node;
381
+ Data_Get_Struct(self, xmlNode, node);
382
+
383
+ return INT2NUM((long)(node));
384
+ }
385
+
386
+ /*
387
+ * call-seq:
388
+ * encode_special_chars(string)
389
+ *
390
+ * Encode any special characters in +string+
391
+ */
392
+ static VALUE encode_special_chars(VALUE self, VALUE string)
393
+ {
394
+ xmlNodePtr node;
395
+ xmlChar *encoded;
396
+ VALUE encoded_str;
397
+
398
+ Data_Get_Struct(self, xmlNode, node);
399
+ encoded = xmlEncodeSpecialChars(
400
+ node->doc,
401
+ (const xmlChar *)StringValueCStr(string)
402
+ );
403
+
404
+ encoded_str = NOKOGIRI_STR_NEW2(encoded);
405
+ xmlFree(encoded);
406
+
407
+ return encoded_str;
408
+ }
409
+
410
+ /*
411
+ * call-seq:
412
+ * create_internal_subset(name, external_id, system_id)
413
+ *
414
+ * Create the internal subset of a document.
415
+ *
416
+ * doc.create_internal_subset("chapter", "-//OASIS//DTD DocBook XML//EN", "chapter.dtd")
417
+ * # => <!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML//EN" "chapter.dtd">
418
+ *
419
+ * doc.create_internal_subset("chapter", nil, "chapter.dtd")
420
+ * # => <!DOCTYPE chapter SYSTEM "chapter.dtd">
421
+ */
422
+ static VALUE create_internal_subset(VALUE self, VALUE name, VALUE external_id, VALUE system_id)
423
+ {
424
+ xmlNodePtr node;
425
+ xmlDocPtr doc;
426
+ xmlDtdPtr dtd;
427
+
428
+ Data_Get_Struct(self, xmlNode, node);
429
+
430
+ doc = node->doc;
431
+
432
+ if(xmlGetIntSubset(doc)) {
433
+ rb_raise(rb_eRuntimeError, "Document already has an internal subset");
434
+ }
435
+
436
+ dtd = xmlCreateIntSubset(
437
+ doc,
438
+ NIL_P(name) ? NULL : (const xmlChar *)StringValueCStr(name),
439
+ NIL_P(external_id) ? NULL : (const xmlChar *)StringValueCStr(external_id),
440
+ NIL_P(system_id) ? NULL : (const xmlChar *)StringValueCStr(system_id)
441
+ );
442
+
443
+ if(!dtd) { return Qnil; }
444
+
445
+ return Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)dtd);
446
+ }
447
+
448
+ /*
449
+ * call-seq:
450
+ * create_external_subset(name, external_id, system_id)
451
+ *
452
+ * Create an external subset
453
+ */
454
+ static VALUE create_external_subset(VALUE self, VALUE name, VALUE external_id, VALUE system_id)
455
+ {
456
+ xmlNodePtr node;
457
+ xmlDocPtr doc;
458
+ xmlDtdPtr dtd;
459
+
460
+ Data_Get_Struct(self, xmlNode, node);
461
+
462
+ doc = node->doc;
463
+
464
+ if(doc->extSubset) {
465
+ rb_raise(rb_eRuntimeError, "Document already has an external subset");
466
+ }
467
+
468
+ dtd = xmlNewDtd(
469
+ doc,
470
+ NIL_P(name) ? NULL : (const xmlChar *)StringValueCStr(name),
471
+ NIL_P(external_id) ? NULL : (const xmlChar *)StringValueCStr(external_id),
472
+ NIL_P(system_id) ? NULL : (const xmlChar *)StringValueCStr(system_id)
473
+ );
474
+
475
+ if(!dtd) { return Qnil; }
476
+
477
+ return Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)dtd);
478
+ }
479
+
480
+ /*
481
+ * call-seq:
482
+ * external_subset
483
+ *
484
+ * Get the external subset
485
+ */
486
+ static VALUE external_subset(VALUE self)
487
+ {
488
+ xmlNodePtr node;
489
+ xmlDocPtr doc;
490
+ xmlDtdPtr dtd;
491
+
492
+ Data_Get_Struct(self, xmlNode, node);
493
+
494
+ if(!node->doc) { return Qnil; }
495
+
496
+ doc = node->doc;
497
+ dtd = doc->extSubset;
498
+
499
+ if(!dtd) { return Qnil; }
500
+
501
+ return Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)dtd);
502
+ }
503
+
504
+ /*
505
+ * call-seq:
506
+ * internal_subset
507
+ *
508
+ * Get the internal subset
509
+ */
510
+ static VALUE internal_subset(VALUE self)
511
+ {
512
+ xmlNodePtr node;
513
+ xmlDocPtr doc;
514
+ xmlDtdPtr dtd;
515
+
516
+ Data_Get_Struct(self, xmlNode, node);
517
+
518
+ if(!node->doc) { return Qnil; }
519
+
520
+ doc = node->doc;
521
+ dtd = xmlGetIntSubset(doc);
522
+
523
+ if(!dtd) { return Qnil; }
524
+
525
+ return Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)dtd);
526
+ }
527
+
528
+ /*
529
+ * call-seq:
530
+ * dup
531
+ * dup(depth)
532
+ * dup(depth, new_parent_doc)
533
+ *
534
+ * Copy this node.
535
+ * An optional depth may be passed in. 0 is a shallow copy, 1 (the default) is a deep copy.
536
+ * An optional new_parent_doc may also be passed in, which will be the new
537
+ * node's parent document. Defaults to the current node's document.
538
+ * current document.
539
+ */
540
+ static VALUE duplicate_node(int argc, VALUE *argv, VALUE self)
541
+ {
542
+ VALUE r_level, r_new_parent_doc;
543
+ int level;
544
+ int n_args;
545
+ xmlDocPtr new_parent_doc;
546
+ xmlNodePtr node, dup;
547
+
548
+ Data_Get_Struct(self, xmlNode, node);
549
+
550
+ n_args = rb_scan_args(argc, argv, "02", &r_level, &r_new_parent_doc);
551
+
552
+ if (n_args < 1) {
553
+ r_level = INT2NUM((long)1);
554
+ }
555
+ level = (int)NUM2INT(r_level);
556
+
557
+ if (n_args < 2) {
558
+ new_parent_doc = node->doc;
559
+ } else {
560
+ Data_Get_Struct(r_new_parent_doc, xmlDoc, new_parent_doc);
561
+ }
562
+
563
+ dup = xmlDocCopyNode(node, new_parent_doc, level);
564
+ if(dup == NULL) { return Qnil; }
565
+
566
+ nokogiri_root_node(dup);
567
+
568
+ return Nokogiri_wrap_xml_node(rb_obj_class(self), dup);
569
+ }
570
+
571
+ /*
572
+ * call-seq:
573
+ * unlink
574
+ *
575
+ * Unlink this node from its current context.
576
+ */
577
+ static VALUE unlink_node(VALUE self)
578
+ {
579
+ xmlNodePtr node;
580
+ Data_Get_Struct(self, xmlNode, node);
581
+ xmlUnlinkNode(node);
582
+ nokogiri_root_node(node);
583
+ return self;
584
+ }
585
+
586
+ /*
587
+ * call-seq:
588
+ * blank?
589
+ *
590
+ * Is this node blank?
591
+ */
592
+ static VALUE blank_eh(VALUE self)
593
+ {
594
+ xmlNodePtr node;
595
+ Data_Get_Struct(self, xmlNode, node);
596
+ return (1 == xmlIsBlankNode(node)) ? Qtrue : Qfalse ;
597
+ }
598
+
599
+ /*
600
+ * call-seq:
601
+ * next_sibling
602
+ *
603
+ * Returns the next sibling node
604
+ */
605
+ static VALUE next_sibling(VALUE self)
606
+ {
607
+ xmlNodePtr node, sibling;
608
+ Data_Get_Struct(self, xmlNode, node);
609
+
610
+ sibling = node->next;
611
+ if(!sibling) { return Qnil; }
612
+
613
+ return Nokogiri_wrap_xml_node(Qnil, sibling) ;
614
+ }
615
+
616
+ /*
617
+ * call-seq:
618
+ * previous_sibling
619
+ *
620
+ * Returns the previous sibling node
621
+ */
622
+ static VALUE previous_sibling(VALUE self)
623
+ {
624
+ xmlNodePtr node, sibling;
625
+ Data_Get_Struct(self, xmlNode, node);
626
+
627
+ sibling = node->prev;
628
+ if(!sibling) { return Qnil; }
629
+
630
+ return Nokogiri_wrap_xml_node(Qnil, sibling);
631
+ }
632
+
633
+ /*
634
+ * call-seq:
635
+ * next_element
636
+ *
637
+ * Returns the next Nokogiri::XML::Element type sibling node.
638
+ */
639
+ static VALUE next_element(VALUE self)
640
+ {
641
+ xmlNodePtr node, sibling;
642
+ Data_Get_Struct(self, xmlNode, node);
643
+
644
+ sibling = xmlNextElementSibling(node);
645
+ if(!sibling) { return Qnil; }
646
+
647
+ return Nokogiri_wrap_xml_node(Qnil, sibling);
648
+ }
649
+
650
+ /*
651
+ * call-seq:
652
+ * previous_element
653
+ *
654
+ * Returns the previous Nokogiri::XML::Element type sibling node.
655
+ */
656
+ static VALUE previous_element(VALUE self)
657
+ {
658
+ xmlNodePtr node, sibling;
659
+ Data_Get_Struct(self, xmlNode, node);
660
+
661
+ /*
662
+ * note that we don't use xmlPreviousElementSibling here because it's buggy pre-2.7.7.
663
+ */
664
+ sibling = node->prev;
665
+ if(!sibling) { return Qnil; }
666
+
667
+ while(sibling && sibling->type != XML_ELEMENT_NODE) {
668
+ sibling = sibling->prev;
669
+ }
670
+
671
+ return sibling ? Nokogiri_wrap_xml_node(Qnil, sibling) : Qnil ;
672
+ }
673
+
674
+ /* :nodoc: */
675
+ static VALUE replace(VALUE self, VALUE new_node)
676
+ {
677
+ VALUE reparent = reparent_node_with(self, new_node, xmlReplaceNodeWrapper);
678
+
679
+ xmlNodePtr pivot;
680
+ Data_Get_Struct(self, xmlNode, pivot);
681
+ nokogiri_root_node(pivot);
682
+
683
+ return reparent;
684
+ }
685
+
686
+ /*
687
+ * call-seq:
688
+ * children
689
+ *
690
+ * Get the list of children for this node as a NodeSet
691
+ */
692
+ static VALUE children(VALUE self)
693
+ {
694
+ xmlNodePtr node;
695
+ xmlNodePtr child;
696
+ xmlNodeSetPtr set;
697
+ VALUE document;
698
+ VALUE node_set;
699
+
700
+ Data_Get_Struct(self, xmlNode, node);
701
+
702
+ child = node->children;
703
+ set = xmlXPathNodeSetCreate(child);
704
+
705
+ document = DOC_RUBY_OBJECT(node->doc);
706
+
707
+ if(!child) { return Nokogiri_wrap_xml_node_set(set, document); }
708
+
709
+ child = child->next;
710
+ while(NULL != child) {
711
+ xmlXPathNodeSetAddUnique(set, child);
712
+ child = child->next;
713
+ }
714
+
715
+ node_set = Nokogiri_wrap_xml_node_set(set, document);
716
+
717
+ return node_set;
718
+ }
719
+
720
+ /*
721
+ * call-seq:
722
+ * element_children
723
+ *
724
+ * Get the list of children for this node as a NodeSet. All nodes will be
725
+ * element nodes.
726
+ *
727
+ * Example:
728
+ *
729
+ * @doc.root.element_children.all? { |x| x.element? } # => true
730
+ */
731
+ static VALUE element_children(VALUE self)
732
+ {
733
+ xmlNodePtr node;
734
+ xmlNodePtr child;
735
+ xmlNodeSetPtr set;
736
+ VALUE document;
737
+ VALUE node_set;
738
+
739
+ Data_Get_Struct(self, xmlNode, node);
740
+
741
+ child = xmlFirstElementChild(node);
742
+ set = xmlXPathNodeSetCreate(child);
743
+
744
+ document = DOC_RUBY_OBJECT(node->doc);
745
+
746
+ if(!child) { return Nokogiri_wrap_xml_node_set(set, document); }
747
+
748
+ child = xmlNextElementSibling(child);
749
+ while(NULL != child) {
750
+ xmlXPathNodeSetAddUnique(set, child);
751
+ child = xmlNextElementSibling(child);
752
+ }
753
+
754
+ node_set = Nokogiri_wrap_xml_node_set(set, document);
755
+
756
+ return node_set;
757
+ }
758
+
759
+ /*
760
+ * call-seq:
761
+ * child
762
+ *
763
+ * Returns the child node
764
+ */
765
+ static VALUE child(VALUE self)
766
+ {
767
+ xmlNodePtr node, child;
768
+ Data_Get_Struct(self, xmlNode, node);
769
+
770
+ child = node->children;
771
+ if(!child) { return Qnil; }
772
+
773
+ return Nokogiri_wrap_xml_node(Qnil, child);
774
+ }
775
+
776
+ /*
777
+ * call-seq:
778
+ * first_element_child
779
+ *
780
+ * Returns the first child node of this node that is an element.
781
+ *
782
+ * Example:
783
+ *
784
+ * @doc.root.first_element_child.element? # => true
785
+ */
786
+ static VALUE first_element_child(VALUE self)
787
+ {
788
+ xmlNodePtr node, child;
789
+ Data_Get_Struct(self, xmlNode, node);
790
+
791
+ child = xmlFirstElementChild(node);
792
+ if(!child) { return Qnil; }
793
+
794
+ return Nokogiri_wrap_xml_node(Qnil, child);
795
+ }
796
+
797
+ /*
798
+ * call-seq:
799
+ * last_element_child
800
+ *
801
+ * Returns the last child node of this node that is an element.
802
+ *
803
+ * Example:
804
+ *
805
+ * @doc.root.last_element_child.element? # => true
806
+ */
807
+ static VALUE last_element_child(VALUE self)
808
+ {
809
+ xmlNodePtr node, child;
810
+ Data_Get_Struct(self, xmlNode, node);
811
+
812
+ child = xmlLastElementChild(node);
813
+ if(!child) { return Qnil; }
814
+
815
+ return Nokogiri_wrap_xml_node(Qnil, child);
816
+ }
817
+
818
+ /*
819
+ * call-seq:
820
+ * key?(attribute)
821
+ *
822
+ * Returns true if +attribute+ is set
823
+ */
824
+ static VALUE key_eh(VALUE self, VALUE attribute)
825
+ {
826
+ xmlNodePtr node;
827
+ Data_Get_Struct(self, xmlNode, node);
828
+ if(xmlHasProp(node, (xmlChar *)StringValueCStr(attribute))) {
829
+ return Qtrue;
830
+ }
831
+ return Qfalse;
832
+ }
833
+
834
+ /*
835
+ * call-seq:
836
+ * namespaced_key?(attribute, namespace)
837
+ *
838
+ * Returns true if +attribute+ is set with +namespace+
839
+ */
840
+ static VALUE namespaced_key_eh(VALUE self, VALUE attribute, VALUE namespace)
841
+ {
842
+ xmlNodePtr node;
843
+ Data_Get_Struct(self, xmlNode, node);
844
+ if(xmlHasNsProp(node, (xmlChar *)StringValueCStr(attribute),
845
+ NIL_P(namespace) ? NULL : (xmlChar *)StringValueCStr(namespace))) {
846
+ return Qtrue;
847
+ }
848
+ return Qfalse;
849
+ }
850
+
851
+ /*
852
+ * call-seq:
853
+ * []=(property, value)
854
+ *
855
+ * Set the +property+ to +value+
856
+ */
857
+ static VALUE set(VALUE self, VALUE property, VALUE value)
858
+ {
859
+ xmlNodePtr node, cur;
860
+ xmlAttrPtr prop;
861
+ Data_Get_Struct(self, xmlNode, node);
862
+
863
+ /* If a matching attribute node already exists, then xmlSetProp will destroy
864
+ * the existing node's children. However, if Nokogiri has a node object
865
+ * pointing to one of those children, we are left with a broken reference.
866
+ *
867
+ * We can avoid this by unlinking these nodes first.
868
+ */
869
+ if (node->type != XML_ELEMENT_NODE) {
870
+ return(Qnil);
871
+ }
872
+ prop = xmlHasProp(node, (xmlChar *)StringValueCStr(property));
873
+ if (prop && prop->children) {
874
+ for (cur = prop->children; cur; cur = cur->next) {
875
+ if (cur->_private) {
876
+ nokogiri_root_node(cur);
877
+ xmlUnlinkNode(cur);
878
+ }
879
+ }
880
+ }
881
+
882
+ xmlSetProp(node, (xmlChar *)StringValueCStr(property),
883
+ (xmlChar *)StringValueCStr(value));
884
+
885
+ return value;
886
+ }
887
+
888
+ /*
889
+ * call-seq:
890
+ * get(attribute)
891
+ *
892
+ * Get the value for +attribute+
893
+ */
894
+ static VALUE get(VALUE self, VALUE rattribute)
895
+ {
896
+ xmlNodePtr node;
897
+ xmlChar *value = 0;
898
+ VALUE rvalue;
899
+ xmlChar *colon;
900
+ xmlChar *attribute, *attr_name, *prefix;
901
+ xmlNsPtr ns;
902
+
903
+ if (NIL_P(rattribute)) { return Qnil; }
904
+
905
+ Data_Get_Struct(self, xmlNode, node);
906
+ attribute = xmlCharStrdup(StringValueCStr(rattribute));
907
+
908
+ colon = (xmlChar *)(uintptr_t)xmlStrchr(attribute, (const xmlChar)':');
909
+ if (colon) {
910
+ /* split the attribute string into separate prefix and name by
911
+ * null-terminating the prefix at the colon */
912
+ prefix = attribute;
913
+ attr_name = colon + 1;
914
+ (*colon) = 0;
915
+
916
+ ns = xmlSearchNs(node->doc, node, prefix);
917
+ if (ns) {
918
+ value = xmlGetNsProp(node, attr_name, ns->href);
919
+ } else {
920
+ value = xmlGetProp(node, (xmlChar*)StringValueCStr(rattribute));
921
+ }
922
+ } else {
923
+ value = xmlGetNoNsProp(node, attribute);
924
+ }
925
+
926
+ xmlFree((void *)attribute);
927
+ if (!value) { return Qnil; }
928
+
929
+ rvalue = NOKOGIRI_STR_NEW2(value);
930
+ xmlFree((void *)value);
931
+
932
+ return rvalue ;
933
+ }
934
+
935
+ /*
936
+ * call-seq:
937
+ * set_namespace(namespace)
938
+ *
939
+ * Set the namespace to +namespace+
940
+ */
941
+ static VALUE set_namespace(VALUE self, VALUE namespace)
942
+ {
943
+ xmlNodePtr node;
944
+ xmlNsPtr ns = NULL;
945
+
946
+ Data_Get_Struct(self, xmlNode, node);
947
+
948
+ if(!NIL_P(namespace)) {
949
+ Data_Get_Struct(namespace, xmlNs, ns);
950
+ }
951
+
952
+ xmlSetNs(node, ns);
953
+
954
+ return self;
955
+ }
956
+
957
+ /*
958
+ * call-seq:
959
+ * attribute(name)
960
+ *
961
+ * Get the attribute node with +name+
962
+ */
963
+ static VALUE attr(VALUE self, VALUE name)
964
+ {
965
+ xmlNodePtr node;
966
+ xmlAttrPtr prop;
967
+ Data_Get_Struct(self, xmlNode, node);
968
+ prop = xmlHasProp(node, (xmlChar *)StringValueCStr(name));
969
+
970
+ if(! prop) { return Qnil; }
971
+ return Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)prop);
972
+ }
973
+
974
+ /*
975
+ * call-seq:
976
+ * attribute_with_ns(name, namespace)
977
+ *
978
+ * Get the attribute node with +name+ and +namespace+
979
+ */
980
+ static VALUE attribute_with_ns(VALUE self, VALUE name, VALUE namespace)
981
+ {
982
+ xmlNodePtr node;
983
+ xmlAttrPtr prop;
984
+ Data_Get_Struct(self, xmlNode, node);
985
+ prop = xmlHasNsProp(node, (xmlChar *)StringValueCStr(name),
986
+ NIL_P(namespace) ? NULL : (xmlChar *)StringValueCStr(namespace));
987
+
988
+ if(! prop) { return Qnil; }
989
+ return Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)prop);
990
+ }
991
+
992
+ /*
993
+ * call-seq:
994
+ * attribute_nodes()
995
+ *
996
+ * returns a list containing the Node attributes.
997
+ */
998
+ static VALUE attribute_nodes(VALUE self)
999
+ {
1000
+ /* this code in the mode of xmlHasProp() */
1001
+ xmlNodePtr node;
1002
+ VALUE attr;
1003
+
1004
+ Data_Get_Struct(self, xmlNode, node);
1005
+
1006
+ attr = rb_ary_new();
1007
+ Nokogiri_xml_node_properties(node, attr);
1008
+
1009
+ return attr ;
1010
+ }
1011
+
1012
+
1013
+ /*
1014
+ * call-seq:
1015
+ * namespace()
1016
+ *
1017
+ * returns the namespace of the element or attribute node as a Namespace
1018
+ * object, or nil if there is no namespace for the element or attribute.
1019
+ */
1020
+ static VALUE namespace(VALUE self)
1021
+ {
1022
+ xmlNodePtr node ;
1023
+ Data_Get_Struct(self, xmlNode, node);
1024
+
1025
+ if (node->ns) {
1026
+ return Nokogiri_wrap_xml_namespace(node->doc, node->ns);
1027
+ }
1028
+
1029
+ return Qnil ;
1030
+ }
1031
+
1032
+ /*
1033
+ * call-seq:
1034
+ * namespace_definitions()
1035
+ *
1036
+ * returns namespaces defined on self element directly, as an array of Namespace objects. Includes both a default namespace (as in"xmlns="), and prefixed namespaces (as in "xmlns:prefix=").
1037
+ */
1038
+ static VALUE namespace_definitions(VALUE self)
1039
+ {
1040
+ /* this code in the mode of xmlHasProp() */
1041
+ xmlNodePtr node ;
1042
+ VALUE list;
1043
+ xmlNsPtr ns;
1044
+
1045
+ Data_Get_Struct(self, xmlNode, node);
1046
+
1047
+ list = rb_ary_new();
1048
+
1049
+ ns = node->nsDef;
1050
+
1051
+ if(!ns) { return list; }
1052
+
1053
+ while(NULL != ns) {
1054
+ rb_ary_push(list, Nokogiri_wrap_xml_namespace(node->doc, ns));
1055
+ ns = ns->next;
1056
+ }
1057
+
1058
+ return list;
1059
+ }
1060
+
1061
+ /*
1062
+ * call-seq:
1063
+ * namespace_scopes()
1064
+ *
1065
+ * returns namespaces in scope for self -- those defined on self element
1066
+ * directly or any ancestor node -- as an array of Namespace objects. Default
1067
+ * namespaces ("xmlns=" style) for self are included in this array; Default
1068
+ * namespaces for ancestors, however, are not. See also #namespaces
1069
+ */
1070
+ static VALUE namespace_scopes(VALUE self)
1071
+ {
1072
+ xmlNodePtr node ;
1073
+ VALUE list;
1074
+ xmlNsPtr *ns_list;
1075
+ int j;
1076
+
1077
+ Data_Get_Struct(self, xmlNode, node);
1078
+
1079
+ list = rb_ary_new();
1080
+ ns_list = xmlGetNsList(node->doc, node);
1081
+
1082
+ if(!ns_list) { return list; }
1083
+
1084
+ for (j = 0 ; ns_list[j] != NULL ; ++j) {
1085
+ rb_ary_push(list, Nokogiri_wrap_xml_namespace(node->doc, ns_list[j]));
1086
+ }
1087
+
1088
+ xmlFree(ns_list);
1089
+ return list;
1090
+ }
1091
+
1092
+ /*
1093
+ * call-seq:
1094
+ * node_type
1095
+ *
1096
+ * Get the type for this Node
1097
+ */
1098
+ static VALUE node_type(VALUE self)
1099
+ {
1100
+ xmlNodePtr node;
1101
+ Data_Get_Struct(self, xmlNode, node);
1102
+ return INT2NUM((long)node->type);
1103
+ }
1104
+
1105
+ /*
1106
+ * call-seq:
1107
+ * content=
1108
+ *
1109
+ * Set the content for this Node
1110
+ */
1111
+ static VALUE set_native_content(VALUE self, VALUE content)
1112
+ {
1113
+ xmlNodePtr node, child, next ;
1114
+ Data_Get_Struct(self, xmlNode, node);
1115
+
1116
+ child = node->children;
1117
+ while (NULL != child) {
1118
+ next = child->next ;
1119
+ xmlUnlinkNode(child) ;
1120
+ nokogiri_root_node(child);
1121
+ child = next ;
1122
+ }
1123
+
1124
+ xmlNodeSetContent(node, (xmlChar *)StringValueCStr(content));
1125
+ return content;
1126
+ }
1127
+
1128
+ /*
1129
+ * call-seq:
1130
+ * content
1131
+ *
1132
+ * Returns the plaintext content for this Node. Note that entities will always
1133
+ * be expanded in the returned string.
1134
+ */
1135
+ static VALUE get_native_content(VALUE self)
1136
+ {
1137
+ xmlNodePtr node;
1138
+ xmlChar * content;
1139
+
1140
+ Data_Get_Struct(self, xmlNode, node);
1141
+
1142
+ content = xmlNodeGetContent(node);
1143
+ if(content) {
1144
+ VALUE rval = NOKOGIRI_STR_NEW2(content);
1145
+ xmlFree(content);
1146
+ return rval;
1147
+ }
1148
+ return Qnil;
1149
+ }
1150
+
1151
+ /*
1152
+ * call-seq:
1153
+ * lang=
1154
+ *
1155
+ * Set the language of a node, i.e. the values of the xml:lang attribute.
1156
+ */
1157
+ static VALUE set_lang(VALUE self_rb, VALUE lang_rb)
1158
+ {
1159
+ xmlNodePtr self ;
1160
+ xmlChar* lang ;
1161
+
1162
+ Data_Get_Struct(self_rb, xmlNode, self);
1163
+ lang = (xmlChar*)StringValueCStr(lang_rb);
1164
+
1165
+ xmlNodeSetLang(self, lang);
1166
+
1167
+ return Qnil ;
1168
+ }
1169
+
1170
+ /*
1171
+ * call-seq:
1172
+ * lang
1173
+ *
1174
+ * Searches the language of a node, i.e. the values of the xml:lang attribute or
1175
+ * the one carried by the nearest ancestor.
1176
+ */
1177
+ static VALUE get_lang(VALUE self_rb)
1178
+ {
1179
+ xmlNodePtr self ;
1180
+ xmlChar* lang ;
1181
+ VALUE lang_rb ;
1182
+
1183
+ Data_Get_Struct(self_rb, xmlNode, self);
1184
+
1185
+ lang = xmlNodeGetLang(self);
1186
+ if (lang) {
1187
+ lang_rb = NOKOGIRI_STR_NEW2(lang);
1188
+ xmlFree(lang);
1189
+ return lang_rb ;
1190
+ }
1191
+
1192
+ return Qnil ;
1193
+ }
1194
+
1195
+ /* :nodoc: */
1196
+ static VALUE add_child(VALUE self, VALUE new_child)
1197
+ {
1198
+ return reparent_node_with(self, new_child, xmlAddChild);
1199
+ }
1200
+
1201
+ /*
1202
+ * call-seq:
1203
+ * parent
1204
+ *
1205
+ * Get the parent Node for this Node
1206
+ */
1207
+ static VALUE get_parent(VALUE self)
1208
+ {
1209
+ xmlNodePtr node, parent;
1210
+ Data_Get_Struct(self, xmlNode, node);
1211
+
1212
+ parent = node->parent;
1213
+ if(!parent) { return Qnil; }
1214
+
1215
+ return Nokogiri_wrap_xml_node(Qnil, parent) ;
1216
+ }
1217
+
1218
+ /*
1219
+ * call-seq:
1220
+ * name=(new_name)
1221
+ *
1222
+ * Set the name for this Node
1223
+ */
1224
+ static VALUE set_name(VALUE self, VALUE new_name)
1225
+ {
1226
+ xmlNodePtr node;
1227
+ Data_Get_Struct(self, xmlNode, node);
1228
+ xmlNodeSetName(node, (xmlChar*)StringValueCStr(new_name));
1229
+ return new_name;
1230
+ }
1231
+
1232
+ /*
1233
+ * call-seq:
1234
+ * name
1235
+ *
1236
+ * Returns the name for this Node
1237
+ */
1238
+ static VALUE get_name(VALUE self)
1239
+ {
1240
+ xmlNodePtr node;
1241
+ Data_Get_Struct(self, xmlNode, node);
1242
+ if(node->name) {
1243
+ return NOKOGIRI_STR_NEW2(node->name);
1244
+ }
1245
+ return Qnil;
1246
+ }
1247
+
1248
+ /*
1249
+ * call-seq:
1250
+ * path
1251
+ *
1252
+ * Returns the path associated with this Node
1253
+ */
1254
+ static VALUE path(VALUE self)
1255
+ {
1256
+ xmlNodePtr node;
1257
+ xmlChar *path ;
1258
+ VALUE rval;
1259
+
1260
+ Data_Get_Struct(self, xmlNode, node);
1261
+
1262
+ path = xmlGetNodePath(node);
1263
+ rval = NOKOGIRI_STR_NEW2(path);
1264
+ xmlFree(path);
1265
+ return rval ;
1266
+ }
1267
+
1268
+ /* :nodoc: */
1269
+ static VALUE add_next_sibling(VALUE self, VALUE new_sibling)
1270
+ {
1271
+ return reparent_node_with(self, new_sibling, xmlAddNextSibling) ;
1272
+ }
1273
+
1274
+ /* :nodoc: */
1275
+ static VALUE add_previous_sibling(VALUE self, VALUE new_sibling)
1276
+ {
1277
+ return reparent_node_with(self, new_sibling, xmlAddPrevSibling) ;
1278
+ }
1279
+
1280
+ /*
1281
+ * call-seq:
1282
+ * native_write_to(io, encoding, options)
1283
+ *
1284
+ * Write this Node to +io+ with +encoding+ and +options+
1285
+ */
1286
+ static VALUE native_write_to(
1287
+ VALUE self,
1288
+ VALUE io,
1289
+ VALUE encoding,
1290
+ VALUE indent_string,
1291
+ VALUE options
1292
+ )
1293
+ {
1294
+ xmlNodePtr node;
1295
+ const char * before_indent;
1296
+ xmlSaveCtxtPtr savectx;
1297
+
1298
+ Data_Get_Struct(self, xmlNode, node);
1299
+
1300
+ xmlIndentTreeOutput = 1;
1301
+
1302
+ before_indent = xmlTreeIndentString;
1303
+
1304
+ xmlTreeIndentString = StringValueCStr(indent_string);
1305
+
1306
+ savectx = xmlSaveToIO(
1307
+ (xmlOutputWriteCallback)io_write_callback,
1308
+ (xmlOutputCloseCallback)io_close_callback,
1309
+ (void *)io,
1310
+ RTEST(encoding) ? StringValueCStr(encoding) : NULL,
1311
+ (int)NUM2INT(options)
1312
+ );
1313
+
1314
+ xmlSaveTree(savectx, node);
1315
+ xmlSaveClose(savectx);
1316
+
1317
+ xmlTreeIndentString = before_indent;
1318
+ return io;
1319
+ }
1320
+
1321
+ /*
1322
+ * call-seq:
1323
+ * line
1324
+ *
1325
+ * Returns the line for this Node
1326
+ */
1327
+ static VALUE line(VALUE self)
1328
+ {
1329
+ xmlNodePtr node;
1330
+ Data_Get_Struct(self, xmlNode, node);
1331
+
1332
+ return INT2NUM(xmlGetLineNo(node));
1333
+ }
1334
+
1335
+ /*
1336
+ * call-seq:
1337
+ * line=(num)
1338
+ *
1339
+ * Sets the line for this Node. num must be less than 65535.
1340
+ */
1341
+ static VALUE set_line(VALUE self, VALUE num)
1342
+ {
1343
+ xmlNodePtr node;
1344
+ Data_Get_Struct(self, xmlNode, node);
1345
+
1346
+ int value = NUM2INT(num);
1347
+ if (value < 65535) {
1348
+ node->line = value;
1349
+ }
1350
+
1351
+ return num;
1352
+ }
1353
+
1354
+ /*
1355
+ * call-seq:
1356
+ * add_namespace_definition(prefix, href)
1357
+ *
1358
+ * Adds a namespace definition with +prefix+ using +href+ value. The result is
1359
+ * as if parsed XML for this node had included an attribute
1360
+ * 'xmlns:prefix=value'. A default namespace for this node ("xmlns=") can be
1361
+ * added by passing 'nil' for prefix. Namespaces added this way will not
1362
+ * show up in #attributes, but they will be included as an xmlns attribute
1363
+ * when the node is serialized to XML.
1364
+ */
1365
+ static VALUE add_namespace_definition(VALUE self, VALUE prefix, VALUE href)
1366
+ {
1367
+ xmlNodePtr node, namespace;
1368
+ xmlNsPtr ns;
1369
+
1370
+ Data_Get_Struct(self, xmlNode, node);
1371
+ namespace = node ;
1372
+
1373
+ ns = xmlSearchNs(
1374
+ node->doc,
1375
+ node,
1376
+ (const xmlChar *)(NIL_P(prefix) ? NULL : StringValueCStr(prefix))
1377
+ );
1378
+
1379
+ if(!ns) {
1380
+ if (node->type != XML_ELEMENT_NODE) {
1381
+ namespace = node->parent;
1382
+ }
1383
+ ns = xmlNewNs(
1384
+ namespace,
1385
+ (const xmlChar *)StringValueCStr(href),
1386
+ (const xmlChar *)(NIL_P(prefix) ? NULL : StringValueCStr(prefix))
1387
+ );
1388
+ }
1389
+
1390
+ if (!ns) { return Qnil ; }
1391
+
1392
+ if(NIL_P(prefix) || node != namespace) { xmlSetNs(node, ns); }
1393
+
1394
+ return Nokogiri_wrap_xml_namespace(node->doc, ns);
1395
+ }
1396
+
1397
+ /*
1398
+ * call-seq:
1399
+ * new(name, document)
1400
+ *
1401
+ * Create a new node with +name+ sharing GC lifecycle with +document+
1402
+ */
1403
+ static VALUE new(int argc, VALUE *argv, VALUE klass)
1404
+ {
1405
+ xmlDocPtr doc;
1406
+ xmlNodePtr node;
1407
+ VALUE name;
1408
+ VALUE document;
1409
+ VALUE rest;
1410
+ VALUE rb_node;
1411
+
1412
+ rb_scan_args(argc, argv, "2*", &name, &document, &rest);
1413
+
1414
+ Data_Get_Struct(document, xmlDoc, doc);
1415
+
1416
+ node = xmlNewNode(NULL, (xmlChar *)StringValueCStr(name));
1417
+ node->doc = doc->doc;
1418
+ nokogiri_root_node(node);
1419
+
1420
+ rb_node = Nokogiri_wrap_xml_node(
1421
+ klass == cNokogiriXmlNode ? (VALUE)NULL : klass,
1422
+ node
1423
+ );
1424
+ rb_obj_call_init(rb_node, argc, argv);
1425
+
1426
+ if(rb_block_given_p()) { rb_yield(rb_node); }
1427
+
1428
+ return rb_node;
1429
+ }
1430
+
1431
+ /*
1432
+ * call-seq:
1433
+ * dump_html
1434
+ *
1435
+ * Returns the Node as html.
1436
+ */
1437
+ static VALUE dump_html(VALUE self)
1438
+ {
1439
+ xmlBufferPtr buf ;
1440
+ xmlNodePtr node ;
1441
+ VALUE html;
1442
+
1443
+ Data_Get_Struct(self, xmlNode, node);
1444
+
1445
+ buf = xmlBufferCreate() ;
1446
+ htmlNodeDump(buf, node->doc, node);
1447
+ html = NOKOGIRI_STR_NEW2(buf->content);
1448
+ xmlBufferFree(buf);
1449
+ return html ;
1450
+ }
1451
+
1452
+ /*
1453
+ * call-seq:
1454
+ * compare(other)
1455
+ *
1456
+ * Compare this Node to +other+ with respect to their Document
1457
+ */
1458
+ static VALUE compare(VALUE self, VALUE _other)
1459
+ {
1460
+ xmlNodePtr node, other;
1461
+ Data_Get_Struct(self, xmlNode, node);
1462
+ Data_Get_Struct(_other, xmlNode, other);
1463
+
1464
+ return INT2NUM((long)xmlXPathCmpNodes(other, node));
1465
+ }
1466
+
1467
+
1468
+ /*
1469
+ * call-seq:
1470
+ * process_xincludes(options)
1471
+ *
1472
+ * Loads and substitutes all xinclude elements below the node. The
1473
+ * parser context will be initialized with +options+.
1474
+ */
1475
+ static VALUE process_xincludes(VALUE self, VALUE options)
1476
+ {
1477
+ int rcode ;
1478
+ xmlNodePtr node;
1479
+ VALUE error_list = rb_ary_new();
1480
+
1481
+ Data_Get_Struct(self, xmlNode, node);
1482
+
1483
+ xmlSetStructuredErrorFunc((void *)error_list, Nokogiri_error_array_pusher);
1484
+ rcode = xmlXIncludeProcessTreeFlags(node, (int)NUM2INT(options));
1485
+ xmlSetStructuredErrorFunc(NULL, NULL);
1486
+
1487
+ if (rcode < 0) {
1488
+ xmlErrorPtr error;
1489
+
1490
+ error = xmlGetLastError();
1491
+ if(error) {
1492
+ rb_exc_raise(Nokogiri_wrap_xml_syntax_error(error));
1493
+ } else {
1494
+ rb_raise(rb_eRuntimeError, "Could not perform xinclude substitution");
1495
+ }
1496
+ }
1497
+
1498
+ return self;
1499
+ }
1500
+
1501
+
1502
+ /* TODO: DOCUMENT ME */
1503
+ static VALUE in_context(VALUE self, VALUE _str, VALUE _options)
1504
+ {
1505
+ xmlNodePtr node, list = 0, tmp, child_iter, node_children, doc_children;
1506
+ xmlNodeSetPtr set;
1507
+ xmlParserErrors error;
1508
+ VALUE doc, err;
1509
+ int doc_is_empty;
1510
+
1511
+ Data_Get_Struct(self, xmlNode, node);
1512
+
1513
+ doc = DOC_RUBY_OBJECT(node->doc);
1514
+ err = rb_iv_get(doc, "@errors");
1515
+ doc_is_empty = (node->doc->children == NULL) ? 1 : 0;
1516
+ node_children = node->children;
1517
+ doc_children = node->doc->children;
1518
+
1519
+ xmlSetStructuredErrorFunc((void *)err, Nokogiri_error_array_pusher);
1520
+
1521
+ /* Twiddle global variable because of a bug in libxml2.
1522
+ * http://git.gnome.org/browse/libxml2/commit/?id=e20fb5a72c83cbfc8e4a8aa3943c6be8febadab7
1523
+ */
1524
+ #ifndef HTML_PARSE_NOIMPLIED
1525
+ htmlHandleOmittedElem(0);
1526
+ #endif
1527
+
1528
+ /* This function adds a fake node to the child of +node+. If the parser
1529
+ * does not exit cleanly with XML_ERR_OK, the list is freed. This can
1530
+ * leave the child pointers in a bad state if they were originally empty.
1531
+ *
1532
+ * http://git.gnome.org/browse/libxml2/tree/parser.c#n13177
1533
+ * */
1534
+ error = xmlParseInNodeContext(node, StringValuePtr(_str),
1535
+ (int)RSTRING_LEN(_str),
1536
+ (int)NUM2INT(_options), &list);
1537
+
1538
+ /* xmlParseInNodeContext should not mutate the original document or node,
1539
+ * so reassigning these pointers should be OK. The reason we're reassigning
1540
+ * is because if there were errors, it's possible for the child pointers
1541
+ * to be manipulated. */
1542
+ if (error != XML_ERR_OK) {
1543
+ node->doc->children = doc_children;
1544
+ node->children = node_children;
1545
+ }
1546
+
1547
+ /* make sure parent/child pointers are coherent so an unlink will work
1548
+ * properly (#331)
1549
+ */
1550
+ child_iter = node->doc->children ;
1551
+ while (child_iter) {
1552
+ if (child_iter->parent != (xmlNodePtr)node->doc) {
1553
+ child_iter->parent = (xmlNodePtr)node->doc;
1554
+ }
1555
+ child_iter = child_iter->next;
1556
+ }
1557
+
1558
+ #ifndef HTML_PARSE_NOIMPLIED
1559
+ htmlHandleOmittedElem(1);
1560
+ #endif
1561
+
1562
+ xmlSetStructuredErrorFunc(NULL, NULL);
1563
+
1564
+ /* Workaround for a libxml2 bug where a parsing error may leave a broken
1565
+ * node reference in node->doc->children.
1566
+ * This workaround is limited to when a parse error occurs, the document
1567
+ * went from having no children to having children, and the context node is
1568
+ * part of a document fragment.
1569
+ * https://bugzilla.gnome.org/show_bug.cgi?id=668155
1570
+ */
1571
+ if (error != XML_ERR_OK && doc_is_empty && node->doc->children != NULL) {
1572
+ child_iter = node;
1573
+ while (child_iter->parent) {
1574
+ child_iter = child_iter->parent;
1575
+ }
1576
+
1577
+ if (child_iter->type == XML_DOCUMENT_FRAG_NODE) {
1578
+ node->doc->children = NULL;
1579
+ }
1580
+ }
1581
+
1582
+ /* FIXME: This probably needs to handle more constants... */
1583
+ switch (error) {
1584
+ case XML_ERR_INTERNAL_ERROR:
1585
+ case XML_ERR_NO_MEMORY:
1586
+ rb_raise(rb_eRuntimeError, "error parsing fragment (%d)", error);
1587
+ break;
1588
+ default:
1589
+ break;
1590
+ }
1591
+
1592
+ set = xmlXPathNodeSetCreate(NULL);
1593
+
1594
+ while (list) {
1595
+ tmp = list->next;
1596
+ list->next = NULL;
1597
+ xmlXPathNodeSetAddUnique(set, list);
1598
+ nokogiri_root_node(list);
1599
+ list = tmp;
1600
+ }
1601
+
1602
+ return Nokogiri_wrap_xml_node_set(set, doc);
1603
+ }
1604
+
1605
+
1606
+ VALUE Nokogiri_wrap_xml_node(VALUE klass, xmlNodePtr node)
1607
+ {
1608
+ VALUE document = Qnil ;
1609
+ VALUE node_cache = Qnil ;
1610
+ VALUE rb_node = Qnil ;
1611
+ nokogiriTuplePtr node_has_a_document;
1612
+ xmlDocPtr doc;
1613
+ void (*mark_method)(xmlNodePtr) = NULL ;
1614
+
1615
+ assert(node);
1616
+
1617
+ if(node->type == XML_DOCUMENT_NODE || node->type == XML_HTML_DOCUMENT_NODE) {
1618
+ return DOC_RUBY_OBJECT(node->doc);
1619
+ }
1620
+
1621
+ /* It's OK if the node doesn't have a fully-realized document (as in XML::Reader). */
1622
+ /* see https://github.com/sparklemotion/nokogiri/issues/95 */
1623
+ /* and https://github.com/sparklemotion/nokogiri/issues/439 */
1624
+ doc = node->doc;
1625
+ if (doc->type == XML_DOCUMENT_FRAG_NODE) { doc = doc->doc; }
1626
+ node_has_a_document = DOC_RUBY_OBJECT_TEST(doc);
1627
+
1628
+ if(node->_private && node_has_a_document) {
1629
+ return (VALUE)node->_private;
1630
+ }
1631
+
1632
+ if(!RTEST(klass)) {
1633
+ switch(node->type) {
1634
+ case XML_ELEMENT_NODE:
1635
+ klass = cNokogiriXmlElement;
1636
+ break;
1637
+ case XML_TEXT_NODE:
1638
+ klass = cNokogiriXmlText;
1639
+ break;
1640
+ case XML_ATTRIBUTE_NODE:
1641
+ klass = cNokogiriXmlAttr;
1642
+ break;
1643
+ case XML_ENTITY_REF_NODE:
1644
+ klass = cNokogiriXmlEntityReference;
1645
+ break;
1646
+ case XML_COMMENT_NODE:
1647
+ klass = cNokogiriXmlComment;
1648
+ break;
1649
+ case XML_DOCUMENT_FRAG_NODE:
1650
+ klass = cNokogiriXmlDocumentFragment;
1651
+ break;
1652
+ case XML_PI_NODE:
1653
+ klass = cNokogiriXmlProcessingInstruction;
1654
+ break;
1655
+ case XML_ENTITY_DECL:
1656
+ klass = cNokogiriXmlEntityDecl;
1657
+ break;
1658
+ case XML_CDATA_SECTION_NODE:
1659
+ klass = cNokogiriXmlCData;
1660
+ break;
1661
+ case XML_DTD_NODE:
1662
+ klass = cNokogiriXmlDtd;
1663
+ break;
1664
+ case XML_ATTRIBUTE_DECL:
1665
+ klass = cNokogiriXmlAttributeDecl;
1666
+ break;
1667
+ case XML_ELEMENT_DECL:
1668
+ klass = cNokogiriXmlElementDecl;
1669
+ break;
1670
+ default:
1671
+ klass = cNokogiriXmlNode;
1672
+ }
1673
+ }
1674
+
1675
+ mark_method = node_has_a_document ? mark : NULL ;
1676
+
1677
+ rb_node = Data_Wrap_Struct(klass, mark_method, debug_node_dealloc, node) ;
1678
+ node->_private = (void *)rb_node;
1679
+
1680
+ if (node_has_a_document) {
1681
+ document = DOC_RUBY_OBJECT(doc);
1682
+ node_cache = DOC_NODE_CACHE(doc);
1683
+ rb_ary_push(node_cache, rb_node);
1684
+ rb_funcall(document, decorate, 1, rb_node);
1685
+ }
1686
+
1687
+ return rb_node ;
1688
+ }
1689
+
1690
+
1691
+ void Nokogiri_xml_node_properties(xmlNodePtr node, VALUE attr_list)
1692
+ {
1693
+ xmlAttrPtr prop;
1694
+ prop = node->properties ;
1695
+ while (prop != NULL) {
1696
+ rb_ary_push(attr_list, Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)prop));
1697
+ prop = prop->next ;
1698
+ }
1699
+ }
1700
+
1701
+ VALUE cNokogiriXmlNode ;
1702
+ VALUE cNokogiriXmlElement ;
1703
+
1704
+ void init_xml_node()
1705
+ {
1706
+ VALUE nokogiri = rb_define_module("Nokogiri");
1707
+ VALUE xml = rb_define_module_under(nokogiri, "XML");
1708
+ VALUE klass = rb_define_class_under(xml, "Node", rb_cObject);
1709
+
1710
+ cNokogiriXmlNode = klass;
1711
+
1712
+ cNokogiriXmlElement = rb_define_class_under(xml, "Element", klass);
1713
+
1714
+ rb_define_singleton_method(klass, "new", new, -1);
1715
+
1716
+ rb_define_method(klass, "add_namespace_definition", add_namespace_definition, 2);
1717
+ rb_define_method(klass, "node_name", get_name, 0);
1718
+ rb_define_method(klass, "document", document, 0);
1719
+ rb_define_method(klass, "node_name=", set_name, 1);
1720
+ rb_define_method(klass, "parent", get_parent, 0);
1721
+ rb_define_method(klass, "child", child, 0);
1722
+ rb_define_method(klass, "first_element_child", first_element_child, 0);
1723
+ rb_define_method(klass, "last_element_child", last_element_child, 0);
1724
+ rb_define_method(klass, "children", children, 0);
1725
+ rb_define_method(klass, "element_children", element_children, 0);
1726
+ rb_define_method(klass, "next_sibling", next_sibling, 0);
1727
+ rb_define_method(klass, "previous_sibling", previous_sibling, 0);
1728
+ rb_define_method(klass, "next_element", next_element, 0);
1729
+ rb_define_method(klass, "previous_element", previous_element, 0);
1730
+ rb_define_method(klass, "node_type", node_type, 0);
1731
+ rb_define_method(klass, "path", path, 0);
1732
+ rb_define_method(klass, "key?", key_eh, 1);
1733
+ rb_define_method(klass, "namespaced_key?", namespaced_key_eh, 2);
1734
+ rb_define_method(klass, "blank?", blank_eh, 0);
1735
+ rb_define_method(klass, "attribute_nodes", attribute_nodes, 0);
1736
+ rb_define_method(klass, "attribute", attr, 1);
1737
+ rb_define_method(klass, "attribute_with_ns", attribute_with_ns, 2);
1738
+ rb_define_method(klass, "namespace", namespace, 0);
1739
+ rb_define_method(klass, "namespace_definitions", namespace_definitions, 0);
1740
+ rb_define_method(klass, "namespace_scopes", namespace_scopes, 0);
1741
+ rb_define_method(klass, "encode_special_chars", encode_special_chars, 1);
1742
+ rb_define_method(klass, "dup", duplicate_node, -1);
1743
+ rb_define_method(klass, "unlink", unlink_node, 0);
1744
+ rb_define_method(klass, "internal_subset", internal_subset, 0);
1745
+ rb_define_method(klass, "external_subset", external_subset, 0);
1746
+ rb_define_method(klass, "create_internal_subset", create_internal_subset, 3);
1747
+ rb_define_method(klass, "create_external_subset", create_external_subset, 3);
1748
+ rb_define_method(klass, "pointer_id", pointer_id, 0);
1749
+ rb_define_method(klass, "line", line, 0);
1750
+ rb_define_method(klass, "line=", set_line, 1);
1751
+ rb_define_method(klass, "content", get_native_content, 0);
1752
+ rb_define_method(klass, "native_content=", set_native_content, 1);
1753
+ rb_define_method(klass, "lang", get_lang, 0);
1754
+ rb_define_method(klass, "lang=", set_lang, 1);
1755
+
1756
+ rb_define_private_method(klass, "process_xincludes", process_xincludes, 1);
1757
+ rb_define_private_method(klass, "in_context", in_context, 2);
1758
+ rb_define_private_method(klass, "add_child_node", add_child, 1);
1759
+ rb_define_private_method(klass, "add_previous_sibling_node", add_previous_sibling, 1);
1760
+ rb_define_private_method(klass, "add_next_sibling_node", add_next_sibling, 1);
1761
+ rb_define_private_method(klass, "replace_node", replace, 1);
1762
+ rb_define_private_method(klass, "dump_html", dump_html, 0);
1763
+ rb_define_private_method(klass, "native_write_to", native_write_to, 4);
1764
+ rb_define_private_method(klass, "get", get, 1);
1765
+ rb_define_private_method(klass, "set", set, 2);
1766
+ rb_define_private_method(klass, "set_namespace", set_namespace, 1);
1767
+ rb_define_private_method(klass, "compare", compare, 1);
1768
+
1769
+ decorate = rb_intern("decorate");
1770
+ decorate_bang = rb_intern("decorate!");
1771
+ }
1772
+
1773
+ /* vim: set noet sw=4 sws=4 */