ox 2.4.1 → 2.4.2

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

Potentially problematic release.


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

@@ -0,0 +1,7 @@
1
+ ---
2
+ SHA1:
3
+ metadata.gz: 2215329004101c80d8889571ae58a0ffa6c29606
4
+ data.tar.gz: 960ed868f559389e88f2be2fd9baf32f1ca6a3de
5
+ SHA512:
6
+ metadata.gz: 90c53c12df67cd76cbecbb9649efef8762c69ba7665904722959349fe113784dd3af1e8c16bdbd32da97d70806f9383aa12d02b974d9c074899e221997240f4f
7
+ data.tar.gz: cf95951c262f221dd8e1d679cc288ac5837cf00adf074c906bf0c2842772af368d606e2f6b56a6375ef31936ef298c9b8ec662405c3c18a88024f09eeb76838c
data/README.md CHANGED
@@ -34,6 +34,10 @@ A fast XML parser and Object marshaller as a Ruby gem.
34
34
 
35
35
  ## Release Notes
36
36
 
37
+ ### Release 2.4.2
38
+
39
+ - Added methods to Ox::Builder to provide output position information.
40
+
37
41
  ### Release 2.4.1
38
42
 
39
43
  - Made SAX smarter a little smarter or rather let it handle unquoted string
@@ -51,23 +55,6 @@ A fast XML parser and Object marshaller as a Ruby gem.
51
55
  - Added Ox::Builder that constructs an XML string or writes XML to a stream
52
56
  using builder methods.
53
57
 
54
- ### Release 2.3.0
55
-
56
- - Added Ox::Element.replace_text() method.
57
-
58
- - Ox::Element nodes variable is now always initialized to an empty Array.
59
-
60
- - Ox::Element attributes variable is now always initialized to an empty Hash.
61
-
62
- - A invalid_replace option has been added. It will replace invalid XML
63
- character with a provided string. Strict effort now raises an exception if an
64
- invalid character is encountered on dump or load.
65
-
66
- - Ox.load and Ox.parse now allow for a callback block to handle multiple top
67
- level entities in the input.
68
-
69
- - The Ox SAX parser now supports strings as input directly without and IO wrapper.
70
-
71
58
  ## Description
72
59
 
73
60
  Optimized XML (Ox), as the name implies was written to provide speed optimized
@@ -29,6 +29,9 @@ typedef struct _Builder {
29
29
  int depth;
30
30
  FILE *file;
31
31
  struct _Element stack[MAX_DEPTH];
32
+ long line;
33
+ long col;
34
+ long pos;
32
35
  } *Builder;
33
36
 
34
37
  static VALUE builder_class = Qundef;
@@ -68,48 +71,70 @@ append_indent(Builder b) {
68
71
  cnt = sizeof(indent_spaces) - 1;
69
72
  }
70
73
  buf_append_string(&b->buf, indent_spaces, cnt);
74
+ b->line++;
75
+ b->col = cnt - 1;
76
+ b->pos += cnt;
71
77
  }
72
78
  }
73
79
 
74
80
  static void
75
- append_string(Buf b, const char *str, size_t size) {
81
+ append_string(Builder b, const char *str, size_t size) {
76
82
  size_t xsize = xml_str_len((const unsigned char*)str, size);
77
83
 
78
84
  if (size == xsize) {
79
- buf_append_string(b, str, size);
85
+ const char *s = str;
86
+ const char *end = str + size;
87
+
88
+ buf_append_string(&b->buf, str, size);
89
+ b->col += size;
90
+ while (NULL != (s = index(s, '\n'))) {
91
+ b->line++;
92
+ b->col = end - s;
93
+ }
94
+ b->pos += size;
80
95
  } else {
81
96
  char buf[256];
82
97
  char *end = buf + sizeof(buf) - 1;
83
98
  char *bp = buf;
84
99
  int i = size;
100
+ int fcnt;
85
101
 
86
102
  for (; '\0' != *str && 0 < i; i--, str++) {
87
- if ('1' == xml_friendly_chars[(unsigned char)*str]) {
103
+ if ('1' == (fcnt = xml_friendly_chars[(unsigned char)*str])) {
88
104
  if (end <= bp) {
89
- buf_append_string(b, buf, bp - buf);
105
+ buf_append_string(&b->buf, buf, bp - buf);
90
106
  bp = buf;
91
107
  }
108
+ if ('\n' == *str) {
109
+ b->line++;
110
+ b->col = 1;
111
+ } else {
112
+ b->col++;
113
+ }
114
+ b->pos++;
92
115
  *bp++ = *str;
93
116
  } else {
117
+ b->pos += fcnt;
118
+ b->col += fcnt;
94
119
  if (buf < bp) {
95
- buf_append_string(b, buf, bp - buf);
120
+ buf_append_string(&b->buf, buf, bp - buf);
96
121
  bp = buf;
97
122
  }
98
123
  switch (*str) {
99
124
  case '"':
100
- buf_append_string(b, "&quot;", 6);
125
+ buf_append_string(&b->buf, "&quot;", 6);
101
126
  break;
102
127
  case '&':
103
- buf_append_string(b, "&amp;", 5);
128
+ buf_append_string(&b->buf, "&amp;", 5);
104
129
  break;
105
130
  case '\'':
106
- buf_append_string(b, "&apos;", 6);
131
+ buf_append_string(&b->buf, "&apos;", 6);
107
132
  break;
108
133
  case '<':
109
- buf_append_string(b, "&lt;", 4);
134
+ buf_append_string(&b->buf, "&lt;", 4);
110
135
  break;
111
136
  case '>':
112
- buf_append_string(b, "&gt;", 4);
137
+ buf_append_string(&b->buf, "&gt;", 4);
113
138
  break;
114
139
  default:
115
140
  // Must be one of the invalid characters.
@@ -119,14 +144,14 @@ append_string(Buf b, const char *str, size_t size) {
119
144
  }
120
145
  }
121
146
  if (buf < bp) {
122
- buf_append_string(b, buf, bp - buf);
147
+ buf_append_string(&b->buf, buf, bp - buf);
123
148
  bp = buf;
124
149
  }
125
150
  }
126
151
  }
127
152
 
128
153
  static void
129
- append_sym_str(Buf b, VALUE v) {
154
+ append_sym_str(Builder b, VALUE v) {
130
155
  const char *s;
131
156
  int len;
132
157
 
@@ -154,6 +179,8 @@ i_am_a_child(Builder b, bool is_text) {
154
179
  if (!e->has_child) {
155
180
  e->has_child = true;
156
181
  buf_append(&b->buf, '>');
182
+ b->col++;
183
+ b->pos++;
157
184
  }
158
185
  if (!is_text) {
159
186
  e->non_text_child = true;
@@ -163,12 +190,19 @@ i_am_a_child(Builder b, bool is_text) {
163
190
 
164
191
  static int
165
192
  append_attr(VALUE key, VALUE value, Builder b) {
193
+ int len;
194
+
166
195
  buf_append(&b->buf, ' ');
167
- append_sym_str(&b->buf, key);
196
+ b->col++;
197
+ b->pos++;
198
+ append_sym_str(b, key);
168
199
  buf_append_string(&b->buf, "=\"", 2);
169
200
  Check_Type(value, T_STRING);
170
- buf_append_string(&b->buf, StringValuePtr(value), RSTRING_LEN(value));
201
+ len = (int)RSTRING_LEN(value);
202
+ buf_append_string(&b->buf, StringValuePtr(value), len);
171
203
  buf_append(&b->buf, '"');
204
+ b->col += len + 3;
205
+ b->pos += len + 3;
172
206
 
173
207
  return ST_CONTINUE;
174
208
  }
@@ -179,6 +213,9 @@ init(Builder b, int fd, int indent, long initial_size) {
179
213
  b->indent = indent;
180
214
  *b->encoding = '\0';
181
215
  b->depth = -1;
216
+ b->line = 1;
217
+ b->col = 1;
218
+ b->pos = 0;
182
219
  }
183
220
 
184
221
  static void
@@ -216,12 +253,16 @@ pop(Builder b) {
216
253
  buf_append_string(&b->buf, "</", 2);
217
254
  buf_append_string(&b->buf, e->name, e->len);
218
255
  buf_append(&b->buf, '>');
256
+ b->col += e->len + 3;
257
+ b->pos += e->len + 3;
219
258
  if (e->buf != e->name) {
220
259
  free(e->name);
221
260
  e->name = 0;
222
261
  }
223
262
  } else {
224
263
  buf_append_string(&b->buf, "/>", 2);
264
+ b->col += 2;
265
+ b->pos += 2;
225
266
  }
226
267
  }
227
268
 
@@ -231,6 +272,9 @@ bclose(Builder b) {
231
272
  pop(b);
232
273
  }
233
274
  buf_append(&b->buf, '\n');
275
+ b->line++;
276
+ b->col = 1;
277
+ b->pos++;
234
278
  buf_finish(&b->buf);
235
279
  if (NULL != b->file) {
236
280
  fclose(b->file);
@@ -246,6 +290,9 @@ to_s(Builder b) {
246
290
  }
247
291
  if ('\n' != *(b->buf.tail - 1)) {
248
292
  buf_append(&b->buf, '\n');
293
+ b->line++;
294
+ b->col = 1;
295
+ b->pos++;
249
296
  }
250
297
  *b->buf.tail = '\0'; // for debugging
251
298
  rstr = rb_str_new(b->buf.head, buf_len(&b->buf));
@@ -296,6 +343,7 @@ builder_new(int argc, VALUE *argv, VALUE self) {
296
343
 
297
344
  if (rb_block_given_p()) {
298
345
  volatile VALUE rb = Data_Wrap_Struct(builder_class, NULL, builder_free, b);
346
+
299
347
  rb_yield(rb);
300
348
  bclose(b);
301
349
 
@@ -429,27 +477,39 @@ builder_instruct(int argc, VALUE *argv, VALUE self) {
429
477
  append_indent(b);
430
478
  if (0 == argc) {
431
479
  buf_append_string(&b->buf, "<?xml?>", 7);
480
+ b->col += 7;
481
+ b->pos += 7;
432
482
  } else {
433
483
  volatile VALUE v;
434
484
 
435
485
  buf_append_string(&b->buf, "<?", 2);
436
- append_sym_str(&b->buf, *argv);
486
+ b->col += 2;
487
+ b->pos += 2;
488
+ append_sym_str(b, *argv);
437
489
  if (1 < argc && rb_cHash == rb_obj_class(argv[1])) {
490
+ int len;
491
+
438
492
  if (Qnil != (v = rb_hash_lookup(argv[1], ox_version_sym))) {
439
493
  if (rb_cString != rb_obj_class(v)) {
440
494
  rb_raise(ox_parse_error_class, ":version must be a Symbol.\n");
441
495
  }
496
+ len = (int)RSTRING_LEN(v);
442
497
  buf_append_string(&b->buf, " version=\"", 10);
443
- buf_append_string(&b->buf, StringValuePtr(v), RSTRING_LEN(v));
498
+ buf_append_string(&b->buf, StringValuePtr(v), len);
444
499
  buf_append(&b->buf, '"');
500
+ b->col += len + 11;
501
+ b->pos += len + 11;
445
502
  }
446
503
  if (Qnil != (v = rb_hash_lookup(argv[1], ox_encoding_sym))) {
447
504
  if (rb_cString != rb_obj_class(v)) {
448
505
  rb_raise(ox_parse_error_class, ":encoding must be a Symbol.\n");
449
506
  }
507
+ len = (int)RSTRING_LEN(v);
450
508
  buf_append_string(&b->buf, " encoding=\"", 11);
451
- buf_append_string(&b->buf, StringValuePtr(v), RSTRING_LEN(v));
509
+ buf_append_string(&b->buf, StringValuePtr(v), len);
452
510
  buf_append(&b->buf, '"');
511
+ b->col += len + 12;
512
+ b->pos += len + 12;
453
513
  strncpy(b->encoding, StringValuePtr(v), sizeof(b->encoding));
454
514
  b->encoding[sizeof(b->encoding) - 1] = '\0';
455
515
  }
@@ -457,12 +517,17 @@ builder_instruct(int argc, VALUE *argv, VALUE self) {
457
517
  if (rb_cString != rb_obj_class(v)) {
458
518
  rb_raise(ox_parse_error_class, ":standalone must be a Symbol.\n");
459
519
  }
520
+ len = (int)RSTRING_LEN(v);
460
521
  buf_append_string(&b->buf, " standalone=\"", 13);
461
- buf_append_string(&b->buf, StringValuePtr(v), RSTRING_LEN(v));
522
+ buf_append_string(&b->buf, StringValuePtr(v), len);
462
523
  buf_append(&b->buf, '"');
524
+ b->col += len + 14;
525
+ b->pos += len + 14;
463
526
  }
464
527
  }
465
528
  buf_append_string(&b->buf, "?>", 2);
529
+ b->col += 2;
530
+ b->pos += 2;
466
531
  }
467
532
  return Qnil;
468
533
  }
@@ -517,7 +582,9 @@ builder_element(int argc, VALUE *argv, VALUE self) {
517
582
  e->non_text_child = false;
518
583
 
519
584
  buf_append(&b->buf, '<');
520
- buf_append_string(&b->buf, e->name, len);
585
+ b->col++;
586
+ b->pos++;
587
+ append_string(b, e->name, len);
521
588
  if (1 < argc) {
522
589
  rb_hash_foreach(argv[1], append_attr, (VALUE)b);
523
590
  }
@@ -537,14 +604,18 @@ builder_element(int argc, VALUE *argv, VALUE self) {
537
604
  static VALUE
538
605
  builder_comment(VALUE self, VALUE text) {
539
606
  Builder b = (Builder)DATA_PTR(self);
540
-
607
+
541
608
  rb_check_type(text, T_STRING);
542
609
  i_am_a_child(b, false);
543
610
  append_indent(b);
544
611
  buf_append_string(&b->buf, "<!-- ", 5);
545
- buf_append_string(&b->buf, StringValuePtr(text), RSTRING_LEN(text));
612
+ b->col += 5;
613
+ b->pos += 5;
614
+ append_string(b, StringValuePtr(text), RSTRING_LEN(text));
546
615
  buf_append_string(&b->buf, " --/> ", 5);
547
-
616
+ b->col += 5;
617
+ b->pos += 5;
618
+
548
619
  return Qnil;
549
620
  }
550
621
 
@@ -561,8 +632,12 @@ builder_doctype(VALUE self, VALUE text) {
561
632
  i_am_a_child(b, false);
562
633
  append_indent(b);
563
634
  buf_append_string(&b->buf, "<!DOCTYPE ", 10);
564
- buf_append_string(&b->buf, StringValuePtr(text), RSTRING_LEN(text));
635
+ b->col += 10;
636
+ b->pos += 10;
637
+ append_string(b, StringValuePtr(text), RSTRING_LEN(text));
565
638
  buf_append(&b->buf, '>');
639
+ b->col++;
640
+ b->pos++;
566
641
 
567
642
  return Qnil;
568
643
  }
@@ -581,7 +656,7 @@ builder_text(VALUE self, VALUE text) {
581
656
  v = rb_funcall(v, ox_to_s_id, 0);
582
657
  }
583
658
  i_am_a_child(b, true);
584
- append_string(&b->buf, StringValuePtr(v), RSTRING_LEN(v));
659
+ append_string(b, StringValuePtr(v), RSTRING_LEN(v));
585
660
 
586
661
  return Qnil;
587
662
  }
@@ -595,15 +670,33 @@ static VALUE
595
670
  builder_cdata(VALUE self, VALUE data) {
596
671
  Builder b = (Builder)DATA_PTR(self);
597
672
  volatile VALUE v = data;
673
+ const char *str;
674
+ const char *s;
675
+ const char *end;
676
+ int len;
598
677
 
599
678
  if (T_STRING != rb_type(v)) {
600
679
  v = rb_funcall(v, ox_to_s_id, 0);
601
680
  }
681
+ str = StringValuePtr(v);
682
+ len = (int)RSTRING_LEN(v);
683
+ s = str;
684
+ end = str + len;
602
685
  i_am_a_child(b, false);
603
686
  append_indent(b);
604
687
  buf_append_string(&b->buf, "<![CDATA[", 9);
605
- buf_append_string(&b->buf, StringValuePtr(v), RSTRING_LEN(v));
688
+ b->col += 9;
689
+ b->pos += 9;
690
+ buf_append_string(&b->buf, str, len);
691
+ b->col += len;
692
+ while (NULL != (s = index(s, '\n'))) {
693
+ b->line++;
694
+ b->col = end - s;
695
+ }
696
+ b->pos += len;
606
697
  buf_append_string(&b->buf, "]]>", 3);
698
+ b->col += 3;
699
+ b->pos += 3;
607
700
 
608
701
  return Qnil;
609
702
  }
@@ -618,12 +711,26 @@ static VALUE
618
711
  builder_raw(VALUE self, VALUE text) {
619
712
  Builder b = (Builder)DATA_PTR(self);
620
713
  volatile VALUE v = text;
714
+ const char *str;
715
+ const char *s;
716
+ const char *end;
717
+ int len;
621
718
 
622
719
  if (T_STRING != rb_type(v)) {
623
720
  v = rb_funcall(v, ox_to_s_id, 0);
624
721
  }
722
+ str = StringValuePtr(v);
723
+ len = (int)RSTRING_LEN(v);
724
+ s = str;
725
+ end = str + len;
625
726
  i_am_a_child(b, true);
626
- buf_append_string(&b->buf, StringValuePtr(v), RSTRING_LEN(v));
727
+ buf_append_string(&b->buf, str, len);
728
+ b->col += len;
729
+ while (NULL != (s = index(s, '\n'))) {
730
+ b->line++;
731
+ b->col = end - s;
732
+ }
733
+ b->pos += len;
627
734
 
628
735
  return Qnil;
629
736
  }
@@ -637,6 +744,34 @@ builder_to_s(VALUE self) {
637
744
  return to_s((Builder)DATA_PTR(self));
638
745
  }
639
746
 
747
+ /* call-seq: line()
748
+ *
749
+ * Returns the current line in the output. The first line is line 1.
750
+ */
751
+ static VALUE
752
+ builder_line(VALUE self) {
753
+ return LONG2NUM(((Builder)DATA_PTR(self))->line);
754
+ }
755
+
756
+ /* call-seq: column()
757
+ *
758
+ * Returns the current column in the output. The first character in a line is at
759
+ * column 1.
760
+ */
761
+ static VALUE
762
+ builder_column(VALUE self) {
763
+ return LONG2NUM(((Builder)DATA_PTR(self))->col);
764
+ }
765
+
766
+ /* call-seq: pos()
767
+ *
768
+ * Returns the number of bytes written.
769
+ */
770
+ static VALUE
771
+ builder_pos(VALUE self) {
772
+ return LONG2NUM(((Builder)DATA_PTR(self))->pos);
773
+ }
774
+
640
775
  /* call-seq: pop()
641
776
  *
642
777
  * Closes the current element.
@@ -682,4 +817,7 @@ void ox_init_builder(VALUE ox) {
682
817
  rb_define_method(builder_class, "pop", builder_pop, 0);
683
818
  rb_define_method(builder_class, "close", builder_close, 0);
684
819
  rb_define_method(builder_class, "to_s", builder_to_s, 0);
820
+ rb_define_method(builder_class, "line", builder_line, 0);
821
+ rb_define_method(builder_class, "column", builder_column, 0);
822
+ rb_define_method(builder_class, "pos", builder_pos, 0);
685
823
  }
@@ -0,0 +1,26 @@
1
+ /* encode.h
2
+ * Copyright (c) 2011, Peter Ohler
3
+ * All rights reserved.
4
+ */
5
+
6
+ #ifndef __OX_ENCODE_H__
7
+ #define __OX_ENCODE_H__
8
+
9
+ #include "ruby.h"
10
+ #if HAS_ENCODING_SUPPORT
11
+ #include "ruby/encoding.h"
12
+ #endif
13
+
14
+ static inline VALUE
15
+ ox_encode(VALUE rstr) {
16
+ #if HAS_ENCODING_SUPPORT
17
+ rb_enc_associate(rstr, ox_utf8_encoding);
18
+ #else
19
+ if (Qnil != ox_utf8_encoding) {
20
+ rstr = rb_funcall(ox_utf8_encoding, ox_iconv_id, 1, rstr);
21
+ }
22
+ #endif
23
+ return rstr;
24
+ }
25
+
26
+ #endif /* __OX_ENCODE_H__ */
@@ -1,5 +1,5 @@
1
1
 
2
2
  module Ox
3
3
  # Current version of the module.
4
- VERSION = '2.4.1'
4
+ VERSION = '2.4.2'
5
5
  end
metadata CHANGED
@@ -1,21 +1,19 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: ox
3
3
  version: !ruby/object:Gem::Version
4
- version: 2.4.1
5
- prerelease:
4
+ version: 2.4.2
6
5
  platform: ruby
7
6
  authors:
8
7
  - Peter Ohler
9
8
  autorequire:
10
9
  bindir: bin
11
10
  cert_chain: []
12
- date: 2016-04-30 00:00:00.000000000 Z
11
+ date: 2016-06-23 00:00:00.000000000 Z
13
12
  dependencies: []
14
- description: ! "A fast XML parser and object serializer that uses only standard C
15
- lib.\n \nOptimized XML (Ox), as the name implies was written to provide
16
- speed optimized\nXML handling. It was designed to be an alternative to Nokogiri
17
- and other Ruby\nXML parsers for generic XML parsing and as an alternative to Marshal
18
- for Object\nserialization. "
13
+ description: "A fast XML parser and object serializer that uses only standard C lib.\n
14
+ \ \nOptimized XML (Ox), as the name implies was written to provide speed
15
+ optimized\nXML handling. It was designed to be an alternative to Nokogiri and other
16
+ Ruby\nXML parsers for generic XML parsing and as an alternative to Marshal for Object\nserialization. "
19
17
  email: peter@ohler.com
20
18
  executables: []
21
19
  extensions:
@@ -23,84 +21,85 @@ extensions:
23
21
  extra_rdoc_files:
24
22
  - README.md
25
23
  files:
26
- - lib/ox/bag.rb
27
- - lib/ox/cdata.rb
28
- - lib/ox/comment.rb
29
- - lib/ox/doctype.rb
30
- - lib/ox/document.rb
31
- - lib/ox/element.rb
32
- - lib/ox/error.rb
33
- - lib/ox/hasattrs.rb
34
- - lib/ox/instruct.rb
35
- - lib/ox/node.rb
36
- - lib/ox/raw.rb
37
- - lib/ox/sax.rb
38
- - lib/ox/version.rb
39
- - lib/ox/xmlrpc_adapter.rb
40
- - lib/ox.rb
41
- - ext/ox/extconf.rb
24
+ - LICENSE
25
+ - README.md
42
26
  - ext/ox/attr.h
27
+ - ext/ox/base64.c
43
28
  - ext/ox/base64.h
44
29
  - ext/ox/buf.h
45
- - ext/ox/cache.h
46
- - ext/ox/cache8.h
47
- - ext/ox/err.h
48
- - ext/ox/helper.h
49
- - ext/ox/ox.h
50
- - ext/ox/sax.h
51
- - ext/ox/sax_buf.h
52
- - ext/ox/sax_has.h
53
- - ext/ox/sax_hint.h
54
- - ext/ox/sax_stack.h
55
- - ext/ox/special.h
56
- - ext/ox/type.h
57
- - ext/ox/base64.c
58
30
  - ext/ox/builder.c
59
31
  - ext/ox/cache.c
32
+ - ext/ox/cache.h
60
33
  - ext/ox/cache8.c
34
+ - ext/ox/cache8.h
61
35
  - ext/ox/dump.c
36
+ - ext/ox/encode.h
62
37
  - ext/ox/err.c
38
+ - ext/ox/err.h
39
+ - ext/ox/extconf.rb
63
40
  - ext/ox/gen_load.c
41
+ - ext/ox/helper.h
64
42
  - ext/ox/obj_load.c
65
43
  - ext/ox/ox.c
44
+ - ext/ox/ox.h
66
45
  - ext/ox/parse.c
67
46
  - ext/ox/sax.c
47
+ - ext/ox/sax.h
68
48
  - ext/ox/sax_as.c
69
49
  - ext/ox/sax_buf.c
50
+ - ext/ox/sax_buf.h
51
+ - ext/ox/sax_has.h
70
52
  - ext/ox/sax_hint.c
53
+ - ext/ox/sax_hint.h
54
+ - ext/ox/sax_stack.h
71
55
  - ext/ox/special.c
72
- - LICENSE
73
- - README.md
56
+ - ext/ox/special.h
57
+ - ext/ox/type.h
58
+ - lib/ox.rb
59
+ - lib/ox/bag.rb
60
+ - lib/ox/cdata.rb
61
+ - lib/ox/comment.rb
62
+ - lib/ox/doctype.rb
63
+ - lib/ox/document.rb
64
+ - lib/ox/element.rb
65
+ - lib/ox/error.rb
66
+ - lib/ox/hasattrs.rb
67
+ - lib/ox/instruct.rb
68
+ - lib/ox/node.rb
69
+ - lib/ox/raw.rb
70
+ - lib/ox/sax.rb
71
+ - lib/ox/version.rb
72
+ - lib/ox/xmlrpc_adapter.rb
74
73
  homepage: http://www.ohler.com/ox
75
74
  licenses:
76
75
  - MIT
76
+ metadata: {}
77
77
  post_install_message:
78
78
  rdoc_options:
79
- - --main
79
+ - "--main"
80
80
  - README.md
81
- - --title
81
+ - "--title"
82
82
  - Ox Documentation
83
- - --exclude
83
+ - "--exclude"
84
84
  - extconf.rb
85
85
  require_paths:
86
86
  - lib
87
87
  - ext
88
88
  required_ruby_version: !ruby/object:Gem::Requirement
89
- none: false
90
89
  requirements:
91
- - - ! '>='
90
+ - - ">="
92
91
  - !ruby/object:Gem::Version
93
92
  version: '0'
94
93
  required_rubygems_version: !ruby/object:Gem::Requirement
95
- none: false
96
94
  requirements:
97
- - - ! '>='
95
+ - - ">="
98
96
  - !ruby/object:Gem::Version
99
97
  version: '0'
100
98
  requirements: []
101
99
  rubyforge_project: ox
102
- rubygems_version: 1.8.23.2
100
+ rubygems_version: 2.4.5
103
101
  signing_key:
104
- specification_version: 3
102
+ specification_version: 4
105
103
  summary: A fast XML parser and object serializer.
106
104
  test_files: []
105
+ has_rdoc: true