nora_mark 0.2beta7 → 0.2beta8

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.
@@ -1,26 +1,31 @@
1
1
  require 'kpeg/compiled_parser'
2
2
 
3
3
  class NoraMark::Parser < KPeg::CompiledParser
4
+
5
+
6
+ PARAMETER_END = /[,)]/
7
+
8
+
4
9
  # :stopdoc:
5
10
 
6
11
  module ::NoraMark
7
12
  class Node; end
8
13
  class Block < Node
9
- def initialize(name, ids, classes, parameters, named_parameters, content, line_no)
14
+ def initialize(name, ids, classes, params, named_params, raw_content, line_no)
10
15
  @name = name
11
16
  @ids = ids
12
17
  @classes = classes
13
- @parameters = parameters
14
- @named_parameters = named_parameters
15
- @content = content
18
+ @params = params
19
+ @named_params = named_params
20
+ @raw_content = raw_content
16
21
  @line_no = line_no
17
22
  end
18
23
  attr_reader :name
19
24
  attr_reader :ids
20
25
  attr_reader :classes
21
- attr_reader :parameters
22
- attr_reader :named_parameters
23
- attr_reader :content
26
+ attr_reader :params
27
+ attr_reader :named_params
28
+ attr_reader :raw_content
24
29
  attr_reader :line_no
25
30
  end
26
31
  class Breakline < Node
@@ -29,36 +34,52 @@ class NoraMark::Parser < KPeg::CompiledParser
29
34
  end
30
35
  attr_reader :line_no
31
36
  end
32
- class DefinitionList < Node
33
- def initialize(ids, classes, parameters, named_parameters, content, line_no)
37
+ class CodeInline < Node
38
+ def initialize(ids, classes, params, named_params, content, line_no)
34
39
  @ids = ids
35
40
  @classes = classes
36
- @parameters = parameters
37
- @named_parameters = named_parameters
41
+ @params = params
42
+ @named_params = named_params
38
43
  @content = content
39
44
  @line_no = line_no
40
45
  end
41
46
  attr_reader :ids
42
47
  attr_reader :classes
43
- attr_reader :parameters
44
- attr_reader :named_parameters
48
+ attr_reader :params
49
+ attr_reader :named_params
45
50
  attr_reader :content
46
51
  attr_reader :line_no
47
52
  end
53
+ class DefinitionList < Node
54
+ def initialize(ids, classes, params, named_params, raw_content, line_no)
55
+ @ids = ids
56
+ @classes = classes
57
+ @params = params
58
+ @named_params = named_params
59
+ @raw_content = raw_content
60
+ @line_no = line_no
61
+ end
62
+ attr_reader :ids
63
+ attr_reader :classes
64
+ attr_reader :params
65
+ attr_reader :named_params
66
+ attr_reader :raw_content
67
+ attr_reader :line_no
68
+ end
48
69
  class DLItem < Node
49
- def initialize(ids, classes, parameters, named_parameters, content, line_no)
70
+ def initialize(ids, classes, params, named_params, raw_content, line_no)
50
71
  @ids = ids
51
72
  @classes = classes
52
- @parameters = parameters
53
- @named_parameters = named_parameters
54
- @content = content
73
+ @params = params
74
+ @named_params = named_params
75
+ @raw_content = raw_content
55
76
  @line_no = line_no
56
77
  end
57
78
  attr_reader :ids
58
79
  attr_reader :classes
59
- attr_reader :parameters
60
- attr_reader :named_parameters
61
- attr_reader :content
80
+ attr_reader :params
81
+ attr_reader :named_params
82
+ attr_reader :raw_content
62
83
  attr_reader :line_no
63
84
  end
64
85
  class Frontmatter < Node
@@ -70,130 +91,134 @@ class NoraMark::Parser < KPeg::CompiledParser
70
91
  attr_reader :line_no
71
92
  end
72
93
  class HeadedSection < Node
73
- def initialize(level, heading, content, line_no)
94
+ def initialize(level, heading, params, named_params, raw_content, line_no)
74
95
  @level = level
75
96
  @heading = heading
76
- @content = content
97
+ @params = params
98
+ @named_params = named_params
99
+ @raw_content = raw_content
77
100
  @line_no = line_no
78
101
  end
79
102
  attr_reader :level
80
103
  attr_reader :heading
81
- attr_reader :content
104
+ attr_reader :params
105
+ attr_reader :named_params
106
+ attr_reader :raw_content
82
107
  attr_reader :line_no
83
108
  end
84
109
  class Inline < Node
85
- def initialize(name, ids, classes, parameters, named_parameters, content, line_no)
110
+ def initialize(name, ids, classes, params, named_params, raw_content, line_no)
86
111
  @name = name
87
112
  @ids = ids
88
113
  @classes = classes
89
- @parameters = parameters
90
- @named_parameters = named_parameters
91
- @content = content
114
+ @params = params
115
+ @named_params = named_params
116
+ @raw_content = raw_content
92
117
  @line_no = line_no
93
118
  end
94
119
  attr_reader :name
95
120
  attr_reader :ids
96
121
  attr_reader :classes
97
- attr_reader :parameters
98
- attr_reader :named_parameters
99
- attr_reader :content
122
+ attr_reader :params
123
+ attr_reader :named_params
124
+ attr_reader :raw_content
100
125
  attr_reader :line_no
101
126
  end
102
127
  class Newpage < Node
103
- def initialize(ids, classes, parameters, named_parameters, content, line_no)
128
+ def initialize(ids, classes, params, named_params, raw_content, line_no)
104
129
  @ids = ids
105
130
  @classes = classes
106
- @parameters = parameters
107
- @named_parameters = named_parameters
108
- @content = content
131
+ @params = params
132
+ @named_params = named_params
133
+ @raw_content = raw_content
109
134
  @line_no = line_no
110
135
  end
111
136
  attr_reader :ids
112
137
  attr_reader :classes
113
- attr_reader :parameters
114
- attr_reader :named_parameters
115
- attr_reader :content
138
+ attr_reader :params
139
+ attr_reader :named_params
140
+ attr_reader :raw_content
116
141
  attr_reader :line_no
117
142
  end
118
143
  class OlItem < Node
119
- def initialize(ids, classes, parameters, named_parameters, content, line_no)
144
+ def initialize(ids, classes, params, named_params, raw_content, line_no)
120
145
  @ids = ids
121
146
  @classes = classes
122
- @parameters = parameters
123
- @named_parameters = named_parameters
124
- @content = content
147
+ @params = params
148
+ @named_params = named_params
149
+ @raw_content = raw_content
125
150
  @line_no = line_no
126
151
  end
127
152
  attr_reader :ids
128
153
  attr_reader :classes
129
- attr_reader :parameters
130
- attr_reader :named_parameters
131
- attr_reader :content
154
+ attr_reader :params
155
+ attr_reader :named_params
156
+ attr_reader :raw_content
132
157
  attr_reader :line_no
133
158
  end
134
159
  class OrderedList < Node
135
- def initialize(ids, classes, parameters, named_parameters, content, line_no)
160
+ def initialize(ids, classes, params, named_params, raw_content, line_no)
136
161
  @ids = ids
137
162
  @classes = classes
138
- @parameters = parameters
139
- @named_parameters = named_parameters
140
- @content = content
163
+ @params = params
164
+ @named_params = named_params
165
+ @raw_content = raw_content
141
166
  @line_no = line_no
142
167
  end
143
168
  attr_reader :ids
144
169
  attr_reader :classes
145
- attr_reader :parameters
146
- attr_reader :named_parameters
147
- attr_reader :content
170
+ attr_reader :params
171
+ attr_reader :named_params
172
+ attr_reader :raw_content
148
173
  attr_reader :line_no
149
174
  end
150
175
  class Page < Node
151
- def initialize(content, line_no)
152
- @content = content
176
+ def initialize(raw_content, line_no)
177
+ @raw_content = raw_content
153
178
  @line_no = line_no
154
179
  end
155
- attr_reader :content
180
+ attr_reader :raw_content
156
181
  attr_reader :line_no
157
182
  end
158
183
  class Paragraph < Node
159
- def initialize(ids, classes, parameters, named_parameters, content, line_no)
184
+ def initialize(ids, classes, params, named_params, raw_content, line_no)
160
185
  @ids = ids
161
186
  @classes = classes
162
- @parameters = parameters
163
- @named_parameters = named_parameters
164
- @content = content
187
+ @params = params
188
+ @named_params = named_params
189
+ @raw_content = raw_content
165
190
  @line_no = line_no
166
191
  end
167
192
  attr_reader :ids
168
193
  attr_reader :classes
169
- attr_reader :parameters
170
- attr_reader :named_parameters
171
- attr_reader :content
194
+ attr_reader :params
195
+ attr_reader :named_params
196
+ attr_reader :raw_content
172
197
  attr_reader :line_no
173
198
  end
174
199
  class ParagraphGroup < Node
175
- def initialize(ids, classes, parameters, named_parameters, content, line_no)
200
+ def initialize(ids, classes, params, named_params, raw_content, line_no)
176
201
  @ids = ids
177
202
  @classes = classes
178
- @parameters = parameters
179
- @named_parameters = named_parameters
180
- @content = content
203
+ @params = params
204
+ @named_params = named_params
205
+ @raw_content = raw_content
181
206
  @line_no = line_no
182
207
  end
183
208
  attr_reader :ids
184
209
  attr_reader :classes
185
- attr_reader :parameters
186
- attr_reader :named_parameters
187
- attr_reader :content
210
+ attr_reader :params
211
+ attr_reader :named_params
212
+ attr_reader :raw_content
188
213
  attr_reader :line_no
189
214
  end
190
215
  class PreformattedBlock < Node
191
- def initialize(name, ids, classes, parameters, named_parameters, codelanguage, content, line_no)
216
+ def initialize(name, ids, classes, params, named_params, codelanguage, content, line_no)
192
217
  @name = name
193
218
  @ids = ids
194
219
  @classes = classes
195
- @parameters = parameters
196
- @named_parameters = named_parameters
220
+ @params = params
221
+ @named_params = named_params
197
222
  @codelanguage = codelanguage
198
223
  @content = content
199
224
  @line_no = line_no
@@ -201,17 +226,17 @@ class NoraMark::Parser < KPeg::CompiledParser
201
226
  attr_reader :name
202
227
  attr_reader :ids
203
228
  attr_reader :classes
204
- attr_reader :parameters
205
- attr_reader :named_parameters
229
+ attr_reader :params
230
+ attr_reader :named_params
206
231
  attr_reader :codelanguage
207
232
  attr_reader :content
208
233
  attr_reader :line_no
209
234
  end
210
235
  class Root < Node
211
- def initialize(content)
212
- @content = content
236
+ def initialize(raw_content)
237
+ @raw_content = raw_content
213
238
  end
214
- attr_reader :content
239
+ attr_reader :raw_content
215
240
  end
216
241
  class Text < Node
217
242
  def initialize(content, line_no)
@@ -222,92 +247,95 @@ class NoraMark::Parser < KPeg::CompiledParser
222
247
  attr_reader :line_no
223
248
  end
224
249
  class UlItem < Node
225
- def initialize(ids, classes, parameters, named_parameters, content, line_no)
250
+ def initialize(ids, classes, params, named_params, raw_content, line_no)
226
251
  @ids = ids
227
252
  @classes = classes
228
- @parameters = parameters
229
- @named_parameters = named_parameters
230
- @content = content
253
+ @params = params
254
+ @named_params = named_params
255
+ @raw_content = raw_content
231
256
  @line_no = line_no
232
257
  end
233
258
  attr_reader :ids
234
259
  attr_reader :classes
235
- attr_reader :parameters
236
- attr_reader :named_parameters
237
- attr_reader :content
260
+ attr_reader :params
261
+ attr_reader :named_params
262
+ attr_reader :raw_content
238
263
  attr_reader :line_no
239
264
  end
240
265
  class UnorderedList < Node
241
- def initialize(ids, classes, parameters, named_parameters, content, line_no)
266
+ def initialize(ids, classes, params, named_params, raw_content, line_no)
242
267
  @ids = ids
243
268
  @classes = classes
244
- @parameters = parameters
245
- @named_parameters = named_parameters
246
- @content = content
269
+ @params = params
270
+ @named_params = named_params
271
+ @raw_content = raw_content
247
272
  @line_no = line_no
248
273
  end
249
274
  attr_reader :ids
250
275
  attr_reader :classes
251
- attr_reader :parameters
252
- attr_reader :named_parameters
253
- attr_reader :content
276
+ attr_reader :params
277
+ attr_reader :named_params
278
+ attr_reader :raw_content
254
279
  attr_reader :line_no
255
280
  end
256
281
  end
257
282
  module ::NoraMarkConstruction
258
- def block(name, ids, classes, parameters, named_parameters, content, line_no)
259
- ::NoraMark::Block.new(name, ids, classes, parameters, named_parameters, content, line_no)
283
+ def block(name, ids, classes, params, named_params, raw_content, line_no)
284
+ ::NoraMark::Block.new(name, ids, classes, params, named_params, raw_content, line_no)
260
285
  end
261
286
  def br(line_no)
262
287
  ::NoraMark::Breakline.new(line_no)
263
288
  end
264
- def definition_list(ids, classes, parameters, named_parameters, content, line_no)
265
- ::NoraMark::DefinitionList.new(ids, classes, parameters, named_parameters, content, line_no)
289
+ def code_inline(ids, classes, params, named_params, content, line_no)
290
+ ::NoraMark::CodeInline.new(ids, classes, params, named_params, content, line_no)
291
+ end
292
+ def definition_list(ids, classes, params, named_params, raw_content, line_no)
293
+ ::NoraMark::DefinitionList.new(ids, classes, params, named_params, raw_content, line_no)
266
294
  end
267
- def dl_item(ids, classes, parameters, named_parameters, content, line_no)
268
- ::NoraMark::DLItem.new(ids, classes, parameters, named_parameters, content, line_no)
295
+ def dl_item(ids, classes, params, named_params, raw_content, line_no)
296
+ ::NoraMark::DLItem.new(ids, classes, params, named_params, raw_content, line_no)
269
297
  end
270
298
  def frontmatter(content, line_no)
271
299
  ::NoraMark::Frontmatter.new(content, line_no)
272
300
  end
273
- def h_section(level, heading, content, line_no)
274
- ::NoraMark::HeadedSection.new(level, heading, content, line_no)
301
+ def h_section(level, heading, params, named_params, raw_content, line_no)
302
+ ::NoraMark::HeadedSection.new(level, heading, params, named_params, raw_content, line_no)
275
303
  end
276
- def inline(name, ids, classes, parameters, named_parameters, content, line_no)
277
- ::NoraMark::Inline.new(name, ids, classes, parameters, named_parameters, content, line_no)
304
+ def inline(name, ids, classes, params, named_params, raw_content, line_no)
305
+ ::NoraMark::Inline.new(name, ids, classes, params, named_params, raw_content, line_no)
278
306
  end
279
- def newpage(ids, classes, parameters, named_parameters, content, line_no)
280
- ::NoraMark::Newpage.new(ids, classes, parameters, named_parameters, content, line_no)
307
+ def newpage(ids, classes, params, named_params, raw_content, line_no)
308
+ ::NoraMark::Newpage.new(ids, classes, params, named_params, raw_content, line_no)
281
309
  end
282
- def ol_item(ids, classes, parameters, named_parameters, content, line_no)
283
- ::NoraMark::OlItem.new(ids, classes, parameters, named_parameters, content, line_no)
310
+ def ol_item(ids, classes, params, named_params, raw_content, line_no)
311
+ ::NoraMark::OlItem.new(ids, classes, params, named_params, raw_content, line_no)
284
312
  end
285
- def ordered_list(ids, classes, parameters, named_parameters, content, line_no)
286
- ::NoraMark::OrderedList.new(ids, classes, parameters, named_parameters, content, line_no)
313
+ def ordered_list(ids, classes, params, named_params, raw_content, line_no)
314
+ ::NoraMark::OrderedList.new(ids, classes, params, named_params, raw_content, line_no)
287
315
  end
288
- def page(content, line_no)
289
- ::NoraMark::Page.new(content, line_no)
316
+ def page(raw_content, line_no)
317
+ ::NoraMark::Page.new(raw_content, line_no)
290
318
  end
291
- def paragraph(ids, classes, parameters, named_parameters, content, line_no)
292
- ::NoraMark::Paragraph.new(ids, classes, parameters, named_parameters, content, line_no)
319
+ def paragraph(ids, classes, params, named_params, raw_content, line_no)
320
+ ::NoraMark::Paragraph.new(ids, classes, params, named_params, raw_content, line_no)
293
321
  end
294
- def paragraph_group(ids, classes, parameters, named_parameters, content, line_no)
295
- ::NoraMark::ParagraphGroup.new(ids, classes, parameters, named_parameters, content, line_no)
322
+ def paragraph_group(ids, classes, params, named_params, raw_content, line_no)
323
+ ::NoraMark::ParagraphGroup.new(ids, classes, params, named_params, raw_content, line_no)
296
324
  end
297
- def preformatted_block(name, ids, classes, parameters, named_parameters, codelanguage, content, line_no)
298
- ::NoraMark::PreformattedBlock.new(name, ids, classes, parameters, named_parameters, codelanguage, content, line_no)
325
+ def preformatted_block(name, ids, classes, params, named_params, codelanguage, content, line_no)
326
+ ::NoraMark::PreformattedBlock.new(name, ids, classes, params, named_params, codelanguage, content, line_no)
299
327
  end
300
- def root(content)
301
- ::NoraMark::Root.new(content)
328
+ def root(raw_content)
329
+ ::NoraMark::Root.new(raw_content)
302
330
  end
303
331
  def text(content, line_no)
304
332
  ::NoraMark::Text.new(content, line_no)
305
333
  end
306
- def ul_item(ids, classes, parameters, named_parameters, content, line_no)
307
- ::NoraMark::UlItem.new(ids, classes, parameters, named_parameters, content, line_no)
334
+ def ul_item(ids, classes, params, named_params, raw_content, line_no)
335
+ ::NoraMark::UlItem.new(ids, classes, params, named_params, raw_content, line_no)
308
336
  end
309
- def unordered_list(ids, classes, parameters, named_parameters, content, line_no)
310
- ::NoraMark::UnorderedList.new(ids, classes, parameters, named_parameters, content, line_no)
337
+ def unordered_list(ids, classes, params, named_params, raw_content, line_no)
338
+ ::NoraMark::UnorderedList.new(ids, classes, params, named_params, raw_content, line_no)
311
339
  end
312
340
  end
313
341
  include ::NoraMarkConstruction
@@ -355,40 +383,47 @@ class NoraMark::Parser < KPeg::CompiledParser
355
383
  return _tmp
356
384
  end
357
385
 
358
- # EofComment = Space* "#" (!Eof .)*
386
+ # - = Space*
387
+ def __hyphen_
388
+ while true
389
+ _tmp = apply(:_Space)
390
+ break unless _tmp
391
+ end
392
+ _tmp = true
393
+ set_failed_rule :__hyphen_ unless _tmp
394
+ return _tmp
395
+ end
396
+
397
+ # EofComment = - "//" (!Eof .)*
359
398
  def _EofComment
360
399
 
361
400
  _save = self.pos
362
401
  while true # sequence
363
- while true
364
- _tmp = apply(:_Space)
365
- break unless _tmp
366
- end
367
- _tmp = true
402
+ _tmp = apply(:__hyphen_)
368
403
  unless _tmp
369
404
  self.pos = _save
370
405
  break
371
406
  end
372
- _tmp = match_string("#")
407
+ _tmp = match_string("//")
373
408
  unless _tmp
374
409
  self.pos = _save
375
410
  break
376
411
  end
377
412
  while true
378
413
 
379
- _save3 = self.pos
414
+ _save2 = self.pos
380
415
  while true # sequence
381
- _save4 = self.pos
416
+ _save3 = self.pos
382
417
  _tmp = apply(:_Eof)
383
418
  _tmp = _tmp ? nil : true
384
- self.pos = _save4
419
+ self.pos = _save3
385
420
  unless _tmp
386
- self.pos = _save3
421
+ self.pos = _save2
387
422
  break
388
423
  end
389
424
  _tmp = get_byte
390
425
  unless _tmp
391
- self.pos = _save3
426
+ self.pos = _save2
392
427
  end
393
428
  break
394
429
  end # end sequence
@@ -406,40 +441,36 @@ class NoraMark::Parser < KPeg::CompiledParser
406
441
  return _tmp
407
442
  end
408
443
 
409
- # Comment = Space* "#" (!Nl .)* Nl EmptyLine*
444
+ # Comment = - "//" (!Nl .)* Nl EmptyLine*
410
445
  def _Comment
411
446
 
412
447
  _save = self.pos
413
448
  while true # sequence
414
- while true
415
- _tmp = apply(:_Space)
416
- break unless _tmp
417
- end
418
- _tmp = true
449
+ _tmp = apply(:__hyphen_)
419
450
  unless _tmp
420
451
  self.pos = _save
421
452
  break
422
453
  end
423
- _tmp = match_string("#")
454
+ _tmp = match_string("//")
424
455
  unless _tmp
425
456
  self.pos = _save
426
457
  break
427
458
  end
428
459
  while true
429
460
 
430
- _save3 = self.pos
461
+ _save2 = self.pos
431
462
  while true # sequence
432
- _save4 = self.pos
463
+ _save3 = self.pos
433
464
  _tmp = apply(:_Nl)
434
465
  _tmp = _tmp ? nil : true
435
- self.pos = _save4
466
+ self.pos = _save3
436
467
  unless _tmp
437
- self.pos = _save3
468
+ self.pos = _save2
438
469
  break
439
470
  end
440
471
  _tmp = get_byte
441
472
  unless _tmp
442
- self.pos = _save3
473
+ self.pos = _save2
443
474
  end
444
475
  break
445
476
  end # end sequence
@@ -471,17 +502,6 @@ class NoraMark::Parser < KPeg::CompiledParser
471
502
  return _tmp
472
503
  end
473
504
 
474
- # - = Space*
475
- def __hyphen_
476
- while true
477
- _tmp = apply(:_Space)
478
- break unless _tmp
479
- end
480
- _tmp = true
481
- set_failed_rule :__hyphen_ unless _tmp
482
- return _tmp
483
- end
484
-
485
505
  # EmptyLine = /^/ - (Nl | Comment | EofComment)
486
506
  def _EmptyLine
487
507
 
@@ -547,7 +567,7 @@ class NoraMark::Parser < KPeg::CompiledParser
547
567
  return _tmp
548
568
  end
549
569
 
550
- # Word = < /[\w0-9]/ ("-" | /[\w0-9]/)* > { text }
570
+ # Word = < /[\w]/ ("-" | /[\w]/)* > { text }
551
571
  def _Word
552
572
 
553
573
  _save = self.pos
@@ -556,7 +576,7 @@ class NoraMark::Parser < KPeg::CompiledParser
556
576
 
557
577
  _save1 = self.pos
558
578
  while true # sequence
559
- _tmp = scan(/\A(?-mix:[\w0-9])/)
579
+ _tmp = scan(/\A(?-mix:[\w])/)
560
580
  unless _tmp
561
581
  self.pos = _save1
562
582
  break
@@ -568,7 +588,7 @@ class NoraMark::Parser < KPeg::CompiledParser
568
588
  _tmp = match_string("-")
569
589
  break if _tmp
570
590
  self.pos = _save3
571
- _tmp = scan(/\A(?-mix:[\w0-9])/)
591
+ _tmp = scan(/\A(?-mix:[\w])/)
572
592
  break if _tmp
573
593
  self.pos = _save3
574
594
  break
@@ -821,25 +841,18 @@ class NoraMark::Parser < KPeg::CompiledParser
821
841
  return _tmp
822
842
  end
823
843
 
824
- # ParameterNormal = < /[^,)]/* > { text }
844
+ # ParameterNormal = DocumentContentExcept(PARAMETER_END):content { content }
825
845
  def _ParameterNormal
826
846
 
827
847
  _save = self.pos
828
848
  while true # sequence
829
- _text_start = self.pos
830
- while true
831
- _tmp = scan(/\A(?-mix:[^,)])/)
832
- break unless _tmp
833
- end
834
- _tmp = true
835
- if _tmp
836
- text = get_text(_text_start)
837
- end
849
+ _tmp = apply_with_args(:_DocumentContentExcept, PARAMETER_END)
850
+ content = @result
838
851
  unless _tmp
839
852
  self.pos = _save
840
853
  break
841
854
  end
842
- @result = begin; text ; end
855
+ @result = begin; content ; end
843
856
  _tmp = true
844
857
  unless _tmp
845
858
  self.pos = _save
@@ -851,7 +864,7 @@ class NoraMark::Parser < KPeg::CompiledParser
851
864
  return _tmp
852
865
  end
853
866
 
854
- # ParameterQuoted = "\"" < /[^"]/* > "\"" - &/[,)]/ { text }
867
+ # ParameterQuoted = "\"" DocumentContentExcept('"'):content "\"" - &/[,)]/ { content }
855
868
  def _ParameterQuoted
856
869
 
857
870
  _save = self.pos
@@ -861,15 +874,8 @@ class NoraMark::Parser < KPeg::CompiledParser
861
874
  self.pos = _save
862
875
  break
863
876
  end
864
- _text_start = self.pos
865
- while true
866
- _tmp = scan(/\A(?-mix:[^"])/)
867
- break unless _tmp
868
- end
869
- _tmp = true
870
- if _tmp
871
- text = get_text(_text_start)
872
- end
877
+ _tmp = apply_with_args(:_DocumentContentExcept, '"')
878
+ content = @result
873
879
  unless _tmp
874
880
  self.pos = _save
875
881
  break
@@ -884,14 +890,14 @@ class NoraMark::Parser < KPeg::CompiledParser
884
890
  self.pos = _save
885
891
  break
886
892
  end
887
- _save2 = self.pos
893
+ _save1 = self.pos
888
894
  _tmp = scan(/\A(?-mix:[,)])/)
889
- self.pos = _save2
895
+ self.pos = _save1
890
896
  unless _tmp
891
897
  self.pos = _save
892
898
  break
893
899
  end
894
- @result = begin; text ; end
900
+ @result = begin; content ; end
895
901
  _tmp = true
896
902
  unless _tmp
897
903
  self.pos = _save
@@ -903,7 +909,7 @@ class NoraMark::Parser < KPeg::CompiledParser
903
909
  return _tmp
904
910
  end
905
911
 
906
- # ParameterSingleQuoted = "'" < /[^']/* > "'" - &/[,)]/ { text }
912
+ # ParameterSingleQuoted = "'" DocumentContentExcept("'"):content "'" - &/[,)]/ { content }
907
913
  def _ParameterSingleQuoted
908
914
 
909
915
  _save = self.pos
@@ -913,15 +919,8 @@ class NoraMark::Parser < KPeg::CompiledParser
913
919
  self.pos = _save
914
920
  break
915
921
  end
916
- _text_start = self.pos
917
- while true
918
- _tmp = scan(/\A(?-mix:[^'])/)
919
- break unless _tmp
920
- end
921
- _tmp = true
922
- if _tmp
923
- text = get_text(_text_start)
924
- end
922
+ _tmp = apply_with_args(:_DocumentContentExcept, "'")
923
+ content = @result
925
924
  unless _tmp
926
925
  self.pos = _save
927
926
  break
@@ -936,14 +935,14 @@ class NoraMark::Parser < KPeg::CompiledParser
936
935
  self.pos = _save
937
936
  break
938
937
  end
939
- _save2 = self.pos
938
+ _save1 = self.pos
940
939
  _tmp = scan(/\A(?-mix:[,)])/)
941
- self.pos = _save2
940
+ self.pos = _save1
942
941
  unless _tmp
943
942
  self.pos = _save
944
943
  break
945
944
  end
946
- @result = begin; text ; end
945
+ @result = begin; content ; end
947
946
  _tmp = true
948
947
  unless _tmp
949
948
  self.pos = _save
@@ -1447,7 +1446,7 @@ class NoraMark::Parser < KPeg::CompiledParser
1447
1446
  return _tmp
1448
1447
  end
1449
1448
 
1450
- # ImplicitParagraph = - !ParagraphDelimiter Comment* DocumentLine:content ln:ln Comment* EofComment? {paragraph([],[], [], [], content, ln)}
1449
+ # ImplicitParagraph = - !ParagraphDelimiter Comment* DocumentLine:content ln:ln Comment* EofComment? {paragraph([],[], [], {}, content, ln)}
1451
1450
  def _ImplicitParagraph
1452
1451
 
1453
1452
  _save = self.pos
@@ -1505,7 +1504,7 @@ class NoraMark::Parser < KPeg::CompiledParser
1505
1504
  self.pos = _save
1506
1505
  break
1507
1506
  end
1508
- @result = begin; paragraph([],[], [], [], content, ln); end
1507
+ @result = begin; paragraph([],[], [], {}, content, ln); end
1509
1508
  _tmp = true
1510
1509
  unless _tmp
1511
1510
  self.pos = _save
@@ -1623,7 +1622,7 @@ class NoraMark::Parser < KPeg::CompiledParser
1623
1622
  return _tmp
1624
1623
  end
1625
1624
 
1626
- # ParagraphGroup = ln:ln Paragraph+:p EmptyLine* {paragraph_group([],[],[],[],p, ln)}
1625
+ # ParagraphGroup = ln:ln Paragraph+:p EmptyLine* {paragraph_group([],[],[],{},p, ln)}
1627
1626
  def _ParagraphGroup
1628
1627
 
1629
1628
  _save = self.pos
@@ -1663,7 +1662,7 @@ class NoraMark::Parser < KPeg::CompiledParser
1663
1662
  self.pos = _save
1664
1663
  break
1665
1664
  end
1666
- @result = begin; paragraph_group([],[],[],[],p, ln); end
1665
+ @result = begin; paragraph_group([],[],[],{},p, ln); end
1667
1666
  _tmp = true
1668
1667
  unless _tmp
1669
1668
  self.pos = _save
@@ -2009,26 +2008,8 @@ class NoraMark::Parser < KPeg::CompiledParser
2009
2008
  return _tmp
2010
2009
  end
2011
2010
 
2012
- # PreformattedCommandHead = (PreformattedCommandHeadComplex | PreformattedCommandHeadSimple)
2013
- def _PreformattedCommandHead
2014
-
2015
- _save = self.pos
2016
- while true # choice
2017
- _tmp = apply(:_PreformattedCommandHeadComplex)
2018
- break if _tmp
2019
- self.pos = _save
2020
- _tmp = apply(:_PreformattedCommandHeadSimple)
2021
- break if _tmp
2022
- self.pos = _save
2023
- break
2024
- end # end choice
2025
-
2026
- set_failed_rule :_PreformattedCommandHead unless _tmp
2027
- return _tmp
2028
- end
2029
-
2030
- # PreformatEndSimple = - "}" - Le EmptyLine*
2031
- def _PreformatEndSimple
2011
+ # PreformattedFence = - "```" Word?:codelanguage ("(" - Parameters:args - ")")? ("[" - NamedParameters:named_args - "]")? - Nl { {codelanguage: codelanguage, args: args || [], named_args: named_args || {} } }
2012
+ def _PreformattedFence
2032
2013
 
2033
2014
  _save = self.pos
2034
2015
  while true # sequence
@@ -2037,47 +2018,99 @@ class NoraMark::Parser < KPeg::CompiledParser
2037
2018
  self.pos = _save
2038
2019
  break
2039
2020
  end
2040
- _tmp = match_string("}")
2021
+ _tmp = match_string("```")
2041
2022
  unless _tmp
2042
2023
  self.pos = _save
2043
2024
  break
2044
2025
  end
2045
- _tmp = apply(:__hyphen_)
2026
+ _save1 = self.pos
2027
+ _tmp = apply(:_Word)
2028
+ @result = nil unless _tmp
2046
2029
  unless _tmp
2047
- self.pos = _save
2048
- break
2030
+ _tmp = true
2031
+ self.pos = _save1
2049
2032
  end
2050
- _tmp = apply(:_Le)
2033
+ codelanguage = @result
2051
2034
  unless _tmp
2052
2035
  self.pos = _save
2053
2036
  break
2054
2037
  end
2055
- while true
2056
- _tmp = apply(:_EmptyLine)
2057
- break unless _tmp
2038
+ _save2 = self.pos
2039
+
2040
+ _save3 = self.pos
2041
+ while true # sequence
2042
+ _tmp = match_string("(")
2043
+ unless _tmp
2044
+ self.pos = _save3
2045
+ break
2046
+ end
2047
+ _tmp = apply(:__hyphen_)
2048
+ unless _tmp
2049
+ self.pos = _save3
2050
+ break
2051
+ end
2052
+ _tmp = apply(:_Parameters)
2053
+ args = @result
2054
+ unless _tmp
2055
+ self.pos = _save3
2056
+ break
2057
+ end
2058
+ _tmp = apply(:__hyphen_)
2059
+ unless _tmp
2060
+ self.pos = _save3
2061
+ break
2062
+ end
2063
+ _tmp = match_string(")")
2064
+ unless _tmp
2065
+ self.pos = _save3
2066
+ end
2067
+ break
2068
+ end # end sequence
2069
+
2070
+ unless _tmp
2071
+ _tmp = true
2072
+ self.pos = _save2
2058
2073
  end
2059
- _tmp = true
2060
2074
  unless _tmp
2061
2075
  self.pos = _save
2076
+ break
2062
2077
  end
2063
- break
2064
- end # end sequence
2065
-
2066
- set_failed_rule :_PreformatEndSimple unless _tmp
2067
- return _tmp
2068
- end
2078
+ _save4 = self.pos
2069
2079
 
2070
- # PreformatEndComplex = - "//}" - Le EmptyLine*
2071
- def _PreformatEndComplex
2080
+ _save5 = self.pos
2081
+ while true # sequence
2082
+ _tmp = match_string("[")
2083
+ unless _tmp
2084
+ self.pos = _save5
2085
+ break
2086
+ end
2087
+ _tmp = apply(:__hyphen_)
2088
+ unless _tmp
2089
+ self.pos = _save5
2090
+ break
2091
+ end
2092
+ _tmp = apply(:_NamedParameters)
2093
+ named_args = @result
2094
+ unless _tmp
2095
+ self.pos = _save5
2096
+ break
2097
+ end
2098
+ _tmp = apply(:__hyphen_)
2099
+ unless _tmp
2100
+ self.pos = _save5
2101
+ break
2102
+ end
2103
+ _tmp = match_string("]")
2104
+ unless _tmp
2105
+ self.pos = _save5
2106
+ end
2107
+ break
2108
+ end # end sequence
2072
2109
 
2073
- _save = self.pos
2074
- while true # sequence
2075
- _tmp = apply(:__hyphen_)
2076
2110
  unless _tmp
2077
- self.pos = _save
2078
- break
2111
+ _tmp = true
2112
+ self.pos = _save4
2079
2113
  end
2080
- _tmp = match_string("//}")
2081
2114
  unless _tmp
2082
2115
  self.pos = _save
2083
2116
  break
@@ -2087,15 +2120,14 @@ class NoraMark::Parser < KPeg::CompiledParser
2087
2120
  self.pos = _save
2088
2121
  break
2089
2122
  end
2090
- _tmp = apply(:_Le)
2123
+ _tmp = apply(:_Nl)
2091
2124
  unless _tmp
2092
2125
  self.pos = _save
2093
2126
  break
2094
2127
  end
2095
- while true
2096
- _tmp = apply(:_EmptyLine)
2097
- break unless _tmp
2098
- end
2128
+ @result = begin; {codelanguage: codelanguage,
2129
+ args: args || [],
2130
+ named_args: named_args || {} } ; end
2099
2131
  _tmp = true
2100
2132
  unless _tmp
2101
2133
  self.pos = _save
@@ -2103,11 +2135,112 @@ class NoraMark::Parser < KPeg::CompiledParser
2103
2135
  break
2104
2136
  end # end sequence
2105
2137
 
2106
- set_failed_rule :_PreformatEndComplex unless _tmp
2138
+ set_failed_rule :_PreformattedFence unless _tmp
2107
2139
  return _tmp
2108
2140
  end
2109
2141
 
2110
- # PreformattedBlockSimple = - PreformattedCommandHeadSimple:c (!PreformatEndSimple CharString Nl)+:content PreformatEndSimple {preformatted_block(c[:name], c[:ids], c[:classes], c[:args], c[:named_args], c[:codelanguage], content, c[:ln])}
2142
+ # PreformattedCommandHead = (PreformattedCommandHeadComplex | PreformattedCommandHeadSimple | PreformattedFence)
2143
+ def _PreformattedCommandHead
2144
+
2145
+ _save = self.pos
2146
+ while true # choice
2147
+ _tmp = apply(:_PreformattedCommandHeadComplex)
2148
+ break if _tmp
2149
+ self.pos = _save
2150
+ _tmp = apply(:_PreformattedCommandHeadSimple)
2151
+ break if _tmp
2152
+ self.pos = _save
2153
+ _tmp = apply(:_PreformattedFence)
2154
+ break if _tmp
2155
+ self.pos = _save
2156
+ break
2157
+ end # end choice
2158
+
2159
+ set_failed_rule :_PreformattedCommandHead unless _tmp
2160
+ return _tmp
2161
+ end
2162
+
2163
+ # PreformatEndSimple = - "}" - Le EmptyLine*
2164
+ def _PreformatEndSimple
2165
+
2166
+ _save = self.pos
2167
+ while true # sequence
2168
+ _tmp = apply(:__hyphen_)
2169
+ unless _tmp
2170
+ self.pos = _save
2171
+ break
2172
+ end
2173
+ _tmp = match_string("}")
2174
+ unless _tmp
2175
+ self.pos = _save
2176
+ break
2177
+ end
2178
+ _tmp = apply(:__hyphen_)
2179
+ unless _tmp
2180
+ self.pos = _save
2181
+ break
2182
+ end
2183
+ _tmp = apply(:_Le)
2184
+ unless _tmp
2185
+ self.pos = _save
2186
+ break
2187
+ end
2188
+ while true
2189
+ _tmp = apply(:_EmptyLine)
2190
+ break unless _tmp
2191
+ end
2192
+ _tmp = true
2193
+ unless _tmp
2194
+ self.pos = _save
2195
+ end
2196
+ break
2197
+ end # end sequence
2198
+
2199
+ set_failed_rule :_PreformatEndSimple unless _tmp
2200
+ return _tmp
2201
+ end
2202
+
2203
+ # PreformatEndComplex = - "//}" - Le EmptyLine*
2204
+ def _PreformatEndComplex
2205
+
2206
+ _save = self.pos
2207
+ while true # sequence
2208
+ _tmp = apply(:__hyphen_)
2209
+ unless _tmp
2210
+ self.pos = _save
2211
+ break
2212
+ end
2213
+ _tmp = match_string("//}")
2214
+ unless _tmp
2215
+ self.pos = _save
2216
+ break
2217
+ end
2218
+ _tmp = apply(:__hyphen_)
2219
+ unless _tmp
2220
+ self.pos = _save
2221
+ break
2222
+ end
2223
+ _tmp = apply(:_Le)
2224
+ unless _tmp
2225
+ self.pos = _save
2226
+ break
2227
+ end
2228
+ while true
2229
+ _tmp = apply(:_EmptyLine)
2230
+ break unless _tmp
2231
+ end
2232
+ _tmp = true
2233
+ unless _tmp
2234
+ self.pos = _save
2235
+ end
2236
+ break
2237
+ end # end sequence
2238
+
2239
+ set_failed_rule :_PreformatEndComplex unless _tmp
2240
+ return _tmp
2241
+ end
2242
+
2243
+ # PreformattedBlockSimple = - PreformattedCommandHeadSimple:c (!PreformatEndSimple CharString Nl)+:content PreformatEndSimple {preformatted_block(c[:name], c[:ids], c[:classes], c[:args], c[:named_args], c[:codelanguage], content, c[:ln])}
2111
2244
  def _PreformattedBlockSimple
2112
2245
 
2113
2246
  _save = self.pos
@@ -2301,7 +2434,134 @@ class NoraMark::Parser < KPeg::CompiledParser
2301
2434
  return _tmp
2302
2435
  end
2303
2436
 
2304
- # PreformattedBlock = (PreformattedBlockComplex | PreformattedBlockSimple)
2437
+ # PreformattedBlockFence = - ln:ln PreformattedFence:c (!"```" CharString Nl)+:content - "```" - Le EmptyLine* {preformatted_block('code', [], [], c[:args], c[:named_args], c[:codelanguage], content, ln)}
2438
+ def _PreformattedBlockFence
2439
+
2440
+ _save = self.pos
2441
+ while true # sequence
2442
+ _tmp = apply(:__hyphen_)
2443
+ unless _tmp
2444
+ self.pos = _save
2445
+ break
2446
+ end
2447
+ _tmp = apply(:_ln)
2448
+ ln = @result
2449
+ unless _tmp
2450
+ self.pos = _save
2451
+ break
2452
+ end
2453
+ _tmp = apply(:_PreformattedFence)
2454
+ c = @result
2455
+ unless _tmp
2456
+ self.pos = _save
2457
+ break
2458
+ end
2459
+ _save1 = self.pos
2460
+ _ary = []
2461
+
2462
+ _save2 = self.pos
2463
+ while true # sequence
2464
+ _save3 = self.pos
2465
+ _tmp = match_string("```")
2466
+ _tmp = _tmp ? nil : true
2467
+ self.pos = _save3
2468
+ unless _tmp
2469
+ self.pos = _save2
2470
+ break
2471
+ end
2472
+ _tmp = apply(:_CharString)
2473
+ unless _tmp
2474
+ self.pos = _save2
2475
+ break
2476
+ end
2477
+ _tmp = apply(:_Nl)
2478
+ unless _tmp
2479
+ self.pos = _save2
2480
+ end
2481
+ break
2482
+ end # end sequence
2483
+
2484
+ if _tmp
2485
+ _ary << @result
2486
+ while true
2487
+
2488
+ _save4 = self.pos
2489
+ while true # sequence
2490
+ _save5 = self.pos
2491
+ _tmp = match_string("```")
2492
+ _tmp = _tmp ? nil : true
2493
+ self.pos = _save5
2494
+ unless _tmp
2495
+ self.pos = _save4
2496
+ break
2497
+ end
2498
+ _tmp = apply(:_CharString)
2499
+ unless _tmp
2500
+ self.pos = _save4
2501
+ break
2502
+ end
2503
+ _tmp = apply(:_Nl)
2504
+ unless _tmp
2505
+ self.pos = _save4
2506
+ end
2507
+ break
2508
+ end # end sequence
2509
+
2510
+ _ary << @result if _tmp
2511
+ break unless _tmp
2512
+ end
2513
+ _tmp = true
2514
+ @result = _ary
2515
+ else
2516
+ self.pos = _save1
2517
+ end
2518
+ content = @result
2519
+ unless _tmp
2520
+ self.pos = _save
2521
+ break
2522
+ end
2523
+ _tmp = apply(:__hyphen_)
2524
+ unless _tmp
2525
+ self.pos = _save
2526
+ break
2527
+ end
2528
+ _tmp = match_string("```")
2529
+ unless _tmp
2530
+ self.pos = _save
2531
+ break
2532
+ end
2533
+ _tmp = apply(:__hyphen_)
2534
+ unless _tmp
2535
+ self.pos = _save
2536
+ break
2537
+ end
2538
+ _tmp = apply(:_Le)
2539
+ unless _tmp
2540
+ self.pos = _save
2541
+ break
2542
+ end
2543
+ while true
2544
+ _tmp = apply(:_EmptyLine)
2545
+ break unless _tmp
2546
+ end
2547
+ _tmp = true
2548
+ unless _tmp
2549
+ self.pos = _save
2550
+ break
2551
+ end
2552
+ @result = begin; preformatted_block('code', [], [], c[:args], c[:named_args], c[:codelanguage], content, ln); end
2553
+ _tmp = true
2554
+ unless _tmp
2555
+ self.pos = _save
2556
+ end
2557
+ break
2558
+ end # end sequence
2559
+
2560
+ set_failed_rule :_PreformattedBlockFence unless _tmp
2561
+ return _tmp
2562
+ end
2563
+
2564
+ # PreformattedBlock = (PreformattedBlockComplex | PreformattedBlockSimple | PreformattedBlockFence)
2305
2565
  def _PreformattedBlock
2306
2566
 
2307
2567
  _save = self.pos
@@ -2312,6 +2572,9 @@ class NoraMark::Parser < KPeg::CompiledParser
2312
2572
  _tmp = apply(:_PreformattedBlockSimple)
2313
2573
  break if _tmp
2314
2574
  self.pos = _save
2575
+ _tmp = apply(:_PreformattedBlockFence)
2576
+ break if _tmp
2577
+ self.pos = _save
2315
2578
  break
2316
2579
  end # end choice
2317
2580
 
@@ -2319,17 +2582,29 @@ class NoraMark::Parser < KPeg::CompiledParser
2319
2582
  return _tmp
2320
2583
  end
2321
2584
 
2322
- # Inline = (ImgInline | CommonInline)
2585
+ # Inline = (EscapedChar | ImgInline | MediaInline | CodeInline | CommonInline | FenceInline)
2323
2586
  def _Inline
2324
2587
 
2325
2588
  _save = self.pos
2326
2589
  while true # choice
2590
+ _tmp = apply(:_EscapedChar)
2591
+ break if _tmp
2592
+ self.pos = _save
2327
2593
  _tmp = apply(:_ImgInline)
2328
2594
  break if _tmp
2329
2595
  self.pos = _save
2596
+ _tmp = apply(:_MediaInline)
2597
+ break if _tmp
2598
+ self.pos = _save
2599
+ _tmp = apply(:_CodeInline)
2600
+ break if _tmp
2601
+ self.pos = _save
2330
2602
  _tmp = apply(:_CommonInline)
2331
2603
  break if _tmp
2332
2604
  self.pos = _save
2605
+ _tmp = apply(:_FenceInline)
2606
+ break if _tmp
2607
+ self.pos = _save
2333
2608
  break
2334
2609
  end # end choice
2335
2610
 
@@ -2436,7 +2711,253 @@ class NoraMark::Parser < KPeg::CompiledParser
2436
2711
  self.pos = _save
2437
2712
  break
2438
2713
  end
2439
- @result = begin; inline(c[:name], c[:ids], c[:classes], c[:args], c[:named_args], nil, c[:ln]); end
2714
+ @result = begin; inline(c[:name], c[:ids], c[:classes], c[:args], c[:named_args], nil, c[:ln]); end
2715
+ _tmp = true
2716
+ unless _tmp
2717
+ self.pos = _save
2718
+ end
2719
+ break
2720
+ end # end sequence
2721
+
2722
+ set_failed_rule :_ImgInline unless _tmp
2723
+ return _tmp
2724
+ end
2725
+
2726
+ # MediaCommand = Command:c &{ (c[:name] == 'video' || c[:name] == 'audio') && c[:args].size > 0}
2727
+ def _MediaCommand
2728
+
2729
+ _save = self.pos
2730
+ while true # sequence
2731
+ _tmp = apply(:_Command)
2732
+ c = @result
2733
+ unless _tmp
2734
+ self.pos = _save
2735
+ break
2736
+ end
2737
+ _save1 = self.pos
2738
+ _tmp = begin; (c[:name] == 'video' || c[:name] == 'audio') && c[:args].size > 0; end
2739
+ self.pos = _save1
2740
+ unless _tmp
2741
+ self.pos = _save
2742
+ end
2743
+ break
2744
+ end # end sequence
2745
+
2746
+ set_failed_rule :_MediaCommand unless _tmp
2747
+ return _tmp
2748
+ end
2749
+
2750
+ # MediaInline = "[" MediaCommand:c ("{" - DocumentContentExcept('}'):content "}")? "]" {inline(c[:name], c[:ids], c[:classes], c[:args], c[:named_args], content, c[:ln])}
2751
+ def _MediaInline
2752
+
2753
+ _save = self.pos
2754
+ while true # sequence
2755
+ _tmp = match_string("[")
2756
+ unless _tmp
2757
+ self.pos = _save
2758
+ break
2759
+ end
2760
+ _tmp = apply(:_MediaCommand)
2761
+ c = @result
2762
+ unless _tmp
2763
+ self.pos = _save
2764
+ break
2765
+ end
2766
+ _save1 = self.pos
2767
+
2768
+ _save2 = self.pos
2769
+ while true # sequence
2770
+ _tmp = match_string("{")
2771
+ unless _tmp
2772
+ self.pos = _save2
2773
+ break
2774
+ end
2775
+ _tmp = apply(:__hyphen_)
2776
+ unless _tmp
2777
+ self.pos = _save2
2778
+ break
2779
+ end
2780
+ _tmp = apply_with_args(:_DocumentContentExcept, '}')
2781
+ content = @result
2782
+ unless _tmp
2783
+ self.pos = _save2
2784
+ break
2785
+ end
2786
+ _tmp = match_string("}")
2787
+ unless _tmp
2788
+ self.pos = _save2
2789
+ end
2790
+ break
2791
+ end # end sequence
2792
+
2793
+ unless _tmp
2794
+ _tmp = true
2795
+ self.pos = _save1
2796
+ end
2797
+ unless _tmp
2798
+ self.pos = _save
2799
+ break
2800
+ end
2801
+ _tmp = match_string("]")
2802
+ unless _tmp
2803
+ self.pos = _save
2804
+ break
2805
+ end
2806
+ @result = begin; inline(c[:name], c[:ids], c[:classes], c[:args], c[:named_args], content, c[:ln]); end
2807
+ _tmp = true
2808
+ unless _tmp
2809
+ self.pos = _save
2810
+ end
2811
+ break
2812
+ end # end sequence
2813
+
2814
+ set_failed_rule :_MediaInline unless _tmp
2815
+ return _tmp
2816
+ end
2817
+
2818
+ # FenceInline = "`" ln:ln CharStringExcept('`'):content "`" {code_inline([], [], [], {}, content, ln)}
2819
+ def _FenceInline
2820
+
2821
+ _save = self.pos
2822
+ while true # sequence
2823
+ _tmp = match_string("`")
2824
+ unless _tmp
2825
+ self.pos = _save
2826
+ break
2827
+ end
2828
+ _tmp = apply(:_ln)
2829
+ ln = @result
2830
+ unless _tmp
2831
+ self.pos = _save
2832
+ break
2833
+ end
2834
+ _tmp = apply_with_args(:_CharStringExcept, '`')
2835
+ content = @result
2836
+ unless _tmp
2837
+ self.pos = _save
2838
+ break
2839
+ end
2840
+ _tmp = match_string("`")
2841
+ unless _tmp
2842
+ self.pos = _save
2843
+ break
2844
+ end
2845
+ @result = begin; code_inline([], [], [], {}, content, ln); end
2846
+ _tmp = true
2847
+ unless _tmp
2848
+ self.pos = _save
2849
+ end
2850
+ break
2851
+ end # end sequence
2852
+
2853
+ set_failed_rule :_FenceInline unless _tmp
2854
+ return _tmp
2855
+ end
2856
+
2857
+ # CodeCommand = Command:c &{ c[:name] == 'code' }
2858
+ def _CodeCommand
2859
+
2860
+ _save = self.pos
2861
+ while true # sequence
2862
+ _tmp = apply(:_Command)
2863
+ c = @result
2864
+ unless _tmp
2865
+ self.pos = _save
2866
+ break
2867
+ end
2868
+ _save1 = self.pos
2869
+ _tmp = begin; c[:name] == 'code' ; end
2870
+ self.pos = _save1
2871
+ unless _tmp
2872
+ self.pos = _save
2873
+ end
2874
+ break
2875
+ end # end sequence
2876
+
2877
+ set_failed_rule :_CodeCommand unless _tmp
2878
+ return _tmp
2879
+ end
2880
+
2881
+ # CodeInline = "[" CodeCommand:c "{" - CharStringExcept('}'):content "}" "]" {code_inline(c[:ids], c[:classes], c[:args], c[:named_args], content, c[:ln])}
2882
+ def _CodeInline
2883
+
2884
+ _save = self.pos
2885
+ while true # sequence
2886
+ _tmp = match_string("[")
2887
+ unless _tmp
2888
+ self.pos = _save
2889
+ break
2890
+ end
2891
+ _tmp = apply(:_CodeCommand)
2892
+ c = @result
2893
+ unless _tmp
2894
+ self.pos = _save
2895
+ break
2896
+ end
2897
+ _tmp = match_string("{")
2898
+ unless _tmp
2899
+ self.pos = _save
2900
+ break
2901
+ end
2902
+ _tmp = apply(:__hyphen_)
2903
+ unless _tmp
2904
+ self.pos = _save
2905
+ break
2906
+ end
2907
+ _tmp = apply_with_args(:_CharStringExcept, '}')
2908
+ content = @result
2909
+ unless _tmp
2910
+ self.pos = _save
2911
+ break
2912
+ end
2913
+ _tmp = match_string("}")
2914
+ unless _tmp
2915
+ self.pos = _save
2916
+ break
2917
+ end
2918
+ _tmp = match_string("]")
2919
+ unless _tmp
2920
+ self.pos = _save
2921
+ break
2922
+ end
2923
+ @result = begin; code_inline(c[:ids], c[:classes], c[:args], c[:named_args], content, c[:ln]); end
2924
+ _tmp = true
2925
+ unless _tmp
2926
+ self.pos = _save
2927
+ end
2928
+ break
2929
+ end # end sequence
2930
+
2931
+ set_failed_rule :_CodeInline unless _tmp
2932
+ return _tmp
2933
+ end
2934
+
2935
+ # EscapedChar = "\\" < /[`]/ > ln:ln {text(text, ln)}
2936
+ def _EscapedChar
2937
+
2938
+ _save = self.pos
2939
+ while true # sequence
2940
+ _tmp = match_string("\\")
2941
+ unless _tmp
2942
+ self.pos = _save
2943
+ break
2944
+ end
2945
+ _text_start = self.pos
2946
+ _tmp = scan(/\A(?-mix:[`])/)
2947
+ if _tmp
2948
+ text = get_text(_text_start)
2949
+ end
2950
+ unless _tmp
2951
+ self.pos = _save
2952
+ break
2953
+ end
2954
+ _tmp = apply(:_ln)
2955
+ ln = @result
2956
+ unless _tmp
2957
+ self.pos = _save
2958
+ break
2959
+ end
2960
+ @result = begin; text(text, ln); end
2440
2961
  _tmp = true
2441
2962
  unless _tmp
2442
2963
  self.pos = _save
@@ -2444,7 +2965,7 @@ class NoraMark::Parser < KPeg::CompiledParser
2444
2965
  break
2445
2966
  end # end sequence
2446
2967
 
2447
- set_failed_rule :_ImgInline unless _tmp
2968
+ set_failed_rule :_EscapedChar unless _tmp
2448
2969
  return _tmp
2449
2970
  end
2450
2971
 
@@ -2550,8 +3071,45 @@ class NoraMark::Parser < KPeg::CompiledParser
2550
3071
  return _tmp
2551
3072
  end
2552
3073
 
2553
- # UnorderedList = ln:ln UnorderedItem+:items {unordered_list([],[],[],[], items, ln)}
2554
- def _UnorderedList
3074
+ # UnorderedStart = /^/ - < /\*+/ > &{ text.length == n && text.size < 5 }
3075
+ def _UnorderedStart(n)
3076
+
3077
+ _save = self.pos
3078
+ while true # sequence
3079
+ _tmp = scan(/\A(?-mix:^)/)
3080
+ unless _tmp
3081
+ self.pos = _save
3082
+ break
3083
+ end
3084
+ _tmp = apply(:__hyphen_)
3085
+ unless _tmp
3086
+ self.pos = _save
3087
+ break
3088
+ end
3089
+ _text_start = self.pos
3090
+ _tmp = scan(/\A(?-mix:\*+)/)
3091
+ if _tmp
3092
+ text = get_text(_text_start)
3093
+ end
3094
+ unless _tmp
3095
+ self.pos = _save
3096
+ break
3097
+ end
3098
+ _save1 = self.pos
3099
+ _tmp = begin; text.length == n && text.size < 5 ; end
3100
+ self.pos = _save1
3101
+ unless _tmp
3102
+ self.pos = _save
3103
+ end
3104
+ break
3105
+ end # end sequence
3106
+
3107
+ set_failed_rule :_UnorderedStart unless _tmp
3108
+ return _tmp
3109
+ end
3110
+
3111
+ # UnorderedList = ln:ln UnorderedItem(n)+:items {unordered_list([],[],[],{}, items, ln)}
3112
+ def _UnorderedList(n)
2555
3113
 
2556
3114
  _save = self.pos
2557
3115
  while true # sequence
@@ -2563,11 +3121,11 @@ class NoraMark::Parser < KPeg::CompiledParser
2563
3121
  end
2564
3122
  _save1 = self.pos
2565
3123
  _ary = []
2566
- _tmp = apply(:_UnorderedItem)
3124
+ _tmp = apply_with_args(:_UnorderedItem, n)
2567
3125
  if _tmp
2568
3126
  _ary << @result
2569
3127
  while true
2570
- _tmp = apply(:_UnorderedItem)
3128
+ _tmp = apply_with_args(:_UnorderedItem, n)
2571
3129
  _ary << @result if _tmp
2572
3130
  break unless _tmp
2573
3131
  end
@@ -2581,7 +3139,7 @@ class NoraMark::Parser < KPeg::CompiledParser
2581
3139
  self.pos = _save
2582
3140
  break
2583
3141
  end
2584
- @result = begin; unordered_list([],[],[],[], items, ln); end
3142
+ @result = begin; unordered_list([],[],[],{}, items, ln); end
2585
3143
  _tmp = true
2586
3144
  unless _tmp
2587
3145
  self.pos = _save
@@ -2593,18 +3151,18 @@ class NoraMark::Parser < KPeg::CompiledParser
2593
3151
  return _tmp
2594
3152
  end
2595
3153
 
2596
- # UnorderedItem = ln:ln "*:" - DocumentContent:content Le {ul_item([], [], [], [], content, ln)}
2597
- def _UnorderedItem
3154
+ # UnorderedItem = UnorderedStart(n) ln:ln - UnorderedItemBody(n):content {ul_item([], [], [], {}, content, ln)}
3155
+ def _UnorderedItem(n)
2598
3156
 
2599
3157
  _save = self.pos
2600
3158
  while true # sequence
2601
- _tmp = apply(:_ln)
2602
- ln = @result
3159
+ _tmp = apply_with_args(:_UnorderedStart, n)
2603
3160
  unless _tmp
2604
3161
  self.pos = _save
2605
3162
  break
2606
3163
  end
2607
- _tmp = match_string("*:")
3164
+ _tmp = apply(:_ln)
3165
+ ln = @result
2608
3166
  unless _tmp
2609
3167
  self.pos = _save
2610
3168
  break
@@ -2614,18 +3172,13 @@ class NoraMark::Parser < KPeg::CompiledParser
2614
3172
  self.pos = _save
2615
3173
  break
2616
3174
  end
2617
- _tmp = apply(:_DocumentContent)
3175
+ _tmp = apply_with_args(:_UnorderedItemBody, n)
2618
3176
  content = @result
2619
3177
  unless _tmp
2620
3178
  self.pos = _save
2621
3179
  break
2622
3180
  end
2623
- _tmp = apply(:_Le)
2624
- unless _tmp
2625
- self.pos = _save
2626
- break
2627
- end
2628
- @result = begin; ul_item([], [], [], [], content, ln); end
3181
+ @result = begin; ul_item([], [], [], {}, content, ln); end
2629
3182
  _tmp = true
2630
3183
  unless _tmp
2631
3184
  self.pos = _save
@@ -2637,7 +3190,91 @@ class NoraMark::Parser < KPeg::CompiledParser
2637
3190
  return _tmp
2638
3191
  end
2639
3192
 
2640
- # OrderedList = ln:ln OrderedItem+:items {ordered_list([],[],[], [], items, ln)}
3193
+ # UnorderedItemBody = (DocumentContent:content Nl - &UnorderedStart(n + 1) ln:ln UnorderedList(n + 1):sub_ul { content << sub_ul } | DocumentContent:content Le { content })
3194
+ def _UnorderedItemBody(n)
3195
+
3196
+ _save = self.pos
3197
+ while true # choice
3198
+
3199
+ _save1 = self.pos
3200
+ while true # sequence
3201
+ _tmp = apply(:_DocumentContent)
3202
+ content = @result
3203
+ unless _tmp
3204
+ self.pos = _save1
3205
+ break
3206
+ end
3207
+ _tmp = apply(:_Nl)
3208
+ unless _tmp
3209
+ self.pos = _save1
3210
+ break
3211
+ end
3212
+ _tmp = apply(:__hyphen_)
3213
+ unless _tmp
3214
+ self.pos = _save1
3215
+ break
3216
+ end
3217
+ _save2 = self.pos
3218
+ _tmp = apply_with_args(:_UnorderedStart, n + 1)
3219
+ self.pos = _save2
3220
+ unless _tmp
3221
+ self.pos = _save1
3222
+ break
3223
+ end
3224
+ _tmp = apply(:_ln)
3225
+ ln = @result
3226
+ unless _tmp
3227
+ self.pos = _save1
3228
+ break
3229
+ end
3230
+ _tmp = apply_with_args(:_UnorderedList, n + 1)
3231
+ sub_ul = @result
3232
+ unless _tmp
3233
+ self.pos = _save1
3234
+ break
3235
+ end
3236
+ @result = begin; content << sub_ul ; end
3237
+ _tmp = true
3238
+ unless _tmp
3239
+ self.pos = _save1
3240
+ end
3241
+ break
3242
+ end # end sequence
3243
+
3244
+ break if _tmp
3245
+ self.pos = _save
3246
+
3247
+ _save3 = self.pos
3248
+ while true # sequence
3249
+ _tmp = apply(:_DocumentContent)
3250
+ content = @result
3251
+ unless _tmp
3252
+ self.pos = _save3
3253
+ break
3254
+ end
3255
+ _tmp = apply(:_Le)
3256
+ unless _tmp
3257
+ self.pos = _save3
3258
+ break
3259
+ end
3260
+ @result = begin; content ; end
3261
+ _tmp = true
3262
+ unless _tmp
3263
+ self.pos = _save3
3264
+ end
3265
+ break
3266
+ end # end sequence
3267
+
3268
+ break if _tmp
3269
+ self.pos = _save
3270
+ break
3271
+ end # end choice
3272
+
3273
+ set_failed_rule :_UnorderedItemBody unless _tmp
3274
+ return _tmp
3275
+ end
3276
+
3277
+ # OrderedList = ln:ln OrderedItem+:items {ordered_list([],[],[], {}, items, ln)}
2641
3278
  def _OrderedList
2642
3279
 
2643
3280
  _save = self.pos
@@ -2668,7 +3305,7 @@ class NoraMark::Parser < KPeg::CompiledParser
2668
3305
  self.pos = _save
2669
3306
  break
2670
3307
  end
2671
- @result = begin; ordered_list([],[],[], [], items, ln); end
3308
+ @result = begin; ordered_list([],[],[], {}, items, ln); end
2672
3309
  _tmp = true
2673
3310
  unless _tmp
2674
3311
  self.pos = _save
@@ -2680,11 +3317,16 @@ class NoraMark::Parser < KPeg::CompiledParser
2680
3317
  return _tmp
2681
3318
  end
2682
3319
 
2683
- # OrderedItem = ln:ln Num ":" - DocumentContent:content Le {ol_item([], [], [], [], content, ln)}
3320
+ # OrderedItem = - ln:ln Num "." - DocumentContent:content Le {ol_item([], [], [], {}, content, ln)}
2684
3321
  def _OrderedItem
2685
3322
 
2686
3323
  _save = self.pos
2687
3324
  while true # sequence
3325
+ _tmp = apply(:__hyphen_)
3326
+ unless _tmp
3327
+ self.pos = _save
3328
+ break
3329
+ end
2688
3330
  _tmp = apply(:_ln)
2689
3331
  ln = @result
2690
3332
  unless _tmp
@@ -2696,7 +3338,7 @@ class NoraMark::Parser < KPeg::CompiledParser
2696
3338
  self.pos = _save
2697
3339
  break
2698
3340
  end
2699
- _tmp = match_string(":")
3341
+ _tmp = match_string(".")
2700
3342
  unless _tmp
2701
3343
  self.pos = _save
2702
3344
  break
@@ -2717,7 +3359,7 @@ class NoraMark::Parser < KPeg::CompiledParser
2717
3359
  self.pos = _save
2718
3360
  break
2719
3361
  end
2720
- @result = begin; ol_item([], [], [], [], content, ln); end
3362
+ @result = begin; ol_item([], [], [], {}, content, ln); end
2721
3363
  _tmp = true
2722
3364
  unless _tmp
2723
3365
  self.pos = _save
@@ -2729,7 +3371,7 @@ class NoraMark::Parser < KPeg::CompiledParser
2729
3371
  return _tmp
2730
3372
  end
2731
3373
 
2732
- # DefinitionList = ln:ln DefinitionItem+:items {definition_list([], [], [], [], items, ln)}
3374
+ # DefinitionList = ln:ln DefinitionItem+:items {definition_list([], [], [], {}, items, ln)}
2733
3375
  def _DefinitionList
2734
3376
 
2735
3377
  _save = self.pos
@@ -2760,7 +3402,7 @@ class NoraMark::Parser < KPeg::CompiledParser
2760
3402
  self.pos = _save
2761
3403
  break
2762
3404
  end
2763
- @result = begin; definition_list([], [], [], [], items, ln); end
3405
+ @result = begin; definition_list([], [], [], {}, items, ln); end
2764
3406
  _tmp = true
2765
3407
  unless _tmp
2766
3408
  self.pos = _save
@@ -2772,7 +3414,7 @@ class NoraMark::Parser < KPeg::CompiledParser
2772
3414
  return _tmp
2773
3415
  end
2774
3416
 
2775
- # DefinitionItem = - ln:ln ";:" - DocumentContentExcept(':'):term ":" - DocumentContent:definition Le {dl_item([], [], [term], [], definition, ln)}
3417
+ # DefinitionItem = - ln:ln - ";:" - DocumentContentExcept(':'):term ":" - DocumentContent:definition Le {dl_item([], [], [term], {}, definition, ln)}
2776
3418
  def _DefinitionItem
2777
3419
 
2778
3420
  _save = self.pos
@@ -2788,6 +3430,11 @@ class NoraMark::Parser < KPeg::CompiledParser
2788
3430
  self.pos = _save
2789
3431
  break
2790
3432
  end
3433
+ _tmp = apply(:__hyphen_)
3434
+ unless _tmp
3435
+ self.pos = _save
3436
+ break
3437
+ end
2791
3438
  _tmp = match_string(";:")
2792
3439
  unless _tmp
2793
3440
  self.pos = _save
@@ -2825,7 +3472,7 @@ class NoraMark::Parser < KPeg::CompiledParser
2825
3472
  self.pos = _save
2826
3473
  break
2827
3474
  end
2828
- @result = begin; dl_item([], [], [term], [], definition, ln); end
3475
+ @result = begin; dl_item([], [], [term], {}, definition, ln); end
2829
3476
  _tmp = true
2830
3477
  unless _tmp
2831
3478
  self.pos = _save
@@ -2837,7 +3484,7 @@ class NoraMark::Parser < KPeg::CompiledParser
2837
3484
  return _tmp
2838
3485
  end
2839
3486
 
2840
- # LongDefinitionList = ln:ln LongDefinitionItem+:items {definition_list([], [], [], [], items, ln)}
3487
+ # LongDefinitionList = ln:ln LongDefinitionItem+:items {definition_list([], [], [], {}, items, ln)}
2841
3488
  def _LongDefinitionList
2842
3489
 
2843
3490
  _save = self.pos
@@ -2868,7 +3515,7 @@ class NoraMark::Parser < KPeg::CompiledParser
2868
3515
  self.pos = _save
2869
3516
  break
2870
3517
  end
2871
- @result = begin; definition_list([], [], [], [], items, ln); end
3518
+ @result = begin; definition_list([], [], [], {}, items, ln); end
2872
3519
  _tmp = true
2873
3520
  unless _tmp
2874
3521
  self.pos = _save
@@ -2880,7 +3527,7 @@ class NoraMark::Parser < KPeg::CompiledParser
2880
3527
  return _tmp
2881
3528
  end
2882
3529
 
2883
- # LongDefinitionItem = - ln:ln ";:" - DocumentContentExcept('{'):term "{" - Nl - BlockBody:definition - BlockEnd {dl_item([], [], [term], [], definition, ln)}
3530
+ # LongDefinitionItem = - ln:ln ";:" - DocumentContentExcept('{'):term "{" - Nl - BlockBody:definition - BlockEnd {dl_item([], [], [term], {}, definition, ln)}
2884
3531
  def _LongDefinitionItem
2885
3532
 
2886
3533
  _save = self.pos
@@ -2948,7 +3595,7 @@ class NoraMark::Parser < KPeg::CompiledParser
2948
3595
  self.pos = _save
2949
3596
  break
2950
3597
  end
2951
- @result = begin; dl_item([], [], [term], [], definition, ln); end
3598
+ @result = begin; dl_item([], [], [term], {}, definition, ln); end
2952
3599
  _tmp = true
2953
3600
  unless _tmp
2954
3601
  self.pos = _save
@@ -2960,12 +3607,12 @@ class NoraMark::Parser < KPeg::CompiledParser
2960
3607
  return _tmp
2961
3608
  end
2962
3609
 
2963
- # ItemsList = (UnorderedList | OrderedList | DefinitionList | LongDefinitionList)
3610
+ # ItemsList = (UnorderedList(1) | OrderedList | DefinitionList | LongDefinitionList)
2964
3611
  def _ItemsList
2965
3612
 
2966
3613
  _save = self.pos
2967
3614
  while true # choice
2968
- _tmp = apply(:_UnorderedList)
3615
+ _tmp = apply_with_args(:_UnorderedList, 1)
2969
3616
  break if _tmp
2970
3617
  self.pos = _save
2971
3618
  _tmp = apply(:_OrderedList)
@@ -3176,37 +3823,28 @@ class NoraMark::Parser < KPeg::CompiledParser
3176
3823
  return _tmp
3177
3824
  end
3178
3825
 
3179
- # HStartMark = < "="+ ":" > &{ text.length - 1 == n }
3826
+ # HStartMark = - < "#"+ > &{ text.length == n }
3180
3827
  def _HStartMark(n)
3181
3828
 
3182
3829
  _save = self.pos
3183
3830
  while true # sequence
3831
+ _tmp = apply(:__hyphen_)
3832
+ unless _tmp
3833
+ self.pos = _save
3834
+ break
3835
+ end
3184
3836
  _text_start = self.pos
3185
-
3186
3837
  _save1 = self.pos
3187
- while true # sequence
3188
- _save2 = self.pos
3189
- _tmp = match_string("=")
3190
- if _tmp
3191
- while true
3192
- _tmp = match_string("=")
3193
- break unless _tmp
3194
- end
3195
- _tmp = true
3196
- else
3197
- self.pos = _save2
3198
- end
3199
- unless _tmp
3200
- self.pos = _save1
3201
- break
3202
- end
3203
- _tmp = match_string(":")
3204
- unless _tmp
3205
- self.pos = _save1
3838
+ _tmp = match_string("#")
3839
+ if _tmp
3840
+ while true
3841
+ _tmp = match_string("#")
3842
+ break unless _tmp
3206
3843
  end
3207
- break
3208
- end # end sequence
3209
-
3844
+ _tmp = true
3845
+ else
3846
+ self.pos = _save1
3847
+ end
3210
3848
  if _tmp
3211
3849
  text = get_text(_text_start)
3212
3850
  end
@@ -3214,9 +3852,9 @@ class NoraMark::Parser < KPeg::CompiledParser
3214
3852
  self.pos = _save
3215
3853
  break
3216
3854
  end
3217
- _save3 = self.pos
3218
- _tmp = begin; text.length - 1 == n ; end
3219
- self.pos = _save3
3855
+ _save2 = self.pos
3856
+ _tmp = begin; text.length == n ; end
3857
+ self.pos = _save2
3220
3858
  unless _tmp
3221
3859
  self.pos = _save
3222
3860
  end
@@ -3227,7 +3865,7 @@ class NoraMark::Parser < KPeg::CompiledParser
3227
3865
  return _tmp
3228
3866
  end
3229
3867
 
3230
- # HMarkupTerminator = (- < "="+ ":" > &{ text.length - 1 <= n } | - Eof)
3868
+ # HMarkupTerminator = (- < "#"+ > - CharString:cs Le &{ text.length <= n && !cs.strip.end_with?('{') } | - Eof)
3231
3869
  def _HMarkupTerminator(n)
3232
3870
 
3233
3871
  _save = self.pos
@@ -3241,74 +3879,183 @@ class NoraMark::Parser < KPeg::CompiledParser
3241
3879
  break
3242
3880
  end
3243
3881
  _text_start = self.pos
3244
-
3245
3882
  _save2 = self.pos
3246
- while true # sequence
3247
- _save3 = self.pos
3248
- _tmp = match_string("=")
3249
- if _tmp
3250
- while true
3251
- _tmp = match_string("=")
3252
- break unless _tmp
3253
- end
3254
- _tmp = true
3255
- else
3256
- self.pos = _save3
3257
- end
3258
- unless _tmp
3259
- self.pos = _save2
3260
- break
3261
- end
3262
- _tmp = match_string(":")
3263
- unless _tmp
3264
- self.pos = _save2
3883
+ _tmp = match_string("#")
3884
+ if _tmp
3885
+ while true
3886
+ _tmp = match_string("#")
3887
+ break unless _tmp
3265
3888
  end
3889
+ _tmp = true
3890
+ else
3891
+ self.pos = _save2
3892
+ end
3893
+ if _tmp
3894
+ text = get_text(_text_start)
3895
+ end
3896
+ unless _tmp
3897
+ self.pos = _save1
3898
+ break
3899
+ end
3900
+ _tmp = apply(:__hyphen_)
3901
+ unless _tmp
3902
+ self.pos = _save1
3903
+ break
3904
+ end
3905
+ _tmp = apply(:_CharString)
3906
+ cs = @result
3907
+ unless _tmp
3908
+ self.pos = _save1
3909
+ break
3910
+ end
3911
+ _tmp = apply(:_Le)
3912
+ unless _tmp
3913
+ self.pos = _save1
3914
+ break
3915
+ end
3916
+ _save3 = self.pos
3917
+ _tmp = begin; text.length <= n && !cs.strip.end_with?('{') ; end
3918
+ self.pos = _save3
3919
+ unless _tmp
3920
+ self.pos = _save1
3921
+ end
3922
+ break
3923
+ end # end sequence
3924
+
3925
+ break if _tmp
3926
+ self.pos = _save
3927
+
3928
+ _save4 = self.pos
3929
+ while true # sequence
3930
+ _tmp = apply(:__hyphen_)
3931
+ unless _tmp
3932
+ self.pos = _save4
3933
+ break
3934
+ end
3935
+ _tmp = apply(:_Eof)
3936
+ unless _tmp
3937
+ self.pos = _save4
3938
+ end
3939
+ break
3940
+ end # end sequence
3941
+
3942
+ break if _tmp
3943
+ self.pos = _save
3944
+ break
3945
+ end # end choice
3946
+
3947
+ set_failed_rule :_HMarkupTerminator unless _tmp
3948
+ return _tmp
3949
+ end
3950
+
3951
+ # HStartCommand = - HStartMark(n) ("(" - Parameters:args - ")")? ("[" - NamedParameters:named_args - "]")? { { args: args || [] , named_args: named_args || {}} }
3952
+ def _HStartCommand(n)
3953
+
3954
+ _save = self.pos
3955
+ while true # sequence
3956
+ _tmp = apply(:__hyphen_)
3957
+ unless _tmp
3958
+ self.pos = _save
3959
+ break
3960
+ end
3961
+ _tmp = apply_with_args(:_HStartMark, n)
3962
+ unless _tmp
3963
+ self.pos = _save
3964
+ break
3965
+ end
3966
+ _save1 = self.pos
3967
+
3968
+ _save2 = self.pos
3969
+ while true # sequence
3970
+ _tmp = match_string("(")
3971
+ unless _tmp
3972
+ self.pos = _save2
3973
+ break
3974
+ end
3975
+ _tmp = apply(:__hyphen_)
3976
+ unless _tmp
3977
+ self.pos = _save2
3266
3978
  break
3267
- end # end sequence
3268
-
3269
- if _tmp
3270
- text = get_text(_text_start)
3271
3979
  end
3980
+ _tmp = apply(:_Parameters)
3981
+ args = @result
3272
3982
  unless _tmp
3273
- self.pos = _save1
3983
+ self.pos = _save2
3274
3984
  break
3275
3985
  end
3276
- _save4 = self.pos
3277
- _tmp = begin; text.length - 1 <= n ; end
3278
- self.pos = _save4
3986
+ _tmp = apply(:__hyphen_)
3279
3987
  unless _tmp
3280
- self.pos = _save1
3988
+ self.pos = _save2
3989
+ break
3990
+ end
3991
+ _tmp = match_string(")")
3992
+ unless _tmp
3993
+ self.pos = _save2
3281
3994
  end
3282
3995
  break
3283
3996
  end # end sequence
3284
3997
 
3285
- break if _tmp
3286
- self.pos = _save
3998
+ unless _tmp
3999
+ _tmp = true
4000
+ self.pos = _save1
4001
+ end
4002
+ unless _tmp
4003
+ self.pos = _save
4004
+ break
4005
+ end
4006
+ _save3 = self.pos
3287
4007
 
3288
- _save5 = self.pos
4008
+ _save4 = self.pos
3289
4009
  while true # sequence
4010
+ _tmp = match_string("[")
4011
+ unless _tmp
4012
+ self.pos = _save4
4013
+ break
4014
+ end
3290
4015
  _tmp = apply(:__hyphen_)
3291
4016
  unless _tmp
3292
- self.pos = _save5
4017
+ self.pos = _save4
3293
4018
  break
3294
4019
  end
3295
- _tmp = apply(:_Eof)
4020
+ _tmp = apply(:_NamedParameters)
4021
+ named_args = @result
3296
4022
  unless _tmp
3297
- self.pos = _save5
4023
+ self.pos = _save4
4024
+ break
4025
+ end
4026
+ _tmp = apply(:__hyphen_)
4027
+ unless _tmp
4028
+ self.pos = _save4
4029
+ break
4030
+ end
4031
+ _tmp = match_string("]")
4032
+ unless _tmp
4033
+ self.pos = _save4
3298
4034
  end
3299
4035
  break
3300
4036
  end # end sequence
3301
4037
 
3302
- break if _tmp
3303
- self.pos = _save
4038
+ unless _tmp
4039
+ _tmp = true
4040
+ self.pos = _save3
4041
+ end
4042
+ unless _tmp
4043
+ self.pos = _save
4044
+ break
4045
+ end
4046
+ @result = begin; { args: args || [] , named_args: named_args || {}} ; end
4047
+ _tmp = true
4048
+ unless _tmp
4049
+ self.pos = _save
4050
+ end
3304
4051
  break
3305
- end # end choice
4052
+ end # end sequence
3306
4053
 
3307
- set_failed_rule :_HMarkupTerminator unless _tmp
4054
+ set_failed_rule :_HStartCommand unless _tmp
3308
4055
  return _tmp
3309
4056
  end
3310
4057
 
3311
- # HStart = - HStartMark(n) ln:ln - DocumentContent:s Le { { level: n, heading: s, ln: ln} }
4058
+ # HStart = - HStartCommand(n):hsc ln:ln - DocumentContent:s Le { hsc.merge({ level: n, heading: s, ln: ln}) }
3312
4059
  def _HStart(n)
3313
4060
 
3314
4061
  _save = self.pos
@@ -3318,7 +4065,8 @@ class NoraMark::Parser < KPeg::CompiledParser
3318
4065
  self.pos = _save
3319
4066
  break
3320
4067
  end
3321
- _tmp = apply_with_args(:_HStartMark, n)
4068
+ _tmp = apply_with_args(:_HStartCommand, n)
4069
+ hsc = @result
3322
4070
  unless _tmp
3323
4071
  self.pos = _save
3324
4072
  break
@@ -3345,7 +4093,7 @@ class NoraMark::Parser < KPeg::CompiledParser
3345
4093
  self.pos = _save
3346
4094
  break
3347
4095
  end
3348
- @result = begin; { level: n, heading: s, ln: ln} ; end
4096
+ @result = begin; hsc.merge({ level: n, heading: s, ln: ln}) ; end
3349
4097
  _tmp = true
3350
4098
  unless _tmp
3351
4099
  self.pos = _save
@@ -3357,7 +4105,7 @@ class NoraMark::Parser < KPeg::CompiledParser
3357
4105
  return _tmp
3358
4106
  end
3359
4107
 
3360
- # HSection = HStart(n):h EmptyLine* (!HMarkupTerminator(n) Block)*:content EmptyLine* {h_section(h[:level], h[:heading], content, h[:ln])}
4108
+ # HSection = HStart(n):h EmptyLine* (!HMarkupTerminator(n) Block)*:content EmptyLine* {h_section(h[:level], h[:heading], h[:args], h[:named_args], content, h[:ln])}
3361
4109
  def _HSection(n)
3362
4110
 
3363
4111
  _save = self.pos
@@ -3416,7 +4164,7 @@ class NoraMark::Parser < KPeg::CompiledParser
3416
4164
  self.pos = _save
3417
4165
  break
3418
4166
  end
3419
- @result = begin; h_section(h[:level], h[:heading], content, h[:ln]); end
4167
+ @result = begin; h_section(h[:level], h[:heading], h[:args], h[:named_args], content, h[:ln]); end
3420
4168
  _tmp = true
3421
4169
  unless _tmp
3422
4170
  self.pos = _save
@@ -3428,27 +4176,163 @@ class NoraMark::Parser < KPeg::CompiledParser
3428
4176
  return _tmp
3429
4177
  end
3430
4178
 
3431
- # HeadedStart = (HStart(1) | HStart(2) | HStart(3) | HStart(4) | HStart(5) | HStart(6))
4179
+ # BlockHStart = - HStartCommand(n):hsc ln:ln - DocumentContentExcept('{'):s - "{" - Nl { hsc.merge({ level: n, heading: s, ln: ln}) }
4180
+ def _BlockHStart(n)
4181
+
4182
+ _save = self.pos
4183
+ while true # sequence
4184
+ _tmp = apply(:__hyphen_)
4185
+ unless _tmp
4186
+ self.pos = _save
4187
+ break
4188
+ end
4189
+ _tmp = apply_with_args(:_HStartCommand, n)
4190
+ hsc = @result
4191
+ unless _tmp
4192
+ self.pos = _save
4193
+ break
4194
+ end
4195
+ _tmp = apply(:_ln)
4196
+ ln = @result
4197
+ unless _tmp
4198
+ self.pos = _save
4199
+ break
4200
+ end
4201
+ _tmp = apply(:__hyphen_)
4202
+ unless _tmp
4203
+ self.pos = _save
4204
+ break
4205
+ end
4206
+ _tmp = apply_with_args(:_DocumentContentExcept, '{')
4207
+ s = @result
4208
+ unless _tmp
4209
+ self.pos = _save
4210
+ break
4211
+ end
4212
+ _tmp = apply(:__hyphen_)
4213
+ unless _tmp
4214
+ self.pos = _save
4215
+ break
4216
+ end
4217
+ _tmp = match_string("{")
4218
+ unless _tmp
4219
+ self.pos = _save
4220
+ break
4221
+ end
4222
+ _tmp = apply(:__hyphen_)
4223
+ unless _tmp
4224
+ self.pos = _save
4225
+ break
4226
+ end
4227
+ _tmp = apply(:_Nl)
4228
+ unless _tmp
4229
+ self.pos = _save
4230
+ break
4231
+ end
4232
+ @result = begin; hsc.merge({ level: n, heading: s, ln: ln}) ; end
4233
+ _tmp = true
4234
+ unless _tmp
4235
+ self.pos = _save
4236
+ end
4237
+ break
4238
+ end # end sequence
4239
+
4240
+ set_failed_rule :_BlockHStart unless _tmp
4241
+ return _tmp
4242
+ end
4243
+
4244
+ # ExplicitHSection = BlockHStart(n):h EmptyLine* - BlockBody:content - BlockEnd {h_section(h[:level], h[:heading], h[:args], h[:named_args], content, h[:ln])}
4245
+ def _ExplicitHSection(n)
4246
+
4247
+ _save = self.pos
4248
+ while true # sequence
4249
+ _tmp = apply_with_args(:_BlockHStart, n)
4250
+ h = @result
4251
+ unless _tmp
4252
+ self.pos = _save
4253
+ break
4254
+ end
4255
+ while true
4256
+ _tmp = apply(:_EmptyLine)
4257
+ break unless _tmp
4258
+ end
4259
+ _tmp = true
4260
+ unless _tmp
4261
+ self.pos = _save
4262
+ break
4263
+ end
4264
+ _tmp = apply(:__hyphen_)
4265
+ unless _tmp
4266
+ self.pos = _save
4267
+ break
4268
+ end
4269
+ _tmp = apply(:_BlockBody)
4270
+ content = @result
4271
+ unless _tmp
4272
+ self.pos = _save
4273
+ break
4274
+ end
4275
+ _tmp = apply(:__hyphen_)
4276
+ unless _tmp
4277
+ self.pos = _save
4278
+ break
4279
+ end
4280
+ _tmp = apply(:_BlockEnd)
4281
+ unless _tmp
4282
+ self.pos = _save
4283
+ break
4284
+ end
4285
+ @result = begin; h_section(h[:level], h[:heading], h[:args], h[:named_args], content, h[:ln]); end
4286
+ _tmp = true
4287
+ unless _tmp
4288
+ self.pos = _save
4289
+ end
4290
+ break
4291
+ end # end sequence
4292
+
4293
+ set_failed_rule :_ExplicitHSection unless _tmp
4294
+ return _tmp
4295
+ end
4296
+
4297
+ # HeadedStart = (HStart(6) | HStart(5) | HStart(4) | HStart(3) | HStart(2) | HStart(1) | BlockHStart(6) | BlockHStart(5) | BlockHStart(4) | BlockHStart(3) | BlockHStart(2) | BlockHStart(1))
3432
4298
  def _HeadedStart
3433
4299
 
3434
4300
  _save = self.pos
3435
4301
  while true # choice
3436
- _tmp = apply_with_args(:_HStart, 1)
4302
+ _tmp = apply_with_args(:_HStart, 6)
3437
4303
  break if _tmp
3438
4304
  self.pos = _save
3439
- _tmp = apply_with_args(:_HStart, 2)
4305
+ _tmp = apply_with_args(:_HStart, 5)
4306
+ break if _tmp
4307
+ self.pos = _save
4308
+ _tmp = apply_with_args(:_HStart, 4)
3440
4309
  break if _tmp
3441
4310
  self.pos = _save
3442
4311
  _tmp = apply_with_args(:_HStart, 3)
3443
4312
  break if _tmp
3444
4313
  self.pos = _save
3445
- _tmp = apply_with_args(:_HStart, 4)
4314
+ _tmp = apply_with_args(:_HStart, 2)
3446
4315
  break if _tmp
3447
4316
  self.pos = _save
3448
- _tmp = apply_with_args(:_HStart, 5)
4317
+ _tmp = apply_with_args(:_HStart, 1)
3449
4318
  break if _tmp
3450
4319
  self.pos = _save
3451
- _tmp = apply_with_args(:_HStart, 6)
4320
+ _tmp = apply_with_args(:_BlockHStart, 6)
4321
+ break if _tmp
4322
+ self.pos = _save
4323
+ _tmp = apply_with_args(:_BlockHStart, 5)
4324
+ break if _tmp
4325
+ self.pos = _save
4326
+ _tmp = apply_with_args(:_BlockHStart, 4)
4327
+ break if _tmp
4328
+ self.pos = _save
4329
+ _tmp = apply_with_args(:_BlockHStart, 3)
4330
+ break if _tmp
4331
+ self.pos = _save
4332
+ _tmp = apply_with_args(:_BlockHStart, 2)
4333
+ break if _tmp
4334
+ self.pos = _save
4335
+ _tmp = apply_with_args(:_BlockHStart, 1)
3452
4336
  break if _tmp
3453
4337
  self.pos = _save
3454
4338
  break
@@ -3458,29 +4342,47 @@ class NoraMark::Parser < KPeg::CompiledParser
3458
4342
  return _tmp
3459
4343
  end
3460
4344
 
3461
- # HeadedSection = (HSection(1) | HSection(2) | HSection(3) | HSection(4) | HSection(5) | HSection(6))
4345
+ # HeadedSection = (ExplicitHSection(6) | ExplicitHSection(5) | ExplicitHSection(4) | ExplicitHSection(3) | ExplicitHSection(2) | ExplicitHSection(1) | HSection(6) | HSection(5) | HSection(4) | HSection(3) | HSection(2) | HSection(1))
3462
4346
  def _HeadedSection
3463
4347
 
3464
4348
  _save = self.pos
3465
4349
  while true # choice
3466
- _tmp = apply_with_args(:_HSection, 1)
4350
+ _tmp = apply_with_args(:_ExplicitHSection, 6)
3467
4351
  break if _tmp
3468
4352
  self.pos = _save
3469
- _tmp = apply_with_args(:_HSection, 2)
4353
+ _tmp = apply_with_args(:_ExplicitHSection, 5)
3470
4354
  break if _tmp
3471
4355
  self.pos = _save
3472
- _tmp = apply_with_args(:_HSection, 3)
4356
+ _tmp = apply_with_args(:_ExplicitHSection, 4)
3473
4357
  break if _tmp
3474
4358
  self.pos = _save
3475
- _tmp = apply_with_args(:_HSection, 4)
4359
+ _tmp = apply_with_args(:_ExplicitHSection, 3)
3476
4360
  break if _tmp
3477
4361
  self.pos = _save
3478
- _tmp = apply_with_args(:_HSection, 5)
4362
+ _tmp = apply_with_args(:_ExplicitHSection, 2)
4363
+ break if _tmp
4364
+ self.pos = _save
4365
+ _tmp = apply_with_args(:_ExplicitHSection, 1)
3479
4366
  break if _tmp
3480
4367
  self.pos = _save
3481
4368
  _tmp = apply_with_args(:_HSection, 6)
3482
4369
  break if _tmp
3483
4370
  self.pos = _save
4371
+ _tmp = apply_with_args(:_HSection, 5)
4372
+ break if _tmp
4373
+ self.pos = _save
4374
+ _tmp = apply_with_args(:_HSection, 4)
4375
+ break if _tmp
4376
+ self.pos = _save
4377
+ _tmp = apply_with_args(:_HSection, 3)
4378
+ break if _tmp
4379
+ self.pos = _save
4380
+ _tmp = apply_with_args(:_HSection, 2)
4381
+ break if _tmp
4382
+ self.pos = _save
4383
+ _tmp = apply_with_args(:_HSection, 1)
4384
+ break if _tmp
4385
+ self.pos = _save
3484
4386
  break
3485
4387
  end # end choice
3486
4388
 
@@ -3681,7 +4583,7 @@ class NoraMark::Parser < KPeg::CompiledParser
3681
4583
  return _tmp
3682
4584
  end
3683
4585
 
3684
- # CharExcept = Char:c &{ c != e }
4586
+ # CharExcept = Char:c &{ e.is_a?(Regexp) ? e !~ c : e != c }
3685
4587
  def _CharExcept(e)
3686
4588
 
3687
4589
  _save = self.pos
@@ -3693,7 +4595,7 @@ class NoraMark::Parser < KPeg::CompiledParser
3693
4595
  break
3694
4596
  end
3695
4597
  _save1 = self.pos
3696
- _tmp = begin; c != e ; end
4598
+ _tmp = begin; e.is_a?(Regexp) ? e !~ c : e != c ; end
3697
4599
  self.pos = _save1
3698
4600
  unless _tmp
3699
4601
  self.pos = _save
@@ -3705,6 +4607,42 @@ class NoraMark::Parser < KPeg::CompiledParser
3705
4607
  return _tmp
3706
4608
  end
3707
4609
 
4610
+ # CharStringExcept = < CharExcept(e)+ > { text }
4611
+ def _CharStringExcept(e)
4612
+
4613
+ _save = self.pos
4614
+ while true # sequence
4615
+ _text_start = self.pos
4616
+ _save1 = self.pos
4617
+ _tmp = apply_with_args(:_CharExcept, e)
4618
+ if _tmp
4619
+ while true
4620
+ _tmp = apply_with_args(:_CharExcept, e)
4621
+ break unless _tmp
4622
+ end
4623
+ _tmp = true
4624
+ else
4625
+ self.pos = _save1
4626
+ end
4627
+ if _tmp
4628
+ text = get_text(_text_start)
4629
+ end
4630
+ unless _tmp
4631
+ self.pos = _save
4632
+ break
4633
+ end
4634
+ @result = begin; text ; end
4635
+ _tmp = true
4636
+ unless _tmp
4637
+ self.pos = _save
4638
+ end
4639
+ break
4640
+ end # end sequence
4641
+
4642
+ set_failed_rule :_CharStringExcept unless _tmp
4643
+ return _tmp
4644
+ end
4645
+
3708
4646
  # DocumentTextExcept = < (!Inline CharExcept(e))+ > ln:ln {text(text, ln)}
3709
4647
  def _DocumentTextExcept(e)
3710
4648
 
@@ -4076,7 +5014,7 @@ class NoraMark::Parser < KPeg::CompiledParser
4076
5014
  return _tmp
4077
5015
  end
4078
5016
 
4079
- # Pages = (Page:page Newpage:newpage Pages:pages { [ page, newpage ] + pages } | Page:page { [ page ] })
5017
+ # Pages = (Page:page Newpage:newpage Pages:pages { pages.unshift(page) } | Page:page { [ page ] })
4080
5018
  def _Pages
4081
5019
 
4082
5020
  _save = self.pos
@@ -4102,7 +5040,7 @@ class NoraMark::Parser < KPeg::CompiledParser
4102
5040
  self.pos = _save1
4103
5041
  break
4104
5042
  end
4105
- @result = begin; [ page, newpage ] + pages ; end
5043
+ @result = begin; pages.unshift(page) ; end
4106
5044
  _tmp = true
4107
5045
  unless _tmp
4108
5046
  self.pos = _save1
@@ -4200,22 +5138,22 @@ class NoraMark::Parser < KPeg::CompiledParser
4200
5138
  Rules[:_BOM] = rule_info("BOM", "/\\uFEFF/")
4201
5139
  Rules[:_Eof] = rule_info("Eof", "!.")
4202
5140
  Rules[:_Space] = rule_info("Space", "(\" \" | \"\\\\t\")")
4203
- Rules[:_EofComment] = rule_info("EofComment", "Space* \"\#\" (!Eof .)*")
4204
- Rules[:_Comment] = rule_info("Comment", "Space* \"\#\" (!Nl .)* Nl EmptyLine*")
4205
5141
  Rules[:__hyphen_] = rule_info("-", "Space*")
5142
+ Rules[:_EofComment] = rule_info("EofComment", "- \"//\" (!Eof .)*")
5143
+ Rules[:_Comment] = rule_info("Comment", "- \"//\" (!Nl .)* Nl EmptyLine*")
4206
5144
  Rules[:_EmptyLine] = rule_info("EmptyLine", "/^/ - (Nl | Comment | EofComment)")
4207
5145
  Rules[:_Nl] = rule_info("Nl", "/\\r?\\n/")
4208
5146
  Rules[:_Le] = rule_info("Le", "(Nl | Eof)")
4209
- Rules[:_Word] = rule_info("Word", "< /[\\w0-9]/ (\"-\" | /[\\w0-9]/)* > { text }")
5147
+ Rules[:_Word] = rule_info("Word", "< /[\\w]/ (\"-\" | /[\\w]/)* > { text }")
4210
5148
  Rules[:_Num] = rule_info("Num", "< [0-9]+ > { text.to_i }")
4211
5149
  Rules[:_ClassName] = rule_info("ClassName", "\".\" Word:classname { classname }")
4212
5150
  Rules[:_ClassNames] = rule_info("ClassNames", "ClassName*:classnames { classnames }")
4213
5151
  Rules[:_IdName] = rule_info("IdName", "\"\#\" Word:idname { idname }")
4214
5152
  Rules[:_IdNames] = rule_info("IdNames", "IdName*:idnames { idnames }")
4215
5153
  Rules[:_CommandName] = rule_info("CommandName", "Word:name IdNames?:idnames ClassNames?:classes ln:ln { {name: name, ids: idnames, classes: classes, ln:ln } }")
4216
- Rules[:_ParameterNormal] = rule_info("ParameterNormal", "< /[^,)]/* > { text }")
4217
- Rules[:_ParameterQuoted] = rule_info("ParameterQuoted", "\"\\\"\" < /[^\"]/* > \"\\\"\" - &/[,)]/ { text }")
4218
- Rules[:_ParameterSingleQuoted] = rule_info("ParameterSingleQuoted", "\"'\" < /[^']/* > \"'\" - &/[,)]/ { text }")
5154
+ Rules[:_ParameterNormal] = rule_info("ParameterNormal", "DocumentContentExcept(PARAMETER_END):content { content }")
5155
+ Rules[:_ParameterQuoted] = rule_info("ParameterQuoted", "\"\\\"\" DocumentContentExcept('\"'):content \"\\\"\" - &/[,)]/ { content }")
5156
+ Rules[:_ParameterSingleQuoted] = rule_info("ParameterSingleQuoted", "\"'\" DocumentContentExcept(\"'\"):content \"'\" - &/[,)]/ { content }")
4219
5157
  Rules[:_Parameter] = rule_info("Parameter", "(ParameterQuoted | ParameterSingleQuoted | ParameterNormal):value { value }")
4220
5158
  Rules[:_NParameterNormal] = rule_info("NParameterNormal", "< /[^,\\]]/* > { text }")
4221
5159
  Rules[:_NParameterQuoted] = rule_info("NParameterQuoted", "\"\\\"\" < /[^\"]/* > \"\\\"\" - &/[,\\]]/ { text }")
@@ -4225,11 +5163,11 @@ class NoraMark::Parser < KPeg::CompiledParser
4225
5163
  Rules[:_NamedParameter] = rule_info("NamedParameter", "Word:key - \":\" - NParameter:parameter { { key.to_sym => parameter } }")
4226
5164
  Rules[:_NamedParameters] = rule_info("NamedParameters", "(NamedParameter:parameter - \",\" - NamedParameters:parameters { parameter.merge parameters } | NamedParameter:parameter { parameter })")
4227
5165
  Rules[:_Command] = rule_info("Command", "CommandName:cn (\"(\" - Parameters:args - \")\")? (\"[\" - NamedParameters:named_args - \"]\")? { cn.merge({ args: args || [] , named_args: named_args || {}}) }")
4228
- Rules[:_ImplicitParagraph] = rule_info("ImplicitParagraph", "- !ParagraphDelimiter Comment* DocumentLine:content ln:ln Comment* EofComment? {paragraph([],[], [], [], content, ln)}")
5166
+ Rules[:_ImplicitParagraph] = rule_info("ImplicitParagraph", "- !ParagraphDelimiter Comment* DocumentLine:content ln:ln Comment* EofComment? {paragraph([],[], [], {}, content, ln)}")
4229
5167
  Rules[:_ExplicitParagraphCommand] = rule_info("ExplicitParagraphCommand", "Command:c &{ c[:name] == 'p' }")
4230
5168
  Rules[:_ExplicitParagraph] = rule_info("ExplicitParagraph", "- ExplicitParagraphCommand:c \":\" - DocumentContent?:content Le EmptyLine* {paragraph(c[:ids], c[:classes], c[:args], c[:named_args], content, c[:ln])}")
4231
5169
  Rules[:_Paragraph] = rule_info("Paragraph", "(ExplicitParagraph | ImplicitParagraph)")
4232
- Rules[:_ParagraphGroup] = rule_info("ParagraphGroup", "ln:ln Paragraph+:p EmptyLine* {paragraph_group([],[],[],[],p, ln)}")
5170
+ Rules[:_ParagraphGroup] = rule_info("ParagraphGroup", "ln:ln Paragraph+:p EmptyLine* {paragraph_group([],[],[],{},p, ln)}")
4233
5171
  Rules[:_BlockHead] = rule_info("BlockHead", "Command:command - \"{\" - Nl EmptyLine* { command }")
4234
5172
  Rules[:_BlockEnd] = rule_info("BlockEnd", "- \"}\" - Le EmptyLine*")
4235
5173
  Rules[:_BlockBody] = rule_info("BlockBody", "(!BlockEnd Block)+:body { body }")
@@ -4237,51 +5175,65 @@ class NoraMark::Parser < KPeg::CompiledParser
4237
5175
  Rules[:_PreformattedCommand] = rule_info("PreformattedCommand", "Command:command &{ ['pre', 'code'].include? command[:name] }")
4238
5176
  Rules[:_PreformattedCommandHeadSimple] = rule_info("PreformattedCommandHeadSimple", "PreformattedCommand:command - \"{\" - Nl { command }")
4239
5177
  Rules[:_PreformattedCommandHeadComplex] = rule_info("PreformattedCommandHeadComplex", "PreformattedCommand:command - \"{//\" Word?:codelanguage - Nl { command.merge({codelanguage: codelanguage}) }")
4240
- Rules[:_PreformattedCommandHead] = rule_info("PreformattedCommandHead", "(PreformattedCommandHeadComplex | PreformattedCommandHeadSimple)")
5178
+ Rules[:_PreformattedFence] = rule_info("PreformattedFence", "- \"```\" Word?:codelanguage (\"(\" - Parameters:args - \")\")? (\"[\" - NamedParameters:named_args - \"]\")? - Nl { {codelanguage: codelanguage, args: args || [], named_args: named_args || {} } }")
5179
+ Rules[:_PreformattedCommandHead] = rule_info("PreformattedCommandHead", "(PreformattedCommandHeadComplex | PreformattedCommandHeadSimple | PreformattedFence)")
4241
5180
  Rules[:_PreformatEndSimple] = rule_info("PreformatEndSimple", "- \"}\" - Le EmptyLine*")
4242
5181
  Rules[:_PreformatEndComplex] = rule_info("PreformatEndComplex", "- \"//}\" - Le EmptyLine*")
4243
5182
  Rules[:_PreformattedBlockSimple] = rule_info("PreformattedBlockSimple", "- PreformattedCommandHeadSimple:c (!PreformatEndSimple CharString Nl)+:content PreformatEndSimple {preformatted_block(c[:name], c[:ids], c[:classes], c[:args], c[:named_args], c[:codelanguage], content, c[:ln])}")
4244
5183
  Rules[:_PreformattedBlockComplex] = rule_info("PreformattedBlockComplex", "- PreformattedCommandHeadComplex:c (!PreformatEndComplex CharString Nl)+:content PreformatEndComplex {preformatted_block(c[:name], c[:ids], c[:classes], c[:args], c[:named_args], c[:codelanguage], content, c[:ln])}")
4245
- Rules[:_PreformattedBlock] = rule_info("PreformattedBlock", "(PreformattedBlockComplex | PreformattedBlockSimple)")
4246
- Rules[:_Inline] = rule_info("Inline", "(ImgInline | CommonInline)")
5184
+ Rules[:_PreformattedBlockFence] = rule_info("PreformattedBlockFence", "- ln:ln PreformattedFence:c (!\"```\" CharString Nl)+:content - \"```\" - Le EmptyLine* {preformatted_block('code', [], [], c[:args], c[:named_args], c[:codelanguage], content, ln)}")
5185
+ Rules[:_PreformattedBlock] = rule_info("PreformattedBlock", "(PreformattedBlockComplex | PreformattedBlockSimple | PreformattedBlockFence)")
5186
+ Rules[:_Inline] = rule_info("Inline", "(EscapedChar | ImgInline | MediaInline | CodeInline | CommonInline | FenceInline)")
4247
5187
  Rules[:_CommonInline] = rule_info("CommonInline", "\"[\" Command:c \"{\" - DocumentContentExcept('}'):content \"}\" \"]\" {inline(c[:name], c[:ids], c[:classes], c[:args], c[:named_args], content, c[:ln])}")
4248
5188
  Rules[:_ImgCommand] = rule_info("ImgCommand", "Command:c &{ c[:name] == 'img' && c[:args].size == 2}")
4249
5189
  Rules[:_ImgInline] = rule_info("ImgInline", "\"[\" ImgCommand:c \"]\" {inline(c[:name], c[:ids], c[:classes], c[:args], c[:named_args], nil, c[:ln])}")
5190
+ Rules[:_MediaCommand] = rule_info("MediaCommand", "Command:c &{ (c[:name] == 'video' || c[:name] == 'audio') && c[:args].size > 0}")
5191
+ Rules[:_MediaInline] = rule_info("MediaInline", "\"[\" MediaCommand:c (\"{\" - DocumentContentExcept('}'):content \"}\")? \"]\" {inline(c[:name], c[:ids], c[:classes], c[:args], c[:named_args], content, c[:ln])}")
5192
+ Rules[:_FenceInline] = rule_info("FenceInline", "\"`\" ln:ln CharStringExcept('`'):content \"`\" {code_inline([], [], [], {}, content, ln)}")
5193
+ Rules[:_CodeCommand] = rule_info("CodeCommand", "Command:c &{ c[:name] == 'code' }")
5194
+ Rules[:_CodeInline] = rule_info("CodeInline", "\"[\" CodeCommand:c \"{\" - CharStringExcept('}'):content \"}\" \"]\" {code_inline(c[:ids], c[:classes], c[:args], c[:named_args], content, c[:ln])}")
5195
+ Rules[:_EscapedChar] = rule_info("EscapedChar", "\"\\\\\" < /[`]/ > ln:ln {text(text, ln)}")
4250
5196
  Rules[:_CommandNameForSpecialLineCommand] = rule_info("CommandNameForSpecialLineCommand", "(NewpageCommand | ExplicitParagraphCommand)")
4251
5197
  Rules[:_NewpageCommand] = rule_info("NewpageCommand", "Command:command &{ command[:name] == 'newpage' }")
4252
5198
  Rules[:_Newpage] = rule_info("Newpage", "- NewpageCommand:c \":\" - DocumentContent?:content - Nl {newpage(c[:ids],c[:classes],c[:args], c[:named_args], content, c[:ln])}")
4253
- Rules[:_UnorderedList] = rule_info("UnorderedList", "ln:ln UnorderedItem+:items {unordered_list([],[],[],[], items, ln)}")
4254
- Rules[:_UnorderedItem] = rule_info("UnorderedItem", "ln:ln \"*:\" - DocumentContent:content Le {ul_item([], [], [], [], content, ln)}")
4255
- Rules[:_OrderedList] = rule_info("OrderedList", "ln:ln OrderedItem+:items {ordered_list([],[],[], [], items, ln)}")
4256
- Rules[:_OrderedItem] = rule_info("OrderedItem", "ln:ln Num \":\" - DocumentContent:content Le {ol_item([], [], [], [], content, ln)}")
4257
- Rules[:_DefinitionList] = rule_info("DefinitionList", "ln:ln DefinitionItem+:items {definition_list([], [], [], [], items, ln)}")
4258
- Rules[:_DefinitionItem] = rule_info("DefinitionItem", "- ln:ln \";:\" - DocumentContentExcept(':'):term \":\" - DocumentContent:definition Le {dl_item([], [], [term], [], definition, ln)}")
4259
- Rules[:_LongDefinitionList] = rule_info("LongDefinitionList", "ln:ln LongDefinitionItem+:items {definition_list([], [], [], [], items, ln)}")
4260
- Rules[:_LongDefinitionItem] = rule_info("LongDefinitionItem", "- ln:ln \";:\" - DocumentContentExcept('{'):term \"{\" - Nl - BlockBody:definition - BlockEnd {dl_item([], [], [term], [], definition, ln)}")
4261
- Rules[:_ItemsList] = rule_info("ItemsList", "(UnorderedList | OrderedList | DefinitionList | LongDefinitionList)")
5199
+ Rules[:_UnorderedStart] = rule_info("UnorderedStart", "/^/ - < /\\*+/ > &{ text.length == n && text.size < 5 }")
5200
+ Rules[:_UnorderedList] = rule_info("UnorderedList", "ln:ln UnorderedItem(n)+:items {unordered_list([],[],[],{}, items, ln)}")
5201
+ Rules[:_UnorderedItem] = rule_info("UnorderedItem", "UnorderedStart(n) ln:ln - UnorderedItemBody(n):content {ul_item([], [], [], {}, content, ln)}")
5202
+ Rules[:_UnorderedItemBody] = rule_info("UnorderedItemBody", "(DocumentContent:content Nl - &UnorderedStart(n + 1) ln:ln UnorderedList(n + 1):sub_ul { content << sub_ul } | DocumentContent:content Le { content })")
5203
+ Rules[:_OrderedList] = rule_info("OrderedList", "ln:ln OrderedItem+:items {ordered_list([],[],[], {}, items, ln)}")
5204
+ Rules[:_OrderedItem] = rule_info("OrderedItem", "- ln:ln Num \".\" - DocumentContent:content Le {ol_item([], [], [], {}, content, ln)}")
5205
+ Rules[:_DefinitionList] = rule_info("DefinitionList", "ln:ln DefinitionItem+:items {definition_list([], [], [], {}, items, ln)}")
5206
+ Rules[:_DefinitionItem] = rule_info("DefinitionItem", "- ln:ln - \";:\" - DocumentContentExcept(':'):term \":\" - DocumentContent:definition Le {dl_item([], [], [term], {}, definition, ln)}")
5207
+ Rules[:_LongDefinitionList] = rule_info("LongDefinitionList", "ln:ln LongDefinitionItem+:items {definition_list([], [], [], {}, items, ln)}")
5208
+ Rules[:_LongDefinitionItem] = rule_info("LongDefinitionItem", "- ln:ln \";:\" - DocumentContentExcept('{'):term \"{\" - Nl - BlockBody:definition - BlockEnd {dl_item([], [], [term], {}, definition, ln)}")
5209
+ Rules[:_ItemsList] = rule_info("ItemsList", "(UnorderedList(1) | OrderedList | DefinitionList | LongDefinitionList)")
4262
5210
  Rules[:_LineCommand] = rule_info("LineCommand", "- !CommandNameForSpecialLineCommand Command:c \":\" - DocumentContent?:content - Le EmptyLine* {block(c[:name], c[:ids], c[:classes], c[:args], c[:named_args], content, c[:ln])}")
4263
5211
  Rules[:_LineBlock] = rule_info("LineBlock", "(ItemsList | LineCommand)")
4264
5212
  Rules[:_Block] = rule_info("Block", "(PreformattedBlock | HeadedSection | LineBlock | ExplicitBlock | ParagraphGroup):block EmptyLine* {block}")
4265
5213
  Rules[:_BlockDelimiter] = rule_info("BlockDelimiter", "(BlockHead | BlockEnd)")
4266
5214
  Rules[:_ParagraphDelimiter] = rule_info("ParagraphDelimiter", "(BlockDelimiter | PreformattedCommandHead | LineBlock | Newpage | HeadedStart)")
4267
- Rules[:_HStartMark] = rule_info("HStartMark", "< \"=\"+ \":\" > &{ text.length - 1 == n }")
4268
- Rules[:_HMarkupTerminator] = rule_info("HMarkupTerminator", "(- < \"=\"+ \":\" > &{ text.length - 1 <= n } | - Eof)")
4269
- Rules[:_HStart] = rule_info("HStart", "- HStartMark(n) ln:ln - DocumentContent:s Le { { level: n, heading: s, ln: ln} }")
4270
- Rules[:_HSection] = rule_info("HSection", "HStart(n):h EmptyLine* (!HMarkupTerminator(n) Block)*:content EmptyLine* {h_section(h[:level], h[:heading], content, h[:ln])}")
4271
- Rules[:_HeadedStart] = rule_info("HeadedStart", "(HStart(1) | HStart(2) | HStart(3) | HStart(4) | HStart(5) | HStart(6))")
4272
- Rules[:_HeadedSection] = rule_info("HeadedSection", "(HSection(1) | HSection(2) | HSection(3) | HSection(4) | HSection(5) | HSection(6))")
5215
+ Rules[:_HStartMark] = rule_info("HStartMark", "- < \"\#\"+ > &{ text.length == n }")
5216
+ Rules[:_HMarkupTerminator] = rule_info("HMarkupTerminator", "(- < \"\#\"+ > - CharString:cs Le &{ text.length <= n && !cs.strip.end_with?('{') } | - Eof)")
5217
+ Rules[:_HStartCommand] = rule_info("HStartCommand", "- HStartMark(n) (\"(\" - Parameters:args - \")\")? (\"[\" - NamedParameters:named_args - \"]\")? { { args: args || [] , named_args: named_args || {}} }")
5218
+ Rules[:_HStart] = rule_info("HStart", "- HStartCommand(n):hsc ln:ln - DocumentContent:s Le { hsc.merge({ level: n, heading: s, ln: ln}) }")
5219
+ Rules[:_HSection] = rule_info("HSection", "HStart(n):h EmptyLine* (!HMarkupTerminator(n) Block)*:content EmptyLine* {h_section(h[:level], h[:heading], h[:args], h[:named_args], content, h[:ln])}")
5220
+ Rules[:_BlockHStart] = rule_info("BlockHStart", "- HStartCommand(n):hsc ln:ln - DocumentContentExcept('{'):s - \"{\" - Nl { hsc.merge({ level: n, heading: s, ln: ln}) }")
5221
+ Rules[:_ExplicitHSection] = rule_info("ExplicitHSection", "BlockHStart(n):h EmptyLine* - BlockBody:content - BlockEnd {h_section(h[:level], h[:heading], h[:args], h[:named_args], content, h[:ln])}")
5222
+ Rules[:_HeadedStart] = rule_info("HeadedStart", "(HStart(6) | HStart(5) | HStart(4) | HStart(3) | HStart(2) | HStart(1) | BlockHStart(6) | BlockHStart(5) | BlockHStart(4) | BlockHStart(3) | BlockHStart(2) | BlockHStart(1))")
5223
+ Rules[:_HeadedSection] = rule_info("HeadedSection", "(ExplicitHSection(6) | ExplicitHSection(5) | ExplicitHSection(4) | ExplicitHSection(3) | ExplicitHSection(2) | ExplicitHSection(1) | HSection(6) | HSection(5) | HSection(4) | HSection(3) | HSection(2) | HSection(1))")
4273
5224
  Rules[:_FrontmatterSeparator] = rule_info("FrontmatterSeparator", "- \"---\" - Nl")
4274
5225
  Rules[:_Frontmatter] = rule_info("Frontmatter", "FrontmatterSeparator ln:ln (!FrontmatterSeparator CharString Nl)+:yaml FrontmatterSeparator EmptyLine* {frontmatter(yaml, ln)}")
4275
5226
  Rules[:_Char] = rule_info("Char", "< /[[:print:]]/ > { text }")
4276
5227
  Rules[:_CharString] = rule_info("CharString", "< Char* > { text }")
4277
- Rules[:_CharExcept] = rule_info("CharExcept", "Char:c &{ c != e }")
5228
+ Rules[:_CharExcept] = rule_info("CharExcept", "Char:c &{ e.is_a?(Regexp) ? e !~ c : e != c }")
5229
+ Rules[:_CharStringExcept] = rule_info("CharStringExcept", "< CharExcept(e)+ > { text }")
4278
5230
  Rules[:_DocumentTextExcept] = rule_info("DocumentTextExcept", "< (!Inline CharExcept(e))+ > ln:ln {text(text, ln)}")
4279
5231
  Rules[:_DocumentContentExcept] = rule_info("DocumentContentExcept", "(Inline | DocumentTextExcept(e))+:content { content }")
4280
5232
  Rules[:_DocumentText] = rule_info("DocumentText", "< (!Inline Char)+ > ln:ln {text(text, ln)}")
4281
5233
  Rules[:_DocumentContent] = rule_info("DocumentContent", "(Inline | DocumentText)+:content { content }")
4282
5234
  Rules[:_DocumentLine] = rule_info("DocumentLine", "DocumentContent:content Le { content }")
4283
5235
  Rules[:_Page] = rule_info("Page", "Frontmatter?:frontmatter - (!Newpage Block)*:blocks EmptyLine* {page(([frontmatter] + blocks).select{ |x| !x.nil?}, 1)}")
4284
- Rules[:_Pages] = rule_info("Pages", "(Page:page Newpage:newpage Pages:pages { [ page, newpage ] + pages } | Page:page { [ page ] })")
5236
+ Rules[:_Pages] = rule_info("Pages", "(Page:page Newpage:newpage Pages:pages { pages.unshift(page) } | Page:page { [ page ] })")
4285
5237
  Rules[:_root] = rule_info("root", "BOM? EmptyLine* Pages:pages EofComment? Eof {root(pages)}")
4286
5238
  # :startdoc:
4287
5239
  end