bhook 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (51) hide show
  1. checksums.yaml +7 -0
  2. data/.rspec +3 -0
  3. data/.rubocop.yml +3 -0
  4. data/.ruby-version +1 -0
  5. data/Gemfile +6 -0
  6. data/Gemfile.lock +82 -0
  7. data/LICENSE.txt +21 -0
  8. data/README.md +27 -0
  9. data/Rakefile +13 -0
  10. data/bin/bhook +11 -0
  11. data/lib/bhook/args_parser.rb +55 -0
  12. data/lib/bhook/converter/html.rb +51 -0
  13. data/lib/bhook/directory.rb +62 -0
  14. data/lib/bhook/md_file.rb +50 -0
  15. data/lib/bhook/theme/_after_h1.erb +7 -0
  16. data/lib/bhook/theme/page.erb +71 -0
  17. data/lib/bhook/version.rb +6 -0
  18. data/lib/bhook/workspace.rb +45 -0
  19. data/lib/bhook.rb +22 -0
  20. data/sorbet/config +3 -0
  21. data/sorbet/rbi/gems/ast.rbi +49 -0
  22. data/sorbet/rbi/gems/bhook.rbi +15 -0
  23. data/sorbet/rbi/gems/git.rbi +531 -0
  24. data/sorbet/rbi/gems/kramdown.rbi +255 -0
  25. data/sorbet/rbi/gems/listen.rbi +304 -0
  26. data/sorbet/rbi/gems/parallel.rbi +83 -0
  27. data/sorbet/rbi/gems/parser.rbi +1440 -0
  28. data/sorbet/rbi/gems/rainbow.rbi +122 -0
  29. data/sorbet/rbi/gems/rake.rbi +644 -0
  30. data/sorbet/rbi/gems/rchardet.rbi +181 -0
  31. data/sorbet/rbi/gems/regexp_parser.rbi +929 -0
  32. data/sorbet/rbi/gems/rexml.rbi +599 -0
  33. data/sorbet/rbi/gems/rspec-core.rbi +1898 -0
  34. data/sorbet/rbi/gems/rspec-expectations.rbi +1171 -0
  35. data/sorbet/rbi/gems/rspec-mocks.rbi +1094 -0
  36. data/sorbet/rbi/gems/rspec-support.rbi +280 -0
  37. data/sorbet/rbi/gems/rspec.rbi +15 -0
  38. data/sorbet/rbi/gems/rubocop-ast.rbi +1385 -0
  39. data/sorbet/rbi/gems/rubocop-rake.rbi +85 -0
  40. data/sorbet/rbi/gems/rubocop-rspec.rbi +1044 -0
  41. data/sorbet/rbi/gems/rubocop.rbi +8593 -0
  42. data/sorbet/rbi/gems/ruby-progressbar.rbi +304 -0
  43. data/sorbet/rbi/gems/unicode-display_width.rbi +20 -0
  44. data/sorbet/rbi/hidden-definitions/errors.txt +4944 -0
  45. data/sorbet/rbi/hidden-definitions/hidden.rbi +10044 -0
  46. data/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi +276 -0
  47. data/sorbet/rbi/sorbet-typed/lib/rake/all/rake.rbi +645 -0
  48. data/sorbet/rbi/sorbet-typed/lib/rspec-core/all/rspec-core.rbi +24 -0
  49. data/sorbet/rbi/sorbet-typed/lib/rubocop/>=1.8/rubocop.rbi +12 -0
  50. data/sorbet/rbi/todo.rbi +7 -0
  51. metadata +235 -0
@@ -0,0 +1,599 @@
1
+ # This file is autogenerated. Do not edit it by hand. Regenerate it with:
2
+ # srb rbi gems
3
+
4
+ # typed: strict
5
+ #
6
+ # If you would like to make changes to this file, great! Please create the gem's shim here:
7
+ #
8
+ # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rexml/all/rexml.rbi
9
+ #
10
+ # rexml-3.2.5
11
+
12
+ module REXML
13
+ end
14
+ class REXML::ParseException < RuntimeError
15
+ def context; end
16
+ def continued_exception; end
17
+ def continued_exception=(arg0); end
18
+ def initialize(message, source = nil, parser = nil, exception = nil); end
19
+ def line; end
20
+ def parser; end
21
+ def parser=(arg0); end
22
+ def position; end
23
+ def source; end
24
+ def source=(arg0); end
25
+ def to_s; end
26
+ end
27
+ class REXML::UndefinedNamespaceException < REXML::ParseException
28
+ def initialize(prefix, source, parser); end
29
+ end
30
+ module REXML::Encoding
31
+ def decode(string); end
32
+ def encode(string); end
33
+ def encoding; end
34
+ def encoding=(encoding); end
35
+ def find_encoding(name); end
36
+ end
37
+ class REXML::SourceFactory
38
+ def self.create_from(arg); end
39
+ end
40
+ class REXML::Source
41
+ def buffer; end
42
+ def consume(pattern); end
43
+ def current_line; end
44
+ def detect_encoding; end
45
+ def empty?; end
46
+ def encoding; end
47
+ def encoding=(enc); end
48
+ def encoding_updated; end
49
+ def initialize(arg, encoding = nil); end
50
+ def line; end
51
+ def match(pattern, cons = nil); end
52
+ def match_to(char, pattern); end
53
+ def match_to_consume(char, pattern); end
54
+ def position; end
55
+ def read; end
56
+ def scan(pattern, cons = nil); end
57
+ include REXML::Encoding
58
+ end
59
+ class REXML::IOSource < REXML::Source
60
+ def consume(pattern); end
61
+ def current_line; end
62
+ def empty?; end
63
+ def encoding_updated; end
64
+ def initialize(arg, block_size = nil, encoding = nil); end
65
+ def match(pattern, cons = nil); end
66
+ def position; end
67
+ def read; end
68
+ def readline; end
69
+ def scan(pattern, cons = nil); end
70
+ end
71
+ module REXML::Parsers
72
+ end
73
+ class REXML::Parsers::BaseParser
74
+ def add_listener(listener); end
75
+ def empty?; end
76
+ def entity(reference, entities); end
77
+ def has_next?; end
78
+ def initialize(source); end
79
+ def need_source_encoding_update?(xml_declaration_encoding); end
80
+ def normalize(input, entities = nil, entity_filter = nil); end
81
+ def parse_attributes(prefixes, curr_ns); end
82
+ def parse_id(base_error_message, accept_external_id:, accept_public_id:); end
83
+ def parse_id_invalid_details(accept_external_id:, accept_public_id:); end
84
+ def parse_name(base_error_message); end
85
+ def peek(depth = nil); end
86
+ def position; end
87
+ def process_instruction; end
88
+ def pull; end
89
+ def pull_event; end
90
+ def source; end
91
+ def stream=(source); end
92
+ def unnormalize(string, entities = nil, filter = nil); end
93
+ def unshift(token); end
94
+ end
95
+ module REXML::Security
96
+ def self.entity_expansion_limit; end
97
+ def self.entity_expansion_limit=(val); end
98
+ def self.entity_expansion_text_limit; end
99
+ def self.entity_expansion_text_limit=(val); end
100
+ end
101
+ module REXML::Formatters
102
+ end
103
+ class REXML::Formatters::Default
104
+ def initialize(ie_hack = nil); end
105
+ def write(node, output); end
106
+ def write_cdata(node, output); end
107
+ def write_comment(node, output); end
108
+ def write_document(node, output); end
109
+ def write_element(node, output); end
110
+ def write_instruction(node, output); end
111
+ def write_text(node, output); end
112
+ end
113
+ class REXML::Formatters::Pretty < REXML::Formatters::Default
114
+ def compact; end
115
+ def compact=(arg0); end
116
+ def indent_text(string, level = nil, style = nil, indentfirstline = nil); end
117
+ def initialize(indentation = nil, ie_hack = nil); end
118
+ def width; end
119
+ def width=(arg0); end
120
+ def wrap(string, width); end
121
+ def write_cdata(node, output); end
122
+ def write_comment(node, output); end
123
+ def write_document(node, output); end
124
+ def write_element(node, output); end
125
+ def write_text(node, output); end
126
+ end
127
+ module REXML::Node
128
+ def each_recursive(&block); end
129
+ def find_first_recursive(&block); end
130
+ def indent(to, ind); end
131
+ def index_in_parent; end
132
+ def next_sibling_node; end
133
+ def parent?; end
134
+ def previous_sibling_node; end
135
+ def to_s(indent = nil); end
136
+ end
137
+ class REXML::Child
138
+ def bytes; end
139
+ def document; end
140
+ def initialize(parent = nil); end
141
+ def next_sibling; end
142
+ def next_sibling=(other); end
143
+ def parent; end
144
+ def parent=(other); end
145
+ def previous_sibling; end
146
+ def previous_sibling=(other); end
147
+ def remove; end
148
+ def replace_with(child); end
149
+ include REXML::Node
150
+ end
151
+ class REXML::Parent < REXML::Child
152
+ def <<(object); end
153
+ def [](index); end
154
+ def []=(*args); end
155
+ def add(object); end
156
+ def children; end
157
+ def deep_clone; end
158
+ def delete(object); end
159
+ def delete_at(index); end
160
+ def delete_if(&block); end
161
+ def each(&block); end
162
+ def each_child(&block); end
163
+ def each_index(&block); end
164
+ def index(child); end
165
+ def initialize(parent = nil); end
166
+ def insert_after(child1, child2); end
167
+ def insert_before(child1, child2); end
168
+ def length; end
169
+ def parent?; end
170
+ def push(object); end
171
+ def replace_child(to_replace, replacement); end
172
+ def size; end
173
+ def to_a; end
174
+ def unshift(object); end
175
+ include Enumerable
176
+ end
177
+ module REXML::XMLTokens
178
+ end
179
+ module REXML::Namespace
180
+ def expanded_name; end
181
+ def fully_expanded_name; end
182
+ def has_name?(other, ns = nil); end
183
+ def local_name; end
184
+ def name; end
185
+ def name=(name); end
186
+ def prefix; end
187
+ def prefix=(arg0); end
188
+ include REXML::XMLTokens
189
+ end
190
+ class REXML::Entity < REXML::Child
191
+ def external; end
192
+ def initialize(stream, value = nil, parent = nil, reference = nil); end
193
+ def name; end
194
+ def ndata; end
195
+ def normalized; end
196
+ def pubid; end
197
+ def ref; end
198
+ def self.matches?(string); end
199
+ def to_s; end
200
+ def unnormalized; end
201
+ def value; end
202
+ def write(out, indent = nil); end
203
+ include REXML::XMLTokens
204
+ end
205
+ module REXML::EntityConst
206
+ end
207
+ class REXML::AttlistDecl < REXML::Child
208
+ def [](key); end
209
+ def each(&block); end
210
+ def element_name; end
211
+ def include?(key); end
212
+ def initialize(source); end
213
+ def node_type; end
214
+ def write(out, indent = nil); end
215
+ include Enumerable
216
+ end
217
+ class REXML::ReferenceWriter
218
+ def initialize(id_type, public_id_literal, system_literal, context = nil); end
219
+ def write(output); end
220
+ end
221
+ class REXML::DocType < REXML::Parent
222
+ def add(child); end
223
+ def attribute_of(element, attribute); end
224
+ def attributes_of(element); end
225
+ def clone; end
226
+ def context; end
227
+ def entities; end
228
+ def entity(name); end
229
+ def external_id; end
230
+ def initialize(first, parent = nil); end
231
+ def name; end
232
+ def namespaces; end
233
+ def node_type; end
234
+ def notation(name); end
235
+ def notations; end
236
+ def public; end
237
+ def system; end
238
+ def write(output, indent = nil, transitive = nil, ie_hack = nil); end
239
+ include REXML::XMLTokens
240
+ end
241
+ class REXML::Declaration < REXML::Child
242
+ def initialize(src); end
243
+ def to_s; end
244
+ def write(output, indent); end
245
+ end
246
+ class REXML::ElementDecl < REXML::Declaration
247
+ def initialize(src); end
248
+ end
249
+ class REXML::ExternalEntity < REXML::Child
250
+ def initialize(src); end
251
+ def to_s; end
252
+ def write(output, indent); end
253
+ end
254
+ class REXML::NotationDecl < REXML::Child
255
+ def initialize(name, middle, pub, sys); end
256
+ def name; end
257
+ def public; end
258
+ def public=(arg0); end
259
+ def system; end
260
+ def system=(arg0); end
261
+ def to_s; end
262
+ def write(output, indent = nil); end
263
+ end
264
+ class REXML::Text < REXML::Child
265
+ def <<(to_append); end
266
+ def <=>(other); end
267
+ def clear_cache; end
268
+ def clone; end
269
+ def doctype; end
270
+ def empty?; end
271
+ def indent_text(string, level = nil, style = nil, indentfirstline = nil); end
272
+ def initialize(arg, respect_whitespace = nil, parent = nil, raw = nil, entity_filter = nil, illegal = nil); end
273
+ def inspect; end
274
+ def node_type; end
275
+ def parent=(parent); end
276
+ def raw; end
277
+ def raw=(arg0); end
278
+ def self.check(string, pattern, doctype); end
279
+ def self.expand(ref, doctype, filter); end
280
+ def self.normalize(input, doctype = nil, entity_filter = nil); end
281
+ def self.read_with_substitution(input, illegal = nil); end
282
+ def self.unnormalize(string, doctype = nil, filter = nil, illegal = nil); end
283
+ def to_s; end
284
+ def value; end
285
+ def value=(val); end
286
+ def wrap(string, width, addnewline = nil); end
287
+ def write(writer, indent = nil, transitive = nil, ie_hack = nil); end
288
+ def write_with_substitution(out, input); end
289
+ def xpath; end
290
+ include Comparable
291
+ end
292
+ class REXML::Attribute
293
+ def ==(other); end
294
+ def clone; end
295
+ def doctype; end
296
+ def element; end
297
+ def element=(element); end
298
+ def hash; end
299
+ def initialize(first, second = nil, parent = nil); end
300
+ def inspect; end
301
+ def namespace(arg = nil); end
302
+ def node_type; end
303
+ def normalized=(arg0); end
304
+ def prefix; end
305
+ def remove; end
306
+ def to_s; end
307
+ def to_string; end
308
+ def value; end
309
+ def write(output, indent = nil); end
310
+ def xpath; end
311
+ include REXML::Namespace
312
+ include REXML::Node
313
+ end
314
+ class REXML::CData < REXML::Text
315
+ def clone; end
316
+ def initialize(first, whitespace = nil, parent = nil); end
317
+ def to_s; end
318
+ def value; end
319
+ def write(output = nil, indent = nil, transitive = nil, ie_hack = nil); end
320
+ end
321
+ module REXML::Functions
322
+ end
323
+ class REXML::Parsers::XPathParser
324
+ def AdditiveExpr(path, parsed); end
325
+ def AndExpr(path, parsed); end
326
+ def EqualityExpr(path, parsed); end
327
+ def FilterExpr(path, parsed); end
328
+ def FunctionCall(rest, parsed); end
329
+ def LocationPath(path, parsed); end
330
+ def MultiplicativeExpr(path, parsed); end
331
+ def NodeTest(path, parsed); end
332
+ def OrExpr(path, parsed); end
333
+ def PathExpr(path, parsed); end
334
+ def Predicate(path, parsed); end
335
+ def PrimaryExpr(path, parsed); end
336
+ def RelationalExpr(path, parsed); end
337
+ def RelativeLocationPath(path, parsed); end
338
+ def UnaryExpr(path, parsed); end
339
+ def UnionExpr(path, parsed); end
340
+ def abbreviate(path); end
341
+ def expand(path); end
342
+ def get_group(string); end
343
+ def namespaces=(namespaces); end
344
+ def parse(path); end
345
+ def parse_args(string); end
346
+ def predicate(path); end
347
+ def predicate_to_string(path, &block); end
348
+ include REXML::XMLTokens
349
+ end
350
+ module REXML::DClonable
351
+ end
352
+ class REXML::XPathParser
353
+ def []=(variable_name, value); end
354
+ def child(nodeset); end
355
+ def compare(a, operator, b); end
356
+ def descendant(nodeset, include_self); end
357
+ def descendant_recursive(raw_node, new_nodeset, new_nodes, include_self); end
358
+ def each_unnode(nodeset); end
359
+ def enter(tag, *args); end
360
+ def equality_relational_compare(set1, op, set2); end
361
+ def evaluate_predicate(expression, nodesets); end
362
+ def expr(path_stack, nodeset, context = nil); end
363
+ def filter_nodeset(nodeset); end
364
+ def first(path_stack, node); end
365
+ def following(node); end
366
+ def following_node_of(node); end
367
+ def get_first(path, nodeset); end
368
+ def get_namespace(node, prefix); end
369
+ def initialize(strict: nil); end
370
+ def leave(tag, *args); end
371
+ def match(path_stack, nodeset); end
372
+ def namespaces=(namespaces = nil); end
373
+ def next_sibling_node(node); end
374
+ def node_test(path_stack, nodesets, any_type: nil); end
375
+ def norm(b); end
376
+ def normalize_compare_values(a, operator, b); end
377
+ def parse(path, nodeset); end
378
+ def preceding(node); end
379
+ def preceding_node_of(node); end
380
+ def predicate(path, nodeset); end
381
+ def sort(array_of_nodes, order); end
382
+ def step(path_stack, any_type: nil, order: nil); end
383
+ def strict?; end
384
+ def trace(*args); end
385
+ def unnode(nodeset); end
386
+ def value_type(value); end
387
+ def variables=(vars = nil); end
388
+ include REXML::XMLTokens
389
+ end
390
+ class REXML::XPathNode
391
+ def context; end
392
+ def initialize(node, context = nil); end
393
+ def position; end
394
+ def raw_node; end
395
+ end
396
+ class REXML::XPath
397
+ def self.each(element, path = nil, namespaces = nil, variables = nil, options = nil, &block); end
398
+ def self.first(element, path = nil, namespaces = nil, variables = nil, options = nil); end
399
+ def self.match(element, path = nil, namespaces = nil, variables = nil, options = nil); end
400
+ include REXML::Functions
401
+ end
402
+ class REXML::Element < REXML::Parent
403
+ def [](name_or_index); end
404
+ def __to_xpath_helper(node); end
405
+ def add_attribute(key, value = nil); end
406
+ def add_attributes(hash); end
407
+ def add_element(element, attrs = nil); end
408
+ def add_namespace(prefix, uri = nil); end
409
+ def add_text(text); end
410
+ def attribute(name, namespace = nil); end
411
+ def attributes; end
412
+ def cdatas; end
413
+ def clone; end
414
+ def comments; end
415
+ def context; end
416
+ def context=(arg0); end
417
+ def delete_attribute(key); end
418
+ def delete_element(element); end
419
+ def delete_namespace(namespace = nil); end
420
+ def document; end
421
+ def each_element(xpath = nil, &block); end
422
+ def each_element_with_attribute(key, value = nil, max = nil, name = nil, &block); end
423
+ def each_element_with_text(text = nil, max = nil, name = nil, &block); end
424
+ def each_with_something(test, max = nil, name = nil); end
425
+ def elements; end
426
+ def get_elements(xpath); end
427
+ def get_text(path = nil); end
428
+ def has_attributes?; end
429
+ def has_elements?; end
430
+ def has_text?; end
431
+ def ignore_whitespace_nodes; end
432
+ def initialize(arg = nil, parent = nil, context = nil); end
433
+ def inspect; end
434
+ def instructions; end
435
+ def namespace(prefix = nil); end
436
+ def namespaces; end
437
+ def next_element; end
438
+ def node_type; end
439
+ def prefixes; end
440
+ def previous_element; end
441
+ def raw; end
442
+ def root; end
443
+ def root_node; end
444
+ def text(path = nil); end
445
+ def text=(text); end
446
+ def texts; end
447
+ def whitespace; end
448
+ def write(output = nil, indent = nil, transitive = nil, ie_hack = nil); end
449
+ def xpath; end
450
+ include REXML::Namespace
451
+ end
452
+ class REXML::Elements
453
+ def <<(element = nil); end
454
+ def [](index, name = nil); end
455
+ def []=(index, element); end
456
+ def add(element = nil); end
457
+ def collect(xpath = nil); end
458
+ def delete(element); end
459
+ def delete_all(xpath); end
460
+ def each(xpath = nil); end
461
+ def empty?; end
462
+ def index(element); end
463
+ def initialize(parent); end
464
+ def inject(xpath = nil, initial = nil); end
465
+ def literalize(name); end
466
+ def parent; end
467
+ def size; end
468
+ def to_a(xpath = nil); end
469
+ include Enumerable
470
+ end
471
+ class REXML::Attributes < Hash
472
+ def <<(attribute); end
473
+ def [](name); end
474
+ def []=(name, value); end
475
+ def add(attribute); end
476
+ def delete(attribute); end
477
+ def delete_all(name); end
478
+ def each; end
479
+ def each_attribute; end
480
+ def get_attribute(name); end
481
+ def get_attribute_ns(namespace, name); end
482
+ def initialize(element); end
483
+ def length; end
484
+ def namespaces; end
485
+ def prefixes; end
486
+ def size; end
487
+ def to_a; end
488
+ end
489
+ class REXML::XMLDecl < REXML::Child
490
+ def ==(other); end
491
+ def clone; end
492
+ def content(enc); end
493
+ def dowrite; end
494
+ def encoding=(enc); end
495
+ def initialize(version = nil, encoding = nil, standalone = nil); end
496
+ def inspect; end
497
+ def node_type; end
498
+ def nowrite; end
499
+ def old_enc=(encoding); end
500
+ def self.default; end
501
+ def stand_alone?; end
502
+ def standalone; end
503
+ def standalone=(arg0); end
504
+ def version; end
505
+ def version=(arg0); end
506
+ def write(writer, indent = nil, transitive = nil, ie_hack = nil); end
507
+ def writeencoding; end
508
+ def writethis; end
509
+ def xmldecl(version, encoding, standalone); end
510
+ include REXML::Encoding
511
+ end
512
+ class REXML::Comment < REXML::Child
513
+ def <=>(other); end
514
+ def ==(other); end
515
+ def clone; end
516
+ def initialize(first, second = nil); end
517
+ def node_type; end
518
+ def string; end
519
+ def string=(arg0); end
520
+ def to_s; end
521
+ def write(output, indent = nil, transitive = nil, ie_hack = nil); end
522
+ include Comparable
523
+ end
524
+ class REXML::Instruction < REXML::Child
525
+ def ==(other); end
526
+ def clone; end
527
+ def content; end
528
+ def content=(arg0); end
529
+ def initialize(target, content = nil); end
530
+ def inspect; end
531
+ def node_type; end
532
+ def target; end
533
+ def target=(arg0); end
534
+ def write(writer, indent = nil, transitive = nil, ie_hack = nil); end
535
+ end
536
+ class REXML::Output
537
+ def <<(content); end
538
+ def encoding; end
539
+ def initialize(real_IO, encd = nil); end
540
+ def to_s; end
541
+ include REXML::Encoding
542
+ end
543
+ class REXML::Parsers::StreamParser
544
+ def add_listener(listener); end
545
+ def initialize(source, listener); end
546
+ def parse; end
547
+ end
548
+ module REXML::Validation
549
+ end
550
+ class REXML::Validation::ValidationException < RuntimeError
551
+ def initialize(msg); end
552
+ end
553
+ class REXML::Parsers::TreeParser
554
+ def add_listener(listener); end
555
+ def initialize(source, build_context = nil); end
556
+ def parse; end
557
+ end
558
+ class REXML::Document < REXML::Element
559
+ def <<(child); end
560
+ def add(child); end
561
+ def add_element(arg = nil, arg2 = nil); end
562
+ def build(source); end
563
+ def clone; end
564
+ def doctype; end
565
+ def document; end
566
+ def encoding; end
567
+ def entity_expansion_count; end
568
+ def expanded_name; end
569
+ def initialize(source = nil, context = nil); end
570
+ def name; end
571
+ def node_type; end
572
+ def record_entity_expansion; end
573
+ def root; end
574
+ def self.entity_expansion_limit; end
575
+ def self.entity_expansion_limit=(val); end
576
+ def self.entity_expansion_text_limit; end
577
+ def self.entity_expansion_text_limit=(val); end
578
+ def self.parse_stream(source, listener); end
579
+ def stand_alone?; end
580
+ def version; end
581
+ def write(*arguments); end
582
+ def xml_decl; end
583
+ end
584
+ module REXML::StreamListener
585
+ def attlistdecl(element_name, attributes, raw_content); end
586
+ def cdata(content); end
587
+ def comment(comment); end
588
+ def doctype(name, pub_sys, long_name, uri); end
589
+ def doctype_end; end
590
+ def elementdecl(content); end
591
+ def entity(content); end
592
+ def entitydecl(content); end
593
+ def instruction(name, instruction); end
594
+ def notationdecl(content); end
595
+ def tag_end(name); end
596
+ def tag_start(name, attrs); end
597
+ def text(text); end
598
+ def xmldecl(version, encoding, standalone); end
599
+ end