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
@@ -2,148 +2,151 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
2
2
 
3
3
  shared_examples_for 'a compiled parser with a skip' do
4
4
  include CompilerSpecHelper
5
+ include RuntimeParserSpecHelper
5
6
 
6
7
  subject { compiled_parser }
7
8
 
8
9
  let(:reference_parser) { combinator_parser grammar }
9
10
 
11
+ let(:grammar) { Rattler::Parsers::Grammar[Rattler::Parsers::RuleSet[*rules]] }
12
+
10
13
  context 'with a nested match rule' do
11
- let(:grammar) { define_grammar do
14
+ let(:rules) { [
12
15
  rule(:ws) { skip(/\s+/) }
13
- end }
16
+ ] }
14
17
  it { should parse(' foo').succeeding.like reference_parser }
15
18
  it { should parse('hi').failing.like reference_parser }
16
19
  end
17
20
 
18
21
  context 'with a nested apply rule' do
19
- let(:grammar) { define_grammar do
20
- rule(:spaces) { match(/\s+/) }
22
+ let(:rules) { [
23
+ rule(:spaces) { match(/\s+/) },
21
24
  rule(:ws) { skip(:spaces) }
22
- end }
25
+ ] }
23
26
  it { should parse(' foo').succeeding.like reference_parser }
24
27
  it { should parse('hi').failing.like reference_parser }
25
28
  end
26
29
 
27
30
  context 'with a nested assert rule' do
28
- let(:grammar) { define_grammar do
31
+ let(:rules) { [
29
32
  rule(:foo) { skip(assert(/\d/)) }
30
- end }
33
+ ] }
31
34
  it { should parse('451a').succeeding.like reference_parser }
32
35
  it { should parse(' ').failing.like reference_parser }
33
36
  end
34
37
 
35
38
  context 'with a nested disallow rule' do
36
- let(:grammar) { define_grammar do
39
+ let(:rules) { [
37
40
  rule(:foo) { skip(disallow(/\d/)) }
38
- end }
41
+ ] }
39
42
  it { should parse(' ').succeeding.like reference_parser }
40
43
  it { should parse('451a').failing.like reference_parser }
41
44
  end
42
45
 
43
46
  context 'with a nested EOF rule' do
44
- let(:grammar) { define_grammar do
47
+ let(:rules) { [
45
48
  rule(:foo) { skip(eof) }
46
- end }
49
+ ] }
47
50
  it { should parse('foo').failing.like reference_parser }
48
51
  it { should parse('').succeeding.like reference_parser }
49
52
  it { should parse('foo').from(3).succeeding.like reference_parser }
50
53
  end
51
54
 
52
55
  context 'with a nested "E" symbol rule' do
53
- let(:grammar) { define_grammar do
56
+ let(:rules) { [
54
57
  rule(:foo) { skip(e) }
55
- end }
58
+ ] }
56
59
  it { should parse('').succeeding.like reference_parser }
57
60
  it { should parse('foo').succeeding.like reference_parser }
58
61
  end
59
62
 
60
63
  context 'with a nested choice rule' do
61
- let(:grammar) { define_grammar do
64
+ let(:rules) { [
62
65
  rule(:ws) do
63
66
  skip(match(/\s+/) | match(/\#[^\n]*/))
64
67
  end
65
- end }
68
+ ] }
66
69
  it { should parse(' # hi there ').succeeding.twice.like reference_parser }
67
70
  it { should parse('hi').failing.like reference_parser }
68
71
  end
69
72
 
70
73
  context 'with a nested sequence rule' do
71
- let(:grammar) { define_grammar do
72
- rule :foo do
74
+ let(:rules) { [
75
+ rule(:foo) {
73
76
  skip(match(/[[:alpha:]]+/) & match(/[[:digit:]]+/))
74
- end
75
- end }
77
+ }
78
+ ] }
76
79
  it { should parse('foo42!').succeeding.like reference_parser }
77
80
  it { should parse('val=x').failing.like reference_parser }
78
81
  end
79
82
 
80
83
  context 'with a nested optional rule' do
81
- let(:grammar) { define_grammar do
82
- rule :foo do
83
- skip(optional(/\w+/))
84
- end
85
- end }
84
+ let(:rules) { [
85
+ rule(:foo) {
86
+ skip(match(/\w+/).optional)
87
+ }
88
+ ] }
86
89
  it { should parse('foo ').succeeding.like reference_parser }
87
90
  it { should parse(' ').succeeding.like reference_parser }
88
91
  end
89
92
 
90
93
  context 'with a nested zero-or-more rule' do
91
- let(:grammar) { define_grammar do
92
- rule :foo do
93
- skip(zero_or_more(/\w/))
94
- end
95
- end }
94
+ let(:rules) { [
95
+ rule(:foo) {
96
+ skip(match(/\w/).zero_or_more)
97
+ }
98
+ ] }
96
99
  it { should parse('foo ').succeeding.like reference_parser }
97
100
  it { should parse(' ').succeeding.like reference_parser }
98
101
  end
99
102
 
100
103
  context 'with a nested one-or-more rule' do
101
- let(:grammar) { define_grammar do
102
- rule :foo do
103
- skip(one_or_more(/\w/))
104
- end
105
- end }
104
+ let(:rules) { [
105
+ rule(:foo) {
106
+ skip(match(/\w/).one_or_more)
107
+ }
108
+ ] }
106
109
  it { should parse('foo ').succeeding.like reference_parser }
107
110
  it { should parse(' ').failing.like reference_parser }
108
111
  end
109
112
 
110
113
  context 'with a nested repeat rule' do
111
- let(:grammar) { define_grammar do
112
- rule :foo do
113
- skip(repeat(/\w/, 2, 4))
114
- end
115
- end }
114
+ let(:rules) { [
115
+ rule(:foo) {
116
+ skip(match(/\w/).repeat(2, 4))
117
+ }
118
+ ] }
116
119
  it { should parse('foo ').succeeding.like reference_parser }
117
120
  it { should parse('abcde ').succeeding.like reference_parser }
118
121
  it { should parse('a ').failing.like reference_parser }
119
122
 
120
123
  context 'with optional bounds' do
121
- let(:grammar) { define_grammar do
122
- rule :foo do
123
- skip(repeat(/\w+/, 0, 1))
124
- end
125
- end }
124
+ let(:rules) { [
125
+ rule(:foo) {
126
+ skip(match(/\w+/).repeat(0, 1))
127
+ }
128
+ ] }
126
129
  it { should parse('foo ').succeeding.like reference_parser }
127
130
  it { should parse(' ').succeeding.like reference_parser }
128
131
  end
129
132
 
130
133
  context 'with zero-or-more bounds' do
131
- let(:grammar) { define_grammar do
132
- rule :foo do
133
- skip(repeat(/\w/, 0, 4))
134
- end
135
- end }
134
+ let(:rules) { [
135
+ rule(:foo) {
136
+ skip(match(/\w/).repeat(0, 4))
137
+ }
138
+ ] }
136
139
  it { should parse('foo ').succeeding.like reference_parser }
137
140
  it { should parse('abcde ').succeeding.like reference_parser }
138
141
  it { should parse(' ').succeeding.like reference_parser }
139
142
  end
140
143
 
141
144
  context 'with one-or-more bounds' do
142
- let(:grammar) { define_grammar do
143
- rule :foo do
144
- skip(repeat(/\w/, 1, 4))
145
- end
146
- end }
145
+ let(:rules) { [
146
+ rule(:foo) {
147
+ skip(match(/\w/).repeat(1, 4))
148
+ }
149
+ ] }
147
150
  it { should parse('foo ').succeeding.like reference_parser }
148
151
  it { should parse('abcde ').succeeding.like reference_parser }
149
152
  it { should parse(' ').failing.like reference_parser }
@@ -151,10 +154,10 @@ shared_examples_for 'a compiled parser with a skip' do
151
154
  end
152
155
 
153
156
  context 'with a nested apply rule' do
154
- let(:grammar) { define_grammar do
155
- rule(:digits) { match(/\d+/) }
157
+ let(:rules) { [
158
+ rule(:digits) { match(/\d+/) },
156
159
  rule(:foo) { skip(:digits) }
157
- end }
160
+ ] }
158
161
  it { should parse('451a').succeeding.like reference_parser }
159
162
  it { should parse('hi').failing.like reference_parser }
160
163
  end
@@ -2,223 +2,226 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
2
2
 
3
3
  shared_examples_for 'a compiled parser with a token' do
4
4
  include CompilerSpecHelper
5
+ include RuntimeParserSpecHelper
5
6
 
6
7
  subject { compiled_parser }
7
8
 
8
9
  let(:reference_parser) { combinator_parser grammar }
9
10
 
11
+ let(:grammar) { Rattler::Parsers::Grammar[Rattler::Parsers::RuleSet[*rules]] }
12
+
10
13
  context 'with a nested match rule' do
11
- let(:grammar) { define_grammar do
14
+ let(:rules) { [
12
15
  rule(:digits) { token(match(/\d+/)) }
13
- end }
16
+ ] }
14
17
  it { should parse('451a').succeeding.like reference_parser }
15
18
  it { should parse('hi').failing.like reference_parser }
16
19
  end
17
20
 
18
21
  context 'with a nested apply rule' do
19
- let(:grammar) { define_grammar do
20
- rule(:digit) { match(/\d/) }
21
- rule(:foo) { token :digit }
22
- end }
22
+ let(:rules) { [
23
+ rule(:digit) { match(/\d/) },
24
+ rule(:foo) { token(:digit) }
25
+ ] }
23
26
  it { should parse('451 ').twice.succeeding.like reference_parser }
24
27
  it { should parse('hi').failing.like reference_parser }
25
28
 
26
29
  context 'with a label' do
27
- let(:grammar) { define_grammar do
28
- rule(:digits) { match(/\d+/) }
30
+ let(:rules) { [
31
+ rule(:digits) { match(/\d+/) },
29
32
  rule(:num) { token(label(:num, :digits)) }
30
- end }
33
+ ] }
31
34
  it { should parse('451a').succeeding.like reference_parser }
32
35
  it { should parse(' ').failing.like reference_parser }
33
36
  end
34
37
  end
35
38
 
36
39
  context 'with a nested assert rule' do
37
- let(:grammar) { define_grammar do
40
+ let(:rules) { [
38
41
  rule(:foo) { token(assert(/\d/)) }
39
- end }
42
+ ] }
40
43
  it { should parse('451a').succeeding.like reference_parser }
41
44
  it { should parse(' ').failing.like reference_parser }
42
45
  end
43
46
 
44
47
  context 'with a nested disallow rule' do
45
- let(:grammar) { define_grammar do
48
+ let(:rules) { [
46
49
  rule(:foo) { token(disallow(/\d/)) }
47
- end }
50
+ ] }
48
51
  it { should parse(' ').succeeding.like reference_parser }
49
52
  it { should parse('451a').failing.like reference_parser }
50
53
  end
51
54
 
52
55
  context 'with a nested EOF rule' do
53
- let(:grammar) { define_grammar do
56
+ let(:rules) { [
54
57
  rule(:foo) { token(eof) }
55
- end }
58
+ ] }
56
59
  it { should parse('foo').failing.like reference_parser }
57
60
  it { should parse('').succeeding.like reference_parser }
58
61
  it { should parse('foo').from(3).succeeding.like reference_parser }
59
62
  end
60
63
 
61
64
  context 'with a nested "E" symbol rule' do
62
- let(:grammar) { define_grammar do
65
+ let(:rules) { [
63
66
  rule(:foo) { token(e) }
64
- end }
67
+ ] }
65
68
  it { should parse('').succeeding.like reference_parser }
66
69
  it { should parse('foo').succeeding.like reference_parser }
67
70
  end
68
71
 
69
72
  context 'with a nested choice rule' do
70
- let(:grammar) { define_grammar do
71
- rule(:atom) do
73
+ let(:rules) { [
74
+ rule(:atom) {
72
75
  token(match(/[[:alpha:]]+/) | match(/[[:digit:]]+/))
73
- end
74
- end }
76
+ }
77
+ ] }
75
78
 
76
79
  it { should parse('abc123 ').succeeding.like reference_parser }
77
80
  it { should parse('==').failing.like reference_parser }
78
81
 
79
82
  context 'with non-capturing choices' do
80
- let(:grammar) { define_grammar do
81
- rule(:atom) do
83
+ let(:rules) { [
84
+ rule(:atom) {
82
85
  token(skip(/[[:alpha:]]+/) | match(/[[:digit:]]+/))
83
- end
84
- end }
86
+ }
87
+ ] }
85
88
  it { should parse('abc123 ').succeeding.like reference_parser }
86
89
  it { should parse('==').failing.like reference_parser }
87
90
  end
88
91
  end
89
92
 
90
93
  context 'with a nested sequence rule' do
91
- let(:grammar) { define_grammar do
92
- rule(:atom) do
94
+ let(:rules) { [
95
+ rule(:atom) {
93
96
  token(match(/[[:alpha:]]+/) & match(/[[:digit:]]+/))
94
- end
95
- end }
97
+ }
98
+ ] }
96
99
 
97
100
  it { should parse('foo42!').succeeding.like reference_parser }
98
101
  it { should parse('val=x').failing.like reference_parser }
99
102
 
100
103
  context 'with non-capturing parsers' do
101
- let(:grammar) { define_grammar do
102
- rule :foo do
104
+ let(:rules) { [
105
+ rule(:foo) {
103
106
  token(match(/[[:alpha:]]+/) & skip(/\s+/) & match(/[[:digit:]]+/))
104
- end
105
- end }
107
+ }
108
+ ] }
106
109
  it { should parse('foo 42').succeeding.like reference_parser }
107
110
  it { should parse('foo bar').failing.like reference_parser }
108
111
  end
109
112
  end
110
113
 
111
114
  context 'with a nested optional rule' do
112
- let(:grammar) { define_grammar do
113
- rule :foo do
114
- token(optional(/\w+/))
115
- end
116
- end }
115
+ let(:rules) { [
116
+ rule(:foo) {
117
+ token(match(/\w+/).optional)
118
+ }
119
+ ] }
117
120
 
118
121
  it { should parse('foo ').succeeding.like reference_parser }
119
122
  it { should parse(' ').succeeding.like reference_parser }
120
123
 
121
124
  context 'with a non-capturing rule' do
122
- let(:grammar) { define_grammar do
123
- rule :foo do
124
- token(optional(skip(/\w+/)))
125
- end
126
- end }
125
+ let(:rules) { [
126
+ rule(:foo) {
127
+ token(skip(/\w+/).optional)
128
+ }
129
+ ] }
127
130
  it { should parse('foo ').succeeding.like reference_parser }
128
131
  it { should parse(' ').succeeding.like reference_parser }
129
132
  end
130
133
  end
131
134
 
132
135
  context 'with a nested zero-or-more rule' do
133
- let(:grammar) { define_grammar do
134
- rule :foo do
135
- token(zero_or_more(/\w/))
136
- end
137
- end }
136
+ let(:rules) { [
137
+ rule(:foo) {
138
+ token(match(/\w/).zero_or_more)
139
+ }
140
+ ] }
138
141
 
139
142
  it { should parse('foo ').succeeding.like reference_parser }
140
143
  it { should parse(' ').succeeding.like reference_parser }
141
144
 
142
145
  context 'with a non-capturing rule' do
143
- let(:grammar) { define_grammar do
144
- rule :foo do
145
- token(zero_or_more(skip(/\w/)))
146
- end
147
- end }
146
+ let(:rules) { [
147
+ rule(:foo) {
148
+ token(skip(/\w/).zero_or_more)
149
+ }
150
+ ] }
148
151
  it { should parse('foo ').succeeding.like reference_parser }
149
152
  it { should parse(' ').succeeding.like reference_parser }
150
153
  end
151
154
  end
152
155
 
153
156
  context 'with a nested one-or-more rule' do
154
- let(:grammar) { define_grammar do
155
- rule :foo do
156
- token(one_or_more(/\w/))
157
- end
158
- end }
157
+ let(:rules) { [
158
+ rule(:foo) {
159
+ token(match(/\w/).one_or_more)
160
+ }
161
+ ] }
159
162
 
160
163
  it { should parse('foo ').succeeding.like reference_parser }
161
164
  it { should parse(' ').failing.like reference_parser }
162
165
 
163
166
  context 'with a non-capturing rule' do
164
- let(:grammar) { define_grammar do
165
- rule :foo do
166
- token(one_or_more(skip(/\w/)))
167
- end
168
- end }
167
+ let(:rules) { [
168
+ rule(:foo) {
169
+ token(skip(/\w/).one_or_more)
170
+ }
171
+ ] }
169
172
  it { should parse('foo ').succeeding.like reference_parser }
170
173
  it { should parse(' ').failing.like reference_parser }
171
174
  end
172
175
  end
173
176
 
174
177
  context 'with a nested repeat' do
175
- let(:grammar) { define_grammar do
176
- rule :foo do
177
- token(repeat(/\w/, 2, 4))
178
- end
179
- end }
178
+ let(:rules) { [
179
+ rule(:foo) {
180
+ token(match(/\w/).repeat(2, 4))
181
+ }
182
+ ] }
180
183
 
181
184
  it { should parse('foo ').succeeding.like reference_parser }
182
185
  it { should parse('abcde').succeeding.like reference_parser }
183
186
  it { should parse('a ').failing.like reference_parser }
184
187
 
185
188
  context 'with a non-capturing rule' do
186
- let(:grammar) { define_grammar do
187
- rule :foo do
188
- token(repeat(skip(/\w/), 2, 4))
189
- end
190
- end }
189
+ let(:rules) { [
190
+ rule(:foo) {
191
+ token(skip(/\w/).repeat(2, 4))
192
+ }
193
+ ] }
191
194
  it { should parse('foo ').succeeding.like reference_parser }
192
195
  it { should parse('abcde').succeeding.like reference_parser }
193
196
  it { should parse('a ').failing.like reference_parser }
194
197
  end
195
198
 
196
199
  context 'with optional bounds' do
197
- let(:grammar) { define_grammar do
198
- rule :foo do
199
- token(repeat(/\w+/, 0, 1))
200
- end
201
- end }
200
+ let(:rules) { [
201
+ rule(:foo) {
202
+ token(match(/\w+/).repeat(0, 1))
203
+ }
204
+ ] }
202
205
  it { should parse('foo ').succeeding.like reference_parser }
203
206
  it { should parse(' ').succeeding.like reference_parser }
204
207
  end
205
208
 
206
209
  context 'with zero-or-more bounds' do
207
- let(:grammar) { define_grammar do
208
- rule :foo do
209
- token(repeat(skip(/\w/), 0, nil))
210
- end
211
- end }
210
+ let(:rules) { [
211
+ rule(:foo) {
212
+ token(skip(/\w/).repeat(0, nil))
213
+ }
214
+ ] }
212
215
  it { should parse('foo ').succeeding.like reference_parser }
213
216
  it { should parse(' ').succeeding.like reference_parser }
214
217
  end
215
218
 
216
219
  context 'with one-or-more bounds' do
217
- let(:grammar) { define_grammar do
218
- rule :foo do
219
- token(repeat(skip(/\w/), 1, nil))
220
- end
221
- end }
220
+ let(:rules) { [
221
+ rule(:foo) {
222
+ token(skip(/\w/).repeat(1, nil))
223
+ }
224
+ ] }
222
225
  it { should parse('foo ').succeeding.like reference_parser }
223
226
  it { should parse('a ').succeeding.like reference_parser }
224
227
  it { should parse(' ').failing.like reference_parser }
@@ -226,36 +229,28 @@ shared_examples_for 'a compiled parser with a token' do
226
229
  end
227
230
 
228
231
  context 'with a nested apply rule' do
229
- let(:grammar) { define_grammar do
230
- rule(:foo) { token(match(:digits)) }
232
+ let(:rules) { [
233
+ rule(:foo) { token(:digits) },
231
234
  rule(:digits) { match(/\d+/) }
232
- end }
235
+ ] }
233
236
 
234
237
  it { should parse('451a').succeeding.like reference_parser }
235
238
  it { should parse('hi').failing.like reference_parser }
236
239
 
237
240
  context 'applying a non-capturing rule' do
238
- let(:grammar) { define_grammar do
239
- rule(:foo) { token(match(:digits)) }
241
+ let(:rules) { [
242
+ rule(:foo) { token(:digits) },
240
243
  rule(:digits) { skip(/\d+/) }
241
- end }
244
+ ] }
242
245
  it { should parse('451a').succeeding.like reference_parser }
243
246
  it { should parse('hi').failing.like reference_parser }
244
247
  end
245
248
  end
246
249
 
247
- context 'with a nested dispatch-action rule' do
248
- let(:grammar) { define_grammar do
249
- rule(:foo) { token(dispatch_action(/\w+/)) }
250
- end }
251
- it { should parse('abc123').succeeding.like reference_parser }
252
- it { should parse(' ').failing.like reference_parser }
253
- end
254
-
255
250
  context 'with a nested skip rule' do
256
- let(:grammar) { define_grammar do
251
+ let(:rules) { [
257
252
  rule(:foo) { token(skip(/\w+/)) }
258
- end }
253
+ ] }
259
254
  it { should parse('abc123').succeeding.like reference_parser }
260
255
  it { should parse(' ').failing.like reference_parser }
261
256
  end