rattler 0.5.0 → 0.6.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 (329) hide show
  1. data/README.rdoc +3 -175
  2. data/features/README.markdown +27 -0
  3. data/features/Tutorial.md +224 -0
  4. data/features/command_line/output_option.feature +2 -1
  5. data/features/command_line/{parser_generator.feature → rtlr.feature} +43 -15
  6. data/features/error_reporting/automatic_error_messages.feature +40 -0
  7. data/features/error_reporting/custom_error_messages.feature +28 -0
  8. data/features/examples/json_parser.markdown +88 -0
  9. data/features/{grammar → extended_matching_syntax}/back_reference.feature +5 -3
  10. data/features/{grammar → extended_matching_syntax}/e_symbol.feature +2 -2
  11. data/features/{grammar → extended_matching_syntax}/eof.feature +4 -3
  12. data/features/{grammar → extended_matching_syntax}/fail.feature +8 -6
  13. data/features/extended_matching_syntax/fragments.feature +29 -0
  14. data/features/extended_matching_syntax/include.feature +42 -0
  15. data/features/{grammar → extended_matching_syntax}/list_matching.feature +7 -6
  16. data/features/extended_matching_syntax/posix_class.feature +127 -0
  17. data/features/{grammar → extended_matching_syntax}/repeat.feature +29 -3
  18. data/features/{grammar → extended_matching_syntax}/skip_operator.feature +2 -1
  19. data/features/extended_matching_syntax/super.feature +24 -0
  20. data/features/{grammar → extended_matching_syntax}/token.feature +6 -5
  21. data/features/{grammar → extended_matching_syntax}/whitespace.feature +7 -6
  22. data/features/{grammar → extended_matching_syntax}/word_literal.feature +10 -6
  23. data/features/grammar_heading/explicit_start_rule.feature +20 -0
  24. data/features/grammar_heading/grammar_declaration.feature +60 -0
  25. data/features/grammar_heading/include.feature +19 -0
  26. data/features/grammar_heading/require.feature +27 -0
  27. data/features/{grammar → peg_syntax}/any_character.feature +1 -1
  28. data/features/peg_syntax/character_class.feature +25 -0
  29. data/features/{grammar → peg_syntax}/comments.feature +1 -1
  30. data/features/{grammar → peg_syntax}/literal.feature +5 -3
  31. data/features/{grammar → peg_syntax}/negative_lookahead.feature +5 -3
  32. data/features/peg_syntax/nonterminal.feature +46 -0
  33. data/features/peg_syntax/one_or_more.feature +59 -0
  34. data/features/{grammar → peg_syntax}/optional.feature +2 -2
  35. data/features/peg_syntax/ordered_choice.feature +24 -0
  36. data/features/{grammar → peg_syntax}/positive_lookahead.feature +6 -4
  37. data/features/peg_syntax/sequence.feature +23 -0
  38. data/features/{grammar → peg_syntax}/start_rule.feature +1 -1
  39. data/features/peg_syntax/zero_or_more.feature +59 -0
  40. data/features/{grammar → semantics}/labels.feature +0 -0
  41. data/features/{grammar → semantics}/negative_semantic_predicate.feature +30 -9
  42. data/features/{grammar → semantics}/node_action.feature +0 -0
  43. data/features/{grammar → semantics}/positive_semantic_predicate.feature +29 -8
  44. data/features/{grammar/symantic_action.feature → semantics/semantic_action.feature} +2 -2
  45. data/features/semantics/semantic_result.feature +86 -0
  46. data/features/{grammar → semantics}/side_effect.feature +33 -21
  47. data/features/step_definitions/cli_steps.rb +1 -1
  48. data/features/step_definitions/grammar_steps.rb +19 -5
  49. data/features/support/env.rb +5 -0
  50. data/lib/rattler.rb +21 -44
  51. data/lib/rattler/compiler.rb +69 -0
  52. data/lib/rattler/{grammar → compiler}/grammar_parser.rb +58 -24
  53. data/lib/rattler/compiler/metagrammar.rb +1570 -0
  54. data/lib/rattler/compiler/optimizer.rb +77 -0
  55. data/lib/rattler/{back_end → compiler}/optimizer/composite_reducing.rb +2 -2
  56. data/lib/rattler/{back_end → compiler}/optimizer/flatten_choice.rb +3 -12
  57. data/lib/rattler/{back_end → compiler}/optimizer/flatten_sequence.rb +4 -16
  58. data/lib/rattler/{back_end → compiler}/optimizer/flattening.rb +2 -2
  59. data/lib/rattler/compiler/optimizer/inline_regular_rules.rb +24 -0
  60. data/lib/rattler/{back_end → compiler}/optimizer/join_match_capturing_sequence.rb +16 -14
  61. data/lib/rattler/{back_end → compiler}/optimizer/join_match_choice.rb +4 -13
  62. data/lib/rattler/{back_end → compiler}/optimizer/join_match_matching_sequence.rb +4 -13
  63. data/lib/rattler/compiler/optimizer/join_match_sequence.rb +7 -0
  64. data/lib/rattler/{back_end → compiler}/optimizer/join_predicate_bare_match.rb +3 -12
  65. data/lib/rattler/compiler/optimizer/join_predicate_match.rb +7 -0
  66. data/lib/rattler/{back_end → compiler}/optimizer/join_predicate_nested_match.rb +4 -13
  67. data/lib/rattler/{back_end → compiler}/optimizer/join_predicate_or_bare_match.rb +3 -12
  68. data/lib/rattler/compiler/optimizer/join_predicate_or_match.rb +7 -0
  69. data/lib/rattler/{back_end → compiler}/optimizer/join_predicate_or_nested_match.rb +4 -13
  70. data/lib/rattler/{back_end → compiler}/optimizer/match_joining.rb +2 -2
  71. data/lib/rattler/{back_end → compiler}/optimizer/optimization.rb +12 -34
  72. data/lib/rattler/compiler/optimizer/optimization_context.rb +83 -0
  73. data/lib/rattler/{back_end → compiler}/optimizer/optimization_sequence.rb +3 -11
  74. data/lib/rattler/compiler/optimizer/optimizations.rb +27 -0
  75. data/lib/rattler/{back_end → compiler}/optimizer/optimize_children.rb +6 -14
  76. data/lib/rattler/{back_end → compiler}/optimizer/reduce_repeat_match.rb +4 -13
  77. data/lib/rattler/compiler/optimizer/remove_meaningless_wrapper.rb +22 -0
  78. data/lib/rattler/{back_end → compiler}/optimizer/simplify_redundant_repeat.rb +4 -13
  79. data/lib/rattler/{back_end → compiler}/optimizer/simplify_token_match.rb +4 -13
  80. data/lib/rattler/compiler/parser_generator.rb +108 -0
  81. data/lib/rattler/{back_end → compiler}/parser_generator/apply_generator.rb +7 -21
  82. data/lib/rattler/{back_end → compiler}/parser_generator/assert_generator.rb +11 -19
  83. data/lib/rattler/compiler/parser_generator/attributed_sequence_generator.rb +37 -0
  84. data/lib/rattler/{back_end → compiler}/parser_generator/back_reference_generator.rb +10 -10
  85. data/lib/rattler/{back_end → compiler}/parser_generator/choice_generator.rb +10 -22
  86. data/lib/rattler/{back_end → compiler}/parser_generator/delegating_generator.rb +2 -2
  87. data/lib/rattler/{back_end → compiler}/parser_generator/disallow_generator.rb +11 -19
  88. data/lib/rattler/{back_end → compiler}/parser_generator/e_symbol_generator.rb +2 -10
  89. data/lib/rattler/{back_end → compiler}/parser_generator/eof_generator.rb +2 -10
  90. data/lib/rattler/{back_end → compiler}/parser_generator/expr_generator.rb +9 -35
  91. data/lib/rattler/{back_end → compiler}/parser_generator/fail_generator.rb +7 -3
  92. data/lib/rattler/{back_end → compiler}/parser_generator/gen_method_names.rb +3 -5
  93. data/lib/rattler/{back_end → compiler}/parser_generator/general_list_generator.rb +6 -18
  94. data/lib/rattler/{back_end → compiler}/parser_generator/general_repeat_generator.rb +16 -22
  95. data/lib/rattler/{back_end/parser_generator/rule_set_generator.rb → compiler/parser_generator/grammar_generator.rb} +24 -33
  96. data/lib/rattler/compiler/parser_generator/group_match.rb +33 -0
  97. data/lib/rattler/{back_end → compiler}/parser_generator/group_match_generator.rb +4 -17
  98. data/lib/rattler/compiler/parser_generator/label_generator.rb +37 -0
  99. data/lib/rattler/{back_end → compiler}/parser_generator/list0_generating.rb +5 -5
  100. data/lib/rattler/{back_end → compiler}/parser_generator/list1_generating.rb +3 -3
  101. data/lib/rattler/{back_end → compiler}/parser_generator/list_generator.rb +2 -2
  102. data/lib/rattler/{back_end → compiler}/parser_generator/match_generator.rb +10 -10
  103. data/lib/rattler/{back_end → compiler}/parser_generator/nested.rb +2 -2
  104. data/lib/rattler/compiler/parser_generator/node_action_generator.rb +49 -0
  105. data/lib/rattler/{back_end → compiler}/parser_generator/one_or_more_generating.rb +3 -3
  106. data/lib/rattler/{back_end → compiler}/parser_generator/optional_generating.rb +6 -22
  107. data/lib/rattler/compiler/parser_generator/predicate_propogating.rb +24 -0
  108. data/lib/rattler/{back_end → compiler}/parser_generator/repeat_generator.rb +2 -2
  109. data/lib/rattler/compiler/parser_generator/rule_generator.rb +66 -0
  110. data/lib/rattler/compiler/parser_generator/rule_set_generator.rb +33 -0
  111. data/lib/rattler/compiler/parser_generator/semantic_action_generator.rb +58 -0
  112. data/lib/rattler/compiler/parser_generator/sequence_generating.rb +138 -0
  113. data/lib/rattler/compiler/parser_generator/sequence_generator.rb +57 -0
  114. data/lib/rattler/{back_end → compiler}/parser_generator/skip_generator.rb +4 -18
  115. data/lib/rattler/compiler/parser_generator/skip_propogating.rb +16 -0
  116. data/lib/rattler/{back_end → compiler}/parser_generator/sub_generating.rb +19 -11
  117. data/lib/rattler/compiler/parser_generator/super_generator.rb +54 -0
  118. data/lib/rattler/{back_end → compiler}/parser_generator/token_generator.rb +3 -3
  119. data/lib/rattler/compiler/parser_generator/token_propogating.rb +10 -0
  120. data/lib/rattler/{back_end → compiler}/parser_generator/top_level.rb +2 -2
  121. data/lib/rattler/{back_end → compiler}/parser_generator/zero_or_more_generating.rb +5 -5
  122. data/lib/rattler/compiler/rattler.rtlr +201 -0
  123. data/lib/rattler/{back_end → compiler}/ruby_generator.rb +16 -25
  124. data/lib/rattler/parsers.rb +12 -33
  125. data/lib/rattler/parsers/action_code.rb +25 -16
  126. data/lib/rattler/{grammar → parsers}/analysis.rb +32 -11
  127. data/lib/rattler/parsers/apply.rb +10 -19
  128. data/lib/rattler/parsers/assert.rb +4 -14
  129. data/lib/rattler/parsers/atomic.rb +3 -10
  130. data/lib/rattler/parsers/attributed_sequence.rb +50 -0
  131. data/lib/rattler/parsers/back_reference.rb +19 -14
  132. data/lib/rattler/parsers/choice.rb +11 -12
  133. data/lib/rattler/parsers/combinator_parser.rb +15 -7
  134. data/lib/rattler/parsers/combining.rb +15 -9
  135. data/lib/rattler/parsers/disallow.rb +5 -12
  136. data/lib/rattler/parsers/e_symbol.rb +5 -14
  137. data/lib/rattler/parsers/eof.rb +10 -15
  138. data/lib/rattler/parsers/fail.rb +16 -26
  139. data/lib/rattler/{grammar → parsers}/grammar.rb +15 -20
  140. data/lib/rattler/parsers/label.rb +10 -16
  141. data/lib/rattler/parsers/list_parser.rb +14 -14
  142. data/lib/rattler/parsers/match.rb +5 -17
  143. data/lib/rattler/parsers/node_action.rb +72 -0
  144. data/lib/rattler/parsers/node_code.rb +47 -30
  145. data/lib/rattler/parsers/parser.rb +63 -32
  146. data/lib/rattler/parsers/parser_scope.rb +88 -0
  147. data/lib/rattler/parsers/predicate.rb +12 -10
  148. data/lib/rattler/parsers/repeat.rb +15 -8
  149. data/lib/rattler/parsers/rule.rb +8 -23
  150. data/lib/rattler/parsers/rule_set.rb +67 -12
  151. data/lib/rattler/parsers/semantic.rb +36 -0
  152. data/lib/rattler/parsers/semantic_action.rb +39 -0
  153. data/lib/rattler/parsers/sequence.rb +25 -40
  154. data/lib/rattler/parsers/sequencing.rb +40 -0
  155. data/lib/rattler/parsers/skip.rb +11 -12
  156. data/lib/rattler/parsers/super.rb +33 -0
  157. data/lib/rattler/parsers/token.rb +3 -13
  158. data/lib/rattler/rake_task.rb +50 -0
  159. data/lib/rattler/runner.rb +19 -22
  160. data/lib/rattler/runtime.rb +0 -10
  161. data/lib/rattler/runtime/extended_packrat_parser.rb +40 -45
  162. data/lib/rattler/runtime/packrat_parser.rb +17 -31
  163. data/lib/rattler/runtime/parse_failure.rb +16 -26
  164. data/lib/rattler/runtime/parse_node.rb +8 -18
  165. data/lib/rattler/runtime/parser.rb +6 -18
  166. data/lib/rattler/runtime/parser_helper.rb +3 -10
  167. data/lib/rattler/runtime/recursive_descent_parser.rb +26 -23
  168. data/lib/rattler/runtime/syntax_error.rb +0 -10
  169. data/lib/rattler/util.rb +2 -6
  170. data/lib/rattler/util/grammar_cli.rb +19 -0
  171. data/lib/rattler/util/graphviz.rb +6 -17
  172. data/lib/rattler/util/graphviz/digraph_builder.rb +10 -17
  173. data/lib/rattler/util/graphviz/node_builder.rb +45 -31
  174. data/lib/rattler/util/line_counter.rb +11 -20
  175. data/lib/rattler/util/node.rb +52 -30
  176. data/lib/rattler/util/parser_cli.rb +84 -0
  177. data/lib/rattler/util/parser_spec_helper.rb +8 -12
  178. data/spec/rattler/compiler/assert_compiler_examples.rb +284 -0
  179. data/spec/rattler/compiler/attributed_sequence_compiler_examples.rb +154 -0
  180. data/spec/rattler/compiler/disallow_compiler_examples.rb +293 -0
  181. data/spec/rattler/compiler/grammar_parser_spec.rb +700 -0
  182. data/spec/rattler/{back_end → compiler}/optimizer/flatten_choice_spec.rb +1 -1
  183. data/spec/rattler/{back_end → compiler}/optimizer/flatten_sequence_spec.rb +1 -1
  184. data/spec/rattler/compiler/optimizer/inline_regular_rules_spec.rb +50 -0
  185. data/spec/rattler/{back_end → compiler}/optimizer/join_match_capturing_sequence_spec.rb +106 -22
  186. data/spec/rattler/{back_end → compiler}/optimizer/join_match_choice_spec.rb +1 -1
  187. data/spec/rattler/{back_end → compiler}/optimizer/join_match_matching_sequence_spec.rb +1 -1
  188. data/spec/rattler/{back_end → compiler}/optimizer/join_predicate_bare_match_spec.rb +1 -1
  189. data/spec/rattler/{back_end → compiler}/optimizer/join_predicate_nested_match_spec.rb +1 -1
  190. data/spec/rattler/{back_end → compiler}/optimizer/join_predicate_or_bare_match_spec.rb +1 -1
  191. data/spec/rattler/{back_end → compiler}/optimizer/join_predicate_or_nested_match_spec.rb +1 -1
  192. data/spec/rattler/{back_end → compiler}/optimizer/reduce_repeat_match_spec.rb +1 -1
  193. data/spec/rattler/compiler/optimizer/remove_meaningless_wrapper_spec.rb +82 -0
  194. data/spec/rattler/{back_end → compiler}/optimizer/simplify_redundant_repeat_spec.rb +1 -1
  195. data/spec/rattler/{back_end → compiler}/optimizer/simplify_token_match_spec.rb +1 -1
  196. data/spec/rattler/{back_end → compiler}/optimizer_spec.rb +1 -1
  197. data/spec/rattler/{back_end → compiler}/parser_generator/apply_generator_spec.rb +1 -39
  198. data/spec/rattler/{back_end → compiler}/parser_generator/assert_generator_spec.rb +1 -55
  199. data/spec/rattler/compiler/parser_generator/attributed_sequence_generator_spec.rb +699 -0
  200. data/spec/rattler/{back_end → compiler}/parser_generator/back_reference_generator_spec.rb +3 -56
  201. data/spec/rattler/{back_end → compiler}/parser_generator/choice_generator_spec.rb +1 -63
  202. data/spec/rattler/{back_end → compiler}/parser_generator/disallow_generator_spec.rb +1 -55
  203. data/spec/rattler/{back_end → compiler}/parser_generator/e_symbol_generator_spec.rb +1 -39
  204. data/spec/rattler/{back_end → compiler}/parser_generator/eof_generator_spec.rb +1 -39
  205. data/spec/rattler/{back_end → compiler}/parser_generator/fail_generator_spec.rb +94 -23
  206. data/spec/rattler/compiler/parser_generator/grammar_generator_spec.rb +98 -0
  207. data/spec/rattler/compiler/parser_generator/group_match_generator_spec.rb +67 -0
  208. data/spec/rattler/{back_end → compiler}/parser_generator/group_match_spec.rb +1 -1
  209. data/spec/rattler/{back_end → compiler}/parser_generator/label_generator_spec.rb +1 -55
  210. data/spec/rattler/{back_end → compiler}/parser_generator/list0_generator_examples.rb +0 -88
  211. data/spec/rattler/{back_end → compiler}/parser_generator/list1_generator_examples.rb +0 -88
  212. data/spec/rattler/{back_end → compiler}/parser_generator/list_generator_spec.rb +1 -227
  213. data/spec/rattler/{back_end → compiler}/parser_generator/match_generator_spec.rb +1 -55
  214. data/spec/rattler/compiler/parser_generator/node_action_generator_spec.rb +135 -0
  215. data/spec/rattler/{back_end → compiler}/parser_generator/one_or_more_generator_examples.rb +0 -74
  216. data/spec/rattler/{back_end → compiler}/parser_generator/optional_generator_examples.rb +0 -62
  217. data/spec/rattler/{back_end → compiler}/parser_generator/repeat_generator_spec.rb +66 -1
  218. data/spec/rattler/{back_end → compiler}/parser_generator/rule_generator_spec.rb +3 -2
  219. data/spec/rattler/{back_end → compiler}/parser_generator/rule_set_generator_spec.rb +9 -27
  220. data/spec/rattler/compiler/parser_generator/semantic_action_generator_spec.rb +437 -0
  221. data/spec/rattler/{back_end → compiler}/parser_generator/sequence_generator_spec.rb +234 -68
  222. data/spec/rattler/{back_end → compiler}/parser_generator/skip_generator_spec.rb +1 -55
  223. data/spec/rattler/compiler/parser_generator/super_generator_spec.rb +93 -0
  224. data/spec/rattler/{back_end → compiler}/parser_generator/token_generator_spec.rb +1 -55
  225. data/spec/rattler/{back_end → compiler}/parser_generator/zero_or_more_generator_examples.rb +0 -74
  226. data/spec/rattler/{back_end → compiler}/ruby_generator_spec.rb +13 -13
  227. data/spec/rattler/compiler/semantic_action_compiler_examples.rb +57 -0
  228. data/spec/rattler/{back_end → compiler}/shared_compiler_examples.rb +111 -140
  229. data/spec/rattler/{back_end → compiler}/skip_compiler_examples.rb +60 -57
  230. data/spec/rattler/{back_end → compiler}/token_compiler_examples.rb +99 -104
  231. data/spec/rattler/compiler_spec.rb +67 -0
  232. data/spec/rattler/parsers/action_code_spec.rb +34 -18
  233. data/spec/rattler/{grammar → parsers}/analysis_spec.rb +13 -67
  234. data/spec/rattler/parsers/apply_spec.rb +6 -0
  235. data/spec/rattler/parsers/assert_spec.rb +38 -2
  236. data/spec/rattler/parsers/attributed_sequence_spec.rb +204 -0
  237. data/spec/rattler/parsers/back_reference_spec.rb +6 -0
  238. data/spec/rattler/parsers/choice_spec.rb +38 -1
  239. data/spec/rattler/parsers/combinator_parser_spec.rb +2 -1
  240. data/spec/rattler/parsers/disallow_spec.rb +38 -2
  241. data/spec/rattler/parsers/e_symbol_spec.rb +6 -0
  242. data/spec/rattler/parsers/eof_spec.rb +6 -0
  243. data/spec/rattler/parsers/fail_spec.rb +6 -0
  244. data/spec/rattler/{grammar → parsers}/grammar_spec.rb +10 -15
  245. data/spec/rattler/parsers/label_spec.rb +30 -0
  246. data/spec/rattler/parsers/list_parser_spec.rb +31 -2
  247. data/spec/rattler/parsers/match_spec.rb +6 -0
  248. data/spec/rattler/parsers/node_action_spec.rb +121 -0
  249. data/spec/rattler/parsers/parser_scope_spec.rb +105 -0
  250. data/spec/rattler/parsers/repeat_spec.rb +56 -0
  251. data/spec/rattler/parsers/rule_set_spec.rb +42 -0
  252. data/spec/rattler/parsers/semantic_action_spec.rb +89 -0
  253. data/spec/rattler/parsers/sequence_spec.rb +156 -12
  254. data/spec/rattler/parsers/skip_spec.rb +21 -0
  255. data/spec/rattler/parsers/super_spec.rb +45 -0
  256. data/spec/rattler/parsers/token_spec.rb +33 -14
  257. data/spec/rattler/runtime/extended_packrat_parser_spec.rb +10 -8
  258. data/spec/rattler/runtime/recursive_descent_parser_spec.rb +26 -0
  259. data/spec/rattler/runtime/shared_parser_examples.rb +22 -16
  260. data/spec/rattler/util/graphviz/node_builder_spec.rb +33 -17
  261. data/spec/rattler/util/line_counter_spec.rb +21 -21
  262. data/spec/rattler/util/node_spec.rb +62 -0
  263. data/spec/rattler_spec.rb +7 -41
  264. data/spec/spec_helper.rb +1 -2
  265. data/spec/support/combinator_parser_spec_helper.rb +1 -1
  266. data/spec/support/compiler_spec_helper.rb +0 -4
  267. data/spec/support/parser_generator_spec_helper.rb +7 -7
  268. data/spec/support/runtime_parser_spec_helper.rb +57 -3
  269. metadata +447 -303
  270. data/features/grammar/character_class.feature +0 -20
  271. data/features/grammar/nonterminal.feature +0 -24
  272. data/features/grammar/one_or_more.feature +0 -34
  273. data/features/grammar/ordered_choice.feature +0 -21
  274. data/features/grammar/posix_class.feature +0 -70
  275. data/features/grammar/sequence.feature +0 -20
  276. data/features/grammar/zero_or_more.feature +0 -34
  277. data/lib/rattler/back_end.rb +0 -22
  278. data/lib/rattler/back_end/compiler.rb +0 -128
  279. data/lib/rattler/back_end/optimizer.rb +0 -101
  280. data/lib/rattler/back_end/optimizer/inline_regular_rules.rb +0 -46
  281. data/lib/rattler/back_end/optimizer/join_match_sequence.rb +0 -17
  282. data/lib/rattler/back_end/optimizer/join_predicate_match.rb +0 -17
  283. data/lib/rattler/back_end/optimizer/join_predicate_or_match.rb +0 -17
  284. data/lib/rattler/back_end/optimizer/optimization_context.rb +0 -72
  285. data/lib/rattler/back_end/optimizer/remove_meaningless_wrapper.rb +0 -32
  286. data/lib/rattler/back_end/optimizer/specialize_repeat.rb +0 -40
  287. data/lib/rattler/back_end/parser_generator.rb +0 -113
  288. data/lib/rattler/back_end/parser_generator/direct_action_generator.rb +0 -45
  289. data/lib/rattler/back_end/parser_generator/dispatch_action_generator.rb +0 -45
  290. data/lib/rattler/back_end/parser_generator/group_match.rb +0 -26
  291. data/lib/rattler/back_end/parser_generator/label_generator.rb +0 -64
  292. data/lib/rattler/back_end/parser_generator/predicate_propogating.rb +0 -24
  293. data/lib/rattler/back_end/parser_generator/rule_generator.rb +0 -53
  294. data/lib/rattler/back_end/parser_generator/sequence_generator.rb +0 -190
  295. data/lib/rattler/back_end/parser_generator/skip_propogating.rb +0 -16
  296. data/lib/rattler/back_end/parser_generator/token_propogating.rb +0 -10
  297. data/lib/rattler/grammar.rb +0 -43
  298. data/lib/rattler/grammar/grammar_dsl.rb +0 -51
  299. data/lib/rattler/grammar/metagrammar.rb +0 -990
  300. data/lib/rattler/grammar/rattler.rtlr +0 -183
  301. data/lib/rattler/parsers/assert_code.rb +0 -31
  302. data/lib/rattler/parsers/direct_action.rb +0 -85
  303. data/lib/rattler/parsers/disallow_code.rb +0 -31
  304. data/lib/rattler/parsers/dispatch_action.rb +0 -121
  305. data/lib/rattler/parsers/effect_code.rb +0 -31
  306. data/lib/rattler/parsers/parser_dsl.rb +0 -414
  307. data/lib/rattler/parsers/semantic_assert.rb +0 -19
  308. data/lib/rattler/parsers/semantic_disallow.rb +0 -19
  309. data/lib/rattler/parsers/side_effect.rb +0 -19
  310. data/spec/rattler/back_end/assert_compiler_examples.rb +0 -187
  311. data/spec/rattler/back_end/compiler_spec.rb +0 -43
  312. data/spec/rattler/back_end/direct_action_compiler_examples.rb +0 -227
  313. data/spec/rattler/back_end/disallow_compiler_examples.rb +0 -187
  314. data/spec/rattler/back_end/dispatch_action_compiler_examples.rb +0 -225
  315. data/spec/rattler/back_end/optimizer/inline_regular_rules_spec.rb +0 -80
  316. data/spec/rattler/back_end/parser_generator/direct_action_generator_spec.rb +0 -204
  317. data/spec/rattler/back_end/parser_generator/dispatch_action_generator_spec.rb +0 -204
  318. data/spec/rattler/back_end/parser_generator/group_match_generator_spec.rb +0 -185
  319. data/spec/rattler/back_end/semantic_assert_compiler_examples.rb +0 -152
  320. data/spec/rattler/back_end/semantic_disallow_compiler_examples.rb +0 -152
  321. data/spec/rattler/back_end/side_effect_compiler_examples.rb +0 -227
  322. data/spec/rattler/grammar/grammar_parser_spec.rb +0 -626
  323. data/spec/rattler/parsers/direct_action_spec.rb +0 -224
  324. data/spec/rattler/parsers/dispatch_action_spec.rb +0 -209
  325. data/spec/rattler/parsers/node_code_spec.rb +0 -59
  326. data/spec/rattler/parsers/parser_dsl_spec.rb +0 -334
  327. data/spec/rattler/parsers/semantic_assert_spec.rb +0 -83
  328. data/spec/rattler/parsers/semantic_disallow_spec.rb +0 -83
  329. data/spec/rattler/parsers/side_effect_spec.rb +0 -214
@@ -0,0 +1,40 @@
1
+ Feature: Automatic Error Messages
2
+
3
+ Rattler parsers automatically generate parse error messages for failed rules
4
+ using the name of the failed rule.
5
+
6
+ Rattler usually uses the name of the latest and deepest failed rule to ensure
7
+ the message is as specific as possible. The exception is when a rule is an
8
+ ordered choice. In that case using the name of the ordered choice rule makes
9
+ more sense.
10
+
11
+ Scenario: Automatic Error Message
12
+ Given a grammar with:
13
+ """
14
+ expr <- DIGIT
15
+ """
16
+ When I parse "a"
17
+ Then the parse should fail
18
+ And the failure message should be "expr expected"
19
+
20
+ Scenario: Deepest Rule Name
21
+ Given a grammar with:
22
+ """
23
+ expr <- digits
24
+ digits <- DIGIT+
25
+ """
26
+ When I parse "a"
27
+ Then the parse should fail
28
+ And the failure message should be "digits expected"
29
+
30
+ Scenario: Ordered Choice
31
+ Given a grammar with:
32
+ """
33
+ alnums <- alphas
34
+ / digits
35
+ alphas <- ALPHA+
36
+ digits <- DIGIT+
37
+ """
38
+ When I parse "@"
39
+ Then the parse should fail
40
+ And the failure message should be "alnums expected"
@@ -0,0 +1,28 @@
1
+ Feature: Custom Error Messages
2
+
3
+ A fail expression always fails with a specified message.
4
+
5
+ The keyword "expected" can be used as a shortcut for error messages like
6
+ "number expected."
7
+
8
+ Scenario: Custom Error Message
9
+ Given a grammar with:
10
+ """
11
+ expr <- "a"
12
+ / "b"
13
+ / fail "'a' or 'b' expected"
14
+ """
15
+ When I parse ""
16
+ Then the parse should fail
17
+ And the failure message should be "'a' or 'b' expected"
18
+
19
+ Scenario: "expected" keyword
20
+ Given a grammar with:
21
+ """
22
+ expr <- "a"
23
+ / "b"
24
+ / expected "'a' or 'b'"
25
+ """
26
+ When I parse ""
27
+ Then the parse should fail
28
+ And the failure message should be "'a' or 'b' expected"
@@ -0,0 +1,88 @@
1
+ The following is an example of a complete JSON parser. It parses JSON syntax
2
+ into Ruby hashes, arrays, and values.
3
+
4
+ `json.rtlr`:
5
+
6
+ # JSON parser based on the grammar at http://www.json.org
7
+
8
+ require 'rattler'
9
+ require_relative 'json_helper'
10
+
11
+ parser JsonParser < Rattler::Runtime::PackratParser
12
+
13
+ include JsonHelper
14
+
15
+ %whitespace (SPACE+ / comment)*
16
+
17
+ json_text <- (object / array) EOF
18
+
19
+ object <- ~'{' members ~'}' { object _ }
20
+
21
+ members <- pair *, ','
22
+
23
+ pair <- string ~':' value
24
+
25
+ array <- ~'[' elements ~']' { array _ }
26
+
27
+ elements <- value *, ','
28
+
29
+ value <- object
30
+ / array
31
+ / number
32
+ / string
33
+ / `true` { :true }
34
+ / `false` { :false }
35
+ / `null` { :null }
36
+
37
+ string <- @('"' char* '"') { string _ }
38
+
39
+ number <- @(int frac? exp?) { number _ }
40
+
41
+ %fragments
42
+
43
+ char <- !('"' / '\\' / CNTRL) .
44
+ / '\\' (["\\/bfnrt] / 'u' XDIGIT XDIGIT XDIGIT XDIGIT)
45
+
46
+ int <- '-'? ('0' !DIGIT / [1-9] DIGIT*)
47
+
48
+ frac <- '.' DIGIT+
49
+
50
+ exp <- [eE] [+-]? DIGIT+
51
+
52
+ comment <- '/*' (! '*/' .)* '*/'
53
+ / '//' [^\n]*
54
+
55
+ Because `true`, `false`, and `nil` all have special meaning to Rattler's
56
+ parsers, we encode these as symbols, then decode the symbols when we match
57
+ objects and arrays.
58
+
59
+ `json_helper`:
60
+
61
+ module JsonHelper
62
+
63
+ def object(members)
64
+ Hash[members.map {|k, v| [k, decode(v)] }]
65
+ end
66
+
67
+ def array(a)
68
+ a.map {|_| decode _ }
69
+ end
70
+
71
+ def string(expr)
72
+ eval "%q#{expr}", TOPLEVEL_BINDING
73
+ end
74
+
75
+ def number(expr)
76
+ eval expr, TOPLEVEL_BINDING
77
+ end
78
+
79
+ def decode(v)
80
+ case v
81
+ when :true then true
82
+ when :false then false
83
+ when :null then nil
84
+ else v
85
+ end
86
+ end
87
+
88
+ end
@@ -1,8 +1,10 @@
1
1
  Feature: Back References
2
2
 
3
- A back reference is a "$" followed by a label defined earlier in a sequence.
4
- The reference refers to the previous parse result and it means to match the
5
- same exact input again.
3
+ A back reference refers to a previous labelled parsing expression and matches
4
+ the exact string matched by the referenced expression.
5
+
6
+ A back reference is written as a "$" followed by a label defined earlier in a
7
+ sequence.
6
8
 
7
9
  Scenario Outline: Parsing
8
10
  Given a grammar with:
@@ -1,8 +1,8 @@
1
- Feature: EOF Symbol
1
+ Feature: E Symbol
2
2
 
3
3
  The symbol "E" always matches without consuming any input.
4
4
 
5
- Background: A grammar with the EOF symbol
5
+ Background: A grammar with the E symbol
6
6
  Given a grammar with:
7
7
  """
8
8
  foo <- E
@@ -1,7 +1,8 @@
1
1
  Feature: EOF Symbol
2
2
 
3
- The symbol "EOF" means to match the end of the source, i.e. match only if
4
- there is no more input.
3
+ The symbol "EOF" matches the end of the source, i.e. it matches only if there
4
+ is no more input. This can be used to ensure that a parse fails unless the
5
+ entire input is matched.
5
6
 
6
7
  Background: A grammar with the EOF symbol
7
8
  Given a grammar with:
@@ -17,4 +18,4 @@ Feature: EOF Symbol
17
18
  Scenario: Before end-of-input
18
19
  When I parse "foo"
19
20
  And the parse position is 2
20
- Then the parse should fail
21
+ Then the parse should fail
@@ -1,10 +1,12 @@
1
1
  Feature: Fail Expressions
2
-
3
- A "fail" expression means alway fail here with a specified message. It can
4
- used to provide more meaningful messages when a parse fails. The syntax is
5
- either "fail", "fail_rule" or "fail_parse" followed by the message specified
6
- as a string literal. Using "fail_rule" causes the entire rule to fail and
7
- "fail_parse" causes the entire parse to fail.
2
+
3
+ A fail expression always fails with a specified message. It can used to
4
+ provide more meaningful messages when a parse fails.
5
+
6
+ A fail expression is written as either "fail", "fail_rule" or "fail_parse"
7
+ followed by the message specified as a string literal. Using "fail_rule"
8
+ causes the entire rule to fail and "fail_parse" causes the entire parse to
9
+ fail.
8
10
 
9
11
  Scenario: Fail-expression
10
12
  Given a grammar with:
@@ -0,0 +1,29 @@
1
+ Feature: Fragments
2
+
3
+ The "%fragments" directive disables whitepsace skipping and marks parse rules
4
+ to be inlined. This is useful for factoring complex token rules.
5
+
6
+ Scenario: Matching a number
7
+ Given a grammar with:
8
+ """
9
+ %whitespace SPACE+
10
+
11
+ number <- @(int frac?)
12
+
13
+ %fragments
14
+
15
+ int <- '-'? DIGIT+
16
+
17
+ frac <- '.' DIGIT+
18
+ """
19
+ When I generate parser code
20
+ Then the code should contain:
21
+ """
22
+ def match_number! #:nodoc:
23
+ begin
24
+ @scanner.skip(/(?>(?>[[:space:]])+)((?>(?>(?>\-)?)(?>(?>[[:digit:]])+))(?>(?>(?>\.)(?>(?>[[:digit:]])+))?))/) &&
25
+ @scanner[1]
26
+ end ||
27
+ fail { :number }
28
+ end
29
+ """
@@ -0,0 +1,42 @@
1
+ Feature: include
2
+
3
+ A grammar can include another grammar and use or override its rules.
4
+
5
+ Scenario Outline: Included grammar
6
+ Given a grammar called "ExprGrammar" with:
7
+ """
8
+ a <- "A"
9
+ """
10
+ And a grammar with:
11
+ """
12
+ include ExprGrammar
13
+
14
+ expr <- a
15
+ """
16
+ When I parse <input>
17
+ Then the parse result should be <result>
18
+
19
+ Examples:
20
+ | input | result |
21
+ | "A" | "A" |
22
+ | "B" | FAIL |
23
+
24
+ Scenario Outline: Overriding a rule
25
+ Given a grammar called "ExprGrammar" with:
26
+ """
27
+ expr <- a
28
+ a <- "A"
29
+ """
30
+ And a grammar with:
31
+ """
32
+ include ExprGrammar
33
+
34
+ a <- "B"
35
+ """
36
+ When I parse <input>
37
+ Then the parse result should be <result>
38
+
39
+ Examples:
40
+ | input | result |
41
+ | "B" | "B" |
42
+ | "A" | FAIL |
@@ -1,13 +1,14 @@
1
1
  Feature: List Matching
2
2
 
3
- A term expression followed by "*," or "+," and a separator expression means
4
- to match a list of terms with separators between them. "*," matches a list of
5
- zero or more terms, "+," matches a list of one or more term.
3
+ A list matching expression defines a term expression and a separator and
4
+ matches a list of terms.
6
5
 
6
+ A list matching expression is written by following a parsing expression for
7
+ the term with "*," or "+," followed by a parsing expression for the separator.
7
8
  Repetition counts or ranges can also be used for generalized list matching
8
- expressions. A count by itself means to match the preceding expression exactly
9
- that many times. A range can be written with ".." between the lower and upper
10
- bounds. The upper bound is optional.
9
+ expressions. With a count by itself the expression matches a exactly that
10
+ many terms. A range is written as a lower bound followed by "..", optionally
11
+ followed by an upper bound.
11
12
 
12
13
  Scenario Outline: Zero or more terms
13
14
  Given a grammar with:
@@ -0,0 +1,127 @@
1
+ Feature: POSIX Character Classes
2
+
3
+ The uppercase names of POSIX character classes can be used as a shortcut to
4
+ using them in character class expressions, e.g. "DIGIT" and "[[:digit:]]" are
5
+ equivalent. In addition, "WORD" is a shortcut for "[[:alnum:]_]", equivalent
6
+ to "[[:word:]]" in Ruby 1.9.
7
+
8
+ The POSIX character classes are:
9
+
10
+ ALNUM - Alphanumeric characters
11
+ ALPHA - Alphabetic characters
12
+ ASCII - ASCII characters
13
+ BLANK - Space and tab
14
+ CNTRL - Control characters
15
+ DIGIT - Digits
16
+ GRAPH - Visible characters
17
+ LOWER - Lowercase characters
18
+ PRINT - Visible characters and spaces
19
+ PUNCT - Punctuation characters
20
+ SPACE - Whitespace characters
21
+ UPPER - Uppercase characters
22
+ XDIGIT - Hexadecimal digits
23
+ WORD - Alphanumeric characters plus "_"
24
+
25
+ Scenario: ALNUM
26
+ Given a grammar with:
27
+ """
28
+ expr <- ALNUM+
29
+ """
30
+ When I parse "abc123"
31
+ Then the parse result should be ["a", "b", "c", "1", "2", "3"]
32
+
33
+ Scenario: ALPHA
34
+ Given a grammar with:
35
+ """
36
+ expr <- ALPHA+
37
+ """
38
+ When I parse "abc123"
39
+ Then the parse result should be ["a", "b", "c"]
40
+
41
+ Scenario: BLANK
42
+ Given a grammar with:
43
+ """
44
+ expr <- BLANK+
45
+ """
46
+ When I parse " \t\nabc"
47
+ Then the parse result should be [" ", "\t"]
48
+
49
+ Scenario: CNTRL
50
+ Given a grammar with:
51
+ """
52
+ expr <- CNTRL+
53
+ """
54
+ When I parse "\t\r\n abc"
55
+ Then the parse result should be ["\t", "\r", "\n"]
56
+
57
+ Scenario: DIGIT
58
+ Given a grammar with:
59
+ """
60
+ expr <- DIGIT+
61
+ """
62
+ When I parse "123abc"
63
+ Then the parse result should be ["1", "2", "3"]
64
+
65
+ Scenario: GRAPH
66
+ Given a grammar with:
67
+ """
68
+ expr <- GRAPH+
69
+ """
70
+ When I parse "a1; "
71
+ Then the parse result should be ["a", "1", ";"]
72
+
73
+ Scenario: LOWER
74
+ Given a grammar with:
75
+ """
76
+ expr <- LOWER+
77
+ """
78
+ When I parse "abcDEF"
79
+ Then the parse result should be ["a", "b", "c"]
80
+
81
+ Scenario: PRINT
82
+ Given a grammar with:
83
+ """
84
+ expr <- PRINT+
85
+ """
86
+ When I parse " abc\tdef"
87
+ Then the parse result should be [" ", "a", "b", "c"]
88
+
89
+ Scenario: PUNCT
90
+ Given a grammar with:
91
+ """
92
+ expr <- PUNCT+
93
+ """
94
+ When I parse ",.!;abc"
95
+ Then the parse result should be [",", ".", "!", ";"]
96
+
97
+ Scenario: SPACE
98
+ Given a grammar with:
99
+ """
100
+ expr <- SPACE+
101
+ """
102
+ When I parse " \t\r\nabc"
103
+ Then the parse result should be [" ", "\t", "\r", "\n"]
104
+
105
+ Scenario: UPPER
106
+ Given a grammar with:
107
+ """
108
+ expr <- UPPER+
109
+ """
110
+ When I parse "ABCdef"
111
+ Then the parse result should be ["A", "B", "C"]
112
+
113
+ Scenario: XDIGIT
114
+ Given a grammar with:
115
+ """
116
+ expr <- XDIGIT+
117
+ """
118
+ When I parse "1aFg"
119
+ Then the parse result should be ["1", "a", "F"]
120
+
121
+ Scenario: WORD
122
+ Given a grammar with:
123
+ """
124
+ expr <- WORD+
125
+ """
126
+ When I parse "Ab_1-d"
127
+ Then the parse result should be ["A", "b", "_", "1"]
@@ -1,9 +1,9 @@
1
1
  Feature: Generalized Repeat
2
2
 
3
3
  Repetition counts or ranges can be used for generalized repeat expressions.
4
- A count by itself means to match the preceding expression exactly that many
5
- times. A range can be written with ".." between the lower and upper bounds.
6
- The upper bound is optional.
4
+ With a count by itself the expression matches a exactly that many times.
5
+ A range is written as a lower bound followed by "..", optionally followed by
6
+ an upper bound.
7
7
 
8
8
  Scenario Outline: Range
9
9
  Given a grammar with:
@@ -48,3 +48,29 @@ Feature: Generalized Repeat
48
48
  | input | result | pos |
49
49
  | "abc" | ["a", "b"] | 2 |
50
50
  | "a" | FAIL | 0 |
51
+
52
+ Scenario Outline: Choice of capturing or non-capturing
53
+ Given a grammar with:
54
+ """
55
+ expr <- ("a" / ~"b") 2..
56
+ """
57
+ When I parse <input>
58
+ Then the parse result should be <result>
59
+ And the parse position should be <pos>
60
+
61
+ Examples:
62
+ | input | result | pos |
63
+ | "aa" | ["a", "a"] | 2 |
64
+ | "aba" | ["a", "a"] | 3 |
65
+ | "abc" | ["a"] | 2 |
66
+ | "bbc" | [] | 2 |
67
+ | "acb" | FAIL | 0 |
68
+
69
+ Scenario: Semantic attribute returning true
70
+ Given a grammar with:
71
+ """
72
+ expr <- (ALPHA { true }) 2..
73
+ """
74
+ When I parse "foo "
75
+ Then the parse result should be []
76
+ And the parse position should be 3