libxml-ruby 2.3.3 → 2.4.0

Sign up to get free protection for your applications and to get access to all the features.
@@ -0,0 +1,109 @@
1
+ #include "ruby_libxml.h"
2
+ #include "ruby_xml_schema_attribute.h"
3
+ #include "ruby_xml_schema_type.h"
4
+
5
+ VALUE cXMLSchemaAttribute;
6
+
7
+ static void rxml_schema_attribute_free(xmlSchemaAttributeUsePtr attr)
8
+ {
9
+ attr = NULL;
10
+ xmlFree(attr);
11
+ }
12
+
13
+ VALUE rxml_wrap_schema_attribute(xmlSchemaAttributeUsePtr attr)
14
+ {
15
+ return Data_Wrap_Struct(cXMLSchemaAttribute, NULL, rxml_schema_attribute_free, attr);
16
+ }
17
+
18
+ static VALUE rxml_schema_attribute_namespace(VALUE self)
19
+ {
20
+ xmlSchemaAttributeUsePtr attr;
21
+ const xmlChar *tns;
22
+
23
+ Data_Get_Struct(self, xmlSchemaAttributeUse, attr);
24
+
25
+ if (attr == NULL)
26
+ return Qnil;
27
+
28
+ if (attr->type == XML_SCHEMA_EXTRA_ATTR_USE_PROHIB) {
29
+ tns = ((xmlSchemaAttributeUseProhibPtr) attr)->targetNamespace;
30
+ } else if (attr->type == XML_SCHEMA_EXTRA_QNAMEREF) {
31
+ tns = ((xmlSchemaQNameRefPtr) attr)->targetNamespace;
32
+ } else {
33
+ tns = ((xmlSchemaAttributePtr) ((xmlSchemaAttributeUsePtr) (attr))->attrDecl)->targetNamespace;
34
+ }
35
+
36
+ QNIL_OR_STRING(tns)
37
+ }
38
+
39
+ static VALUE rxml_schema_attribute_name(VALUE self)
40
+ {
41
+ xmlSchemaAttributeUsePtr attr;
42
+ const xmlChar *name;
43
+
44
+ Data_Get_Struct(self, xmlSchemaAttributeUse, attr);
45
+
46
+ if (attr == NULL)
47
+ return Qnil;
48
+
49
+ if (attr->type == XML_SCHEMA_EXTRA_ATTR_USE_PROHIB) {
50
+ name = ((xmlSchemaAttributeUseProhibPtr) attr)->name;
51
+ } else if (attr->type == XML_SCHEMA_EXTRA_QNAMEREF) {
52
+ name = ((xmlSchemaQNameRefPtr) attr)->name;
53
+ } else {
54
+ xmlSchemaAttributePtr attrDecl = ((xmlSchemaAttributeUsePtr) attr)->attrDecl;
55
+ name = attrDecl->name;
56
+ }
57
+
58
+ QNIL_OR_STRING(name)
59
+ }
60
+
61
+ static VALUE rxml_schema_attribute_type(VALUE self)
62
+ {
63
+ xmlSchemaAttributeUsePtr attr;
64
+ xmlSchemaTypePtr xtype;
65
+
66
+ Data_Get_Struct(self, xmlSchemaAttributeUse, attr);
67
+
68
+ xtype = attr->attrDecl->subtypes;
69
+
70
+ return rxml_wrap_schema_type((xmlSchemaTypePtr) xtype);
71
+ }
72
+
73
+ static VALUE rxml_schema_attribute_node(VALUE self)
74
+ {
75
+ xmlSchemaAttributeUsePtr attr;
76
+
77
+ Data_Get_Struct(self, xmlSchemaAttributeUse, attr);
78
+
79
+ return rxml_node_wrap(attr->node);
80
+ }
81
+
82
+ static VALUE rxml_schema_attribute_value(VALUE self)
83
+ {
84
+ xmlSchemaAttributeUsePtr attr;
85
+
86
+ Data_Get_Struct(self, xmlSchemaAttributeUse, attr);
87
+
88
+ QNIL_OR_STRING(attr->defValue)
89
+ }
90
+
91
+ static VALUE rxml_schema_attribute_occurs(VALUE self)
92
+ {
93
+ xmlSchemaAttributeUsePtr attr;
94
+
95
+ Data_Get_Struct(self, xmlSchemaAttributeUse, attr);
96
+
97
+ return INT2NUM(attr->occurs);
98
+ }
99
+
100
+ void rxml_init_schema_attribute(void)
101
+ {
102
+ cXMLSchemaAttribute = rb_define_class_under(cXMLSchema, "Attribute", rb_cObject);
103
+ rb_define_method(cXMLSchemaAttribute, "namespace", rxml_schema_attribute_namespace, 0);
104
+ rb_define_method(cXMLSchemaAttribute, "name", rxml_schema_attribute_name, 0);
105
+ rb_define_method(cXMLSchemaAttribute, "type", rxml_schema_attribute_type, 0);
106
+ rb_define_method(cXMLSchemaAttribute, "node", rxml_schema_attribute_node, 0);
107
+ rb_define_method(cXMLSchemaAttribute, "value", rxml_schema_attribute_value, 0);
108
+ rb_define_method(cXMLSchemaAttribute, "occurs", rxml_schema_attribute_occurs, 0);
109
+ }
@@ -0,0 +1,15 @@
1
+ #ifndef __RXML_SCHEMA_ATTRIBUTE__
2
+ #define __RXML_SCHEMA_ATTRIBUTE__
3
+
4
+ #include "ruby_xml_schema.h"
5
+ #include <libxml/schemasInternals.h>
6
+ #include <libxml/xmlschemas.h>
7
+ #include <libxml/xmlschemastypes.h>
8
+
9
+ extern VALUE cXMLSchemaAttribute;
10
+
11
+
12
+ void rxml_init_schema_attribute(void);
13
+ VALUE rxml_wrap_schema_attribute(xmlSchemaAttributeUsePtr attr);
14
+
15
+ #endif
@@ -0,0 +1,94 @@
1
+ #include "ruby_libxml.h"
2
+ #include "ruby_xml_schema_element.h"
3
+ #include "ruby_xml_schema_type.h"
4
+
5
+ VALUE cXMLSchemaElement;
6
+
7
+ static void rxml_schema_element_free(xmlSchemaElementPtr xschema_element)
8
+ {
9
+ xschema_element = NULL;
10
+ xmlFree(xschema_element);
11
+ }
12
+
13
+ VALUE rxml_wrap_schema_element(xmlSchemaElementPtr xelement)
14
+ {
15
+ return Data_Wrap_Struct(cXMLSchemaElement, NULL, rxml_schema_element_free, xelement);
16
+ }
17
+
18
+ static VALUE rxml_schema_element_namespace(VALUE self)
19
+ {
20
+ xmlSchemaElementPtr xelem;
21
+
22
+ Data_Get_Struct(self, xmlSchemaElement, xelem);
23
+
24
+ QNIL_OR_STRING(xelem->targetNamespace)
25
+ }
26
+
27
+ static VALUE rxml_schema_element_name(VALUE self)
28
+ {
29
+ xmlSchemaElementPtr xelem;
30
+
31
+ Data_Get_Struct(self, xmlSchemaElement, xelem);
32
+
33
+
34
+ QNIL_OR_STRING(xelem->name)
35
+ }
36
+
37
+ static VALUE rxml_schema_element_type(VALUE self)
38
+ {
39
+ xmlSchemaElementPtr xelem;
40
+ xmlSchemaTypePtr xtype;
41
+
42
+ Data_Get_Struct(self, xmlSchemaElement, xelem);
43
+
44
+ xtype = xelem->subtypes;
45
+
46
+ return rxml_wrap_schema_type((xmlSchemaTypePtr) xtype);
47
+ }
48
+
49
+ static VALUE rxml_schema_element_node(VALUE self)
50
+ {
51
+ xmlSchemaElementPtr xelem;
52
+
53
+ Data_Get_Struct(self, xmlSchemaElement, xelem);
54
+
55
+ return rxml_node_wrap(xelem->node);
56
+ }
57
+
58
+ static VALUE rxml_schema_element_value(VALUE self)
59
+ {
60
+ xmlSchemaElementPtr xelem;
61
+
62
+ Data_Get_Struct(self, xmlSchemaElement, xelem);
63
+
64
+ QNIL_OR_STRING(xelem->value)
65
+ }
66
+
67
+ static VALUE rxml_schema_element_min_occurs(VALUE self)
68
+ {
69
+ return rb_iv_get(self, "@min");
70
+ }
71
+
72
+ static VALUE rxml_schema_element_max_occurs(VALUE self)
73
+ {
74
+ return rb_iv_get(self, "@max");
75
+ }
76
+
77
+ static VALUE rxml_schema_element_annot(VALUE self)
78
+ {
79
+ return rb_iv_get(self, "@annotation");
80
+ }
81
+
82
+
83
+ void rxml_init_schema_element(void)
84
+ {
85
+ cXMLSchemaElement = rb_define_class_under(cXMLSchema, "Element", rb_cObject);
86
+ rb_define_method(cXMLSchemaElement, "namespace", rxml_schema_element_namespace, 0);
87
+ rb_define_method(cXMLSchemaElement, "name", rxml_schema_element_name, 0);
88
+ rb_define_method(cXMLSchemaElement, "type", rxml_schema_element_type, 0);
89
+ rb_define_method(cXMLSchemaElement, "node", rxml_schema_element_node, 0);
90
+ rb_define_method(cXMLSchemaElement, "value", rxml_schema_element_value, 0);
91
+ rb_define_method(cXMLSchemaElement, "min_occurs", rxml_schema_element_min_occurs, 0);
92
+ rb_define_method(cXMLSchemaElement, "max_occurs", rxml_schema_element_max_occurs, 0);
93
+ rb_define_method(cXMLSchemaElement, "annotation", rxml_schema_element_annot, 0);
94
+ }
@@ -0,0 +1,14 @@
1
+ #ifndef __RXML_SCHEMA_ELEMENT__
2
+ #define __RXML_SCHEMA_ELEMENT__
3
+
4
+ #include "ruby_xml_schema.h"
5
+ #include <libxml/schemasInternals.h>
6
+ #include <libxml/xmlschemas.h>
7
+ #include <libxml/xmlschemastypes.h>
8
+
9
+ extern VALUE cXMLSchemaElement;
10
+
11
+ VALUE rxml_wrap_schema_element(xmlSchemaElementPtr xelement);
12
+ void rxml_init_schema_element(void);
13
+
14
+ #endif
@@ -0,0 +1,52 @@
1
+ #include "ruby_libxml.h"
2
+ #include "ruby_xml_schema_facet.h"
3
+
4
+ VALUE cXMLSchemaFacet;
5
+
6
+ static void rxml_schema_facet_free(xmlSchemaFacetPtr xschema_type)
7
+ {
8
+ xschema_type = NULL;
9
+ xmlFree(xschema_type);
10
+ }
11
+
12
+ /* START FACET*/
13
+
14
+ static VALUE rxml_schema_facet_node(VALUE self)
15
+ {
16
+ xmlSchemaFacetPtr facet;
17
+
18
+ Data_Get_Struct(self, xmlSchemaFacet, facet);
19
+
20
+ return rxml_node_wrap(facet->node);
21
+ }
22
+
23
+ static VALUE rxml_schema_facet_value(VALUE self)
24
+ {
25
+ xmlSchemaFacetPtr facet;
26
+
27
+ Data_Get_Struct(self, xmlSchemaFacet, facet);
28
+
29
+ QNIL_OR_STRING(facet->value)
30
+ }
31
+
32
+ static VALUE rxml_schema_facet_kind(VALUE self)
33
+ {
34
+ xmlSchemaFacetPtr facet;
35
+
36
+ Data_Get_Struct(self, xmlSchemaFacet, facet);
37
+
38
+ return INT2NUM(facet->type);
39
+ }
40
+
41
+ VALUE rxml_wrap_schema_facet(xmlSchemaFacetPtr facet)
42
+ {
43
+ return Data_Wrap_Struct(cXMLSchemaFacet, NULL, rxml_schema_facet_free, facet);
44
+ }
45
+
46
+ void rxml_init_schema_facet(void)
47
+ {
48
+ cXMLSchemaFacet = rb_define_class_under(cXMLSchema, "Facet", rb_cObject);
49
+ rb_define_method(cXMLSchemaFacet, "value", rxml_schema_facet_value, 0);
50
+ rb_define_method(cXMLSchemaFacet, "node", rxml_schema_facet_node, 0);
51
+ rb_define_method(cXMLSchemaFacet, "kind", rxml_schema_facet_kind, 0);
52
+ }
@@ -0,0 +1,13 @@
1
+ #ifndef __RXML_SCHEMA_FACET__
2
+ #define __RXML_SCHEMA_FACET__
3
+
4
+ #include <libxml/schemasInternals.h>
5
+ #include <libxml/xmlschemas.h>
6
+ #include <libxml/xmlschemastypes.h>
7
+
8
+ extern VALUE cXMLSchemaFacet;
9
+
10
+ VALUE rxml_wrap_schema_facet(xmlSchemaFacetPtr facet);
11
+ void rxml_init_schema_facet(void);
12
+
13
+ #endif
@@ -0,0 +1,252 @@
1
+ #include "ruby_libxml.h"
2
+ #include "ruby_xml_schema_type.h"
3
+ #include "ruby_xml_schema_element.h"
4
+ #include "ruby_xml_schema_attribute.h"
5
+ #include "ruby_xml_schema_facet.h"
6
+
7
+ #define UNBOUNDED 1 << 30
8
+ #define FREE_AND_NULL(str) if ((str) != NULL) { xmlFree((xmlChar *) (str)); str = NULL; }
9
+
10
+ VALUE cXMLSchemaType;
11
+
12
+ static void rxml_schema_type_free(xmlSchemaTypePtr xschema_type)
13
+ {
14
+ xschema_type = NULL;
15
+ xmlFree(xschema_type);
16
+ }
17
+
18
+ VALUE rxml_wrap_schema_type(xmlSchemaTypePtr xtype)
19
+ {
20
+ return Data_Wrap_Struct(cXMLSchemaType, NULL, rxml_schema_type_free, xtype);
21
+ }
22
+
23
+ static VALUE rxml_schema_type_namespace(VALUE self)
24
+ {
25
+ xmlSchemaTypePtr xtype;
26
+
27
+ Data_Get_Struct(self, xmlSchemaType, xtype);
28
+
29
+ QNIL_OR_STRING(xtype->targetNamespace)
30
+ }
31
+
32
+ static VALUE rxml_schema_type_name(VALUE self)
33
+ {
34
+ xmlSchemaTypePtr xtype;
35
+
36
+ Data_Get_Struct(self, xmlSchemaType, xtype);
37
+
38
+ QNIL_OR_STRING(xtype->name)
39
+ }
40
+
41
+ static VALUE rxml_schema_type_base(VALUE self)
42
+ {
43
+ xmlSchemaTypePtr xtype;
44
+
45
+ Data_Get_Struct(self, xmlSchemaType, xtype);
46
+
47
+ return Data_Wrap_Struct(cXMLSchemaType, NULL, rxml_schema_type_free, xtype->baseType);
48
+ }
49
+
50
+ static VALUE rxml_schema_type_facets(VALUE self)
51
+ {
52
+ xmlSchemaTypePtr xtype;
53
+ xmlSchemaFacetPtr facet;
54
+ VALUE facets;
55
+ VALUE rfacet;
56
+
57
+ facets = rb_iv_get(self, "@facets");
58
+
59
+ if (facets == Qnil) {
60
+ facets = rb_ary_new();
61
+ Data_Get_Struct(self, xmlSchemaType, xtype);
62
+
63
+ facet = xtype->facets;
64
+
65
+ while (facet != NULL) {
66
+ rfacet = rxml_wrap_schema_facet((xmlSchemaFacetPtr) facet);
67
+ rb_ary_push(facets, rfacet);
68
+ facet = facet->next;
69
+ }
70
+
71
+ rb_iv_set(self, "@facets", facets);
72
+ }
73
+
74
+ return facets;
75
+ }
76
+
77
+ static VALUE rxml_schema_type_node(VALUE self)
78
+ {
79
+ xmlSchemaTypePtr xtype;
80
+
81
+ Data_Get_Struct(self, xmlSchemaType, xtype);
82
+
83
+ if(xtype->node != NULL)
84
+ return rxml_node_wrap(xtype->node);
85
+ else
86
+ return Qnil;
87
+ }
88
+
89
+ static VALUE rxml_schema_type_kind(VALUE self)
90
+ {
91
+ xmlSchemaTypePtr xtype;
92
+
93
+ Data_Get_Struct(self, xmlSchemaType, xtype);
94
+
95
+ return INT2NUM(xtype->type);
96
+ }
97
+
98
+ static VALUE get_annotation(xmlSchemaAnnotPtr annot)
99
+ {
100
+ if(annot != NULL && annot->content != NULL && annot->content->content != NULL)
101
+ return rb_str_new2((const char *) annot->content->content);
102
+ else
103
+ return Qnil;
104
+ }
105
+
106
+ static VALUE rxml_schema_type_annot(VALUE self)
107
+ {
108
+ xmlSchemaTypePtr xtype;
109
+
110
+ Data_Get_Struct(self, xmlSchemaType, xtype);
111
+
112
+ if(xtype != NULL && xtype->annot != NULL)
113
+ return get_annotation(xtype->annot);
114
+ else
115
+ return Qnil;
116
+ }
117
+
118
+ static void rxmlSchemaCollectElements(xmlSchemaParticlePtr particle, VALUE self)
119
+ {
120
+ VALUE elements;
121
+ VALUE relement;
122
+ xmlSchemaTreeItemPtr term;
123
+
124
+ if (particle == NULL)
125
+ return;
126
+
127
+ term = particle->children;
128
+
129
+ if (term != NULL) {
130
+ elements = rb_iv_get(self, "@elements");
131
+
132
+ switch (term->type) {
133
+ case XML_SCHEMA_TYPE_ELEMENT:
134
+ relement = rxml_wrap_schema_element((xmlSchemaElementPtr) term);
135
+
136
+
137
+ rb_iv_set(relement, "@min", INT2NUM(particle->minOccurs));
138
+
139
+ if (particle->maxOccurs >= UNBOUNDED)
140
+ rb_iv_set(relement, "@max", rb_const_get(rb_path2class("Float"), rb_intern("INFINITY")));
141
+ else
142
+ rb_iv_set(relement, "@max", INT2NUM(particle->maxOccurs));
143
+
144
+ if (particle->annot != NULL)
145
+ {
146
+ xmlChar *content;
147
+
148
+ content = xmlNodeGetContent(particle->annot->content);
149
+
150
+ if (content != NULL)
151
+ {
152
+ rb_iv_set(relement, "@annotation", rb_str_new2((const char *) content));
153
+ xmlFree(content);
154
+ }
155
+ }
156
+
157
+ rb_hash_aset(elements, rb_str_new2((const char *) ((xmlSchemaElementPtr) term)->name), relement);
158
+
159
+ break;
160
+
161
+ case XML_SCHEMA_TYPE_SEQUENCE:
162
+ break;
163
+
164
+ case XML_SCHEMA_TYPE_CHOICE:
165
+ break;
166
+
167
+ case XML_SCHEMA_TYPE_ALL:
168
+ break;
169
+
170
+ case XML_SCHEMA_TYPE_ANY:
171
+ break;
172
+
173
+ default:
174
+
175
+ return;
176
+ }
177
+ }
178
+
179
+ if (term &&
180
+ ((term->type == XML_SCHEMA_TYPE_SEQUENCE) ||
181
+ (term->type == XML_SCHEMA_TYPE_CHOICE) ||
182
+ (term->type == XML_SCHEMA_TYPE_ALL)) &&
183
+ (term->children != NULL)) {
184
+
185
+ rxmlSchemaCollectElements((xmlSchemaParticlePtr) term->children, self);
186
+ }
187
+
188
+ if (particle->next != NULL)
189
+ rxmlSchemaCollectElements((xmlSchemaParticlePtr) particle->next, self);
190
+ }
191
+
192
+ static VALUE
193
+ rxml_schema_type_elements(VALUE self)
194
+ {
195
+ VALUE elements;
196
+ xmlSchemaTypePtr xtype;
197
+
198
+ Data_Get_Struct(self, xmlSchemaType, xtype);
199
+
200
+ if (rb_iv_get(self, "@elements") == Qnil) {
201
+ elements = rb_hash_new();
202
+ rb_iv_set(self, "@elements", elements);
203
+ rxmlSchemaCollectElements((xmlSchemaParticlePtr) xtype->subtypes, self);
204
+ }
205
+
206
+ return rb_iv_get(self, "@elements");
207
+ }
208
+
209
+ static VALUE
210
+ rxml_schema_type_attributes(VALUE self)
211
+ {
212
+ VALUE attributes;
213
+ xmlSchemaTypePtr xtype;
214
+ xmlSchemaAttributeUsePtr use;
215
+ xmlSchemaItemListPtr uses;
216
+ int i;
217
+
218
+ Data_Get_Struct(self, xmlSchemaType, xtype);
219
+
220
+ if (rb_iv_get(self, "@attributes") == Qnil) {
221
+ attributes = rb_ary_new();
222
+ rb_iv_set(self, "@attributes", attributes);
223
+
224
+ uses = xtype->attrUses;
225
+
226
+ if ((uses == NULL) || (uses->nbItems == 0))
227
+ return rb_iv_get(self, "@attributes");
228
+
229
+ for (i = 0; i < uses->nbItems; i++) {
230
+ use = (xmlSchemaAttributeUsePtr) uses->items[i];
231
+ rb_ary_push(attributes, rxml_wrap_schema_attribute(use));
232
+ }
233
+ }
234
+
235
+ return rb_iv_get(self, "@attributes");
236
+ }
237
+
238
+
239
+ void rxml_init_schema_type(void)
240
+ {
241
+ cXMLSchemaType = rb_define_class_under(cXMLSchema, "Type", rb_cObject);
242
+
243
+ rb_define_method(cXMLSchemaType, "namespace", rxml_schema_type_namespace, 0);
244
+ rb_define_method(cXMLSchemaType, "name", rxml_schema_type_name, 0);
245
+ rb_define_method(cXMLSchemaType, "elements", rxml_schema_type_elements, 0);
246
+ rb_define_method(cXMLSchemaType, "attributes", rxml_schema_type_attributes, 0);
247
+ rb_define_method(cXMLSchemaType, "base", rxml_schema_type_base, 0);
248
+ rb_define_method(cXMLSchemaType, "kind", rxml_schema_type_kind, 0);
249
+ rb_define_method(cXMLSchemaType, "node", rxml_schema_type_node, 0);
250
+ rb_define_method(cXMLSchemaType, "facets", rxml_schema_type_facets, 0);
251
+ rb_define_method(cXMLSchemaType, "annotation", rxml_schema_type_annot, 0);
252
+ }