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
@@ -1,6 +1,7 @@
1
1
  Feature: Skip Operator
2
2
 
3
- The "~" operator before an expression means to match but ignore the result.
3
+ The "~" operator in front of a parsing expression causes the expression's
4
+ parse result to be discarded.
4
5
 
5
6
  Scenario: Sequence with skipped sub-expressions
6
7
  Given a grammar with:
@@ -0,0 +1,24 @@
1
+ Feature: super keyword
2
+
3
+ A rule that redefines a rule from an included grammar can match using the
4
+ included grammar's version of the rule by using the "super" keyword.
5
+
6
+ Scenario Outline: Included Grammar
7
+ Given a grammar called "ExprGrammar" with:
8
+ """
9
+ expr <- "A"
10
+ """
11
+ And a grammar with:
12
+ """
13
+ include ExprGrammar
14
+
15
+ expr <- super / "B"
16
+ """
17
+ When I parse <input>
18
+ Then the parse result should be <result>
19
+
20
+ Examples:
21
+ | input | result |
22
+ | "A" | "A" |
23
+ | "B" | "B" |
24
+ | "C" | FAIL |
@@ -1,9 +1,10 @@
1
1
  Feature: Token Operator
2
2
 
3
- The "@" operator before an expression means match as a token, i.e the result
4
- is the entire matched string and whitespace within the token is never
5
- automatically skipped. The expression becomes atomic, so any defined
6
- whitespace will be automatically skipped before the token.
3
+ The "@" operator in front of a parsing expression causes it to match as a
4
+ token. The parse result is the entire string matched by the expression, and
5
+ whitespace is never automatically skipped within the expression. The
6
+ expression becomes atomic, so any defined whitespace will be automatically
7
+ skipped before the token is matched.
7
8
 
8
9
  Scenario: Nested sequences and repeats
9
10
  Given a grammar with:
@@ -19,7 +20,7 @@ Feature: Token Operator
19
20
  %whitespace SPACE*
20
21
  number <- @("-"? DIGIT+ ("." DIGIT+)?)
21
22
  """
22
- When I parse "23 . 45"
23
+ When I parse " 23 . 45"
23
24
  Then the parse result should be "23"
24
25
 
25
26
  Scenario: With non-capturing sub-expressions
@@ -1,10 +1,11 @@
1
- Feature: Whitespace
1
+ Feature: Whitespace Skipping
2
2
 
3
3
  The "%whitespace" directive allows whitespace to defined in one place and
4
- skipped automatically by all atomic expressions. "%whitespace" is followed by
5
- a parsing expression and an optional block delimited by "{" and "}". The block
6
- form defines whitespace for expressions in the block, otherwise it is defined
7
- for the rest of the grammar.
4
+ skipped automatically by all atomic expressions.
5
+
6
+ "%whitespace" is followed by a parsing expression that defines how to match
7
+ whitespace. The directive can be optionally followed by a block delimited
8
+ by curly braces to limit whitespace skipping to rules inside the block.
8
9
 
9
10
  Scenario: Block form
10
11
  Given a grammar with:
@@ -16,7 +17,7 @@ Feature: Whitespace
16
17
  When I parse " foo"
17
18
  Then the parse result should be "foo"
18
19
 
19
- Scenario: Shorcut form
20
+ Scenario: Global form
20
21
  Given a grammar with:
21
22
  """
22
23
  %whitespace SPACE*
@@ -1,10 +1,13 @@
1
1
  Feature: Word Literal Expressions
2
+
3
+ A word literal is like a string literal but matches only if it is not
4
+ followed by a word character. Word literals are useful to match whole words
5
+ only. What is considered a word character can be defined using the
6
+ %word_character directive. By default a word charactacter is an alphanumeric
7
+ character or the underscore character.
2
8
 
3
- A word literal is like a string literal but delimited with backquotes (`) and
4
- it means to match the literal only if it is not followed by a word character.
5
- It is useful when you want to match whole words only. What is considered a
6
- word character can be defined using the %word_character directive. By default
7
- a word charactacter is an alphanumeric character or the underscore character.
9
+ A word literal is written like a string literal but delimited with backquotes
10
+ (`) instead of double or single quotes.
8
11
 
9
12
  Scenario Outline: Default word character definition
10
13
  Given a grammar with:
@@ -33,4 +36,5 @@ Feature: Word Literal Expressions
33
36
  Examples:
34
37
  | input | result |
35
38
  | "for " | "for" |
36
- | "for-each" | FAIL |
39
+ | "for-each" | FAIL |
40
+
@@ -0,0 +1,20 @@
1
+ Feature: Explicit Start Rule
2
+
3
+ The "%start" directive allows the specification of an explicit start rule.
4
+ By default the first rule defined in a grammar is the start rule.
5
+
6
+ Scenario Outline: Explicit Start Rule
7
+ Given a grammar with:
8
+ """
9
+ %start word
10
+
11
+ integer <- @DIGIT+
12
+ word <- @ALPHA+
13
+ """
14
+ When I parse <input>
15
+ Then the parse result should be <result>
16
+
17
+ Examples:
18
+ | input | result |
19
+ | "42" | FAIL |
20
+ | "foo" | "foo" |
@@ -0,0 +1,60 @@
1
+ Feature: Grammar Declaration
2
+
3
+ The grammar declaration names the grammar and tells rattler whether to
4
+ generate a grammar module or a parser class. In the case of the parser class,
5
+ the declaration also specifies the base class.
6
+
7
+ The declaration for a grammar module is "grammar" followed by a module name.
8
+
9
+ The declaration for a parser class is "parser", then a class name, then "<",
10
+ then the base class.
11
+
12
+ Scenario: Grammar module
13
+ Given a grammar with:
14
+ """
15
+ grammar MyGrammar
16
+ """
17
+ When I generate parser code
18
+ Then the code should contain:
19
+ """
20
+ # @private
21
+ module MyGrammar
22
+ """
23
+
24
+ Scenario: Parser class
25
+ Given a grammar with:
26
+ """
27
+ parser MyParser < Rattler::Runtime::PackratParser
28
+ """
29
+ When I generate parser code
30
+ Then the code should contain:
31
+ """
32
+ # @private
33
+ class MyParser < Rattler::Runtime::PackratParser
34
+ """
35
+
36
+ Scenario: Grammar module in a module
37
+ Given a grammar with:
38
+ """
39
+ grammar MyModule::MyGrammar
40
+ """
41
+ When I generate parser code
42
+ Then the code should contain:
43
+ """
44
+ module MyModule
45
+ # @private
46
+ module MyGrammar
47
+ """
48
+
49
+ Scenario: Parser class in a module
50
+ Given a grammar with:
51
+ """
52
+ parser MyModule::MyParser < Rattler::Runtime::PackratParser
53
+ """
54
+ When I generate parser code
55
+ Then the code should contain:
56
+ """
57
+ module MyModule
58
+ # @private
59
+ class MyParser < Rattler::Runtime::PackratParser
60
+ """
@@ -0,0 +1,19 @@
1
+ Feature: include
2
+
3
+ Any "include" statements in the grammar heading get placed at the top of the
4
+ class or module definition in the generated code.
5
+
6
+ Scenario:
7
+ Given a grammar with:
8
+ """
9
+ grammar MyGrammar
10
+
11
+ include MyHelper
12
+ """
13
+ When I generate parser code
14
+ Then the code should contain:
15
+ """
16
+ module MyGrammar #:nodoc:
17
+
18
+ include MyHelper
19
+ """
@@ -0,0 +1,27 @@
1
+ Feature: require
2
+
3
+ Any "require" statements in the grammar heading get placed at the top of the
4
+ generated code. If "require_relative" is use it gets converted into an
5
+ equivalent "require" statement compatible with Ruby 1.8.7.
6
+
7
+ Scenario: require
8
+ Given a grammar with:
9
+ """
10
+ require "logger"
11
+ """
12
+ When I generate parser code
13
+ Then the code should contain:
14
+ """
15
+ require "logger"
16
+ """
17
+
18
+ Scenario: require_relative
19
+ Given a grammar with:
20
+ """
21
+ require_relative "my_helper"
22
+ """
23
+ When I generate parser code
24
+ Then the code should contain:
25
+ """
26
+ require File.expand_path("my_helper", File.dirname(__FILE__))
27
+ """
@@ -1,6 +1,6 @@
1
1
  Feature: "Any Character" Symbol
2
2
 
3
- The "." (period) means match any single character.
3
+ A "." (period) matches any single character.
4
4
 
5
5
  Scenario Outline: Parsing
6
6
  Given a grammar with:
@@ -0,0 +1,25 @@
1
+ Feature: Character Classes
2
+
3
+ A character class defines a set of characters and matches any single
4
+ character in the set.
5
+
6
+ A character class is written as square brackets surrounding a set of
7
+ characters.
8
+
9
+ Character classes are identical in syntax and semantics to character classes
10
+ in Ruby's regular expressions.
11
+
12
+ Scenario Outline: Parsing
13
+ Given a grammar with:
14
+ """
15
+ word_char <- [A-Za-z_]
16
+ """
17
+ When I parse <input>
18
+ Then the parse result should be <result>
19
+
20
+ Examples:
21
+ | input | result |
22
+ | "foo" | "f" |
23
+ | "BAR" | "B" |
24
+ | "_ba" | "_" |
25
+ | "42" | FAIL |
@@ -1,4 +1,4 @@
1
- Feature: Whitespace
1
+ Feature: Comments
2
2
 
3
3
  Comments start with "#" and continue to the end of the line.
4
4
 
@@ -1,7 +1,9 @@
1
- Feature: Literal Expressions
1
+ Feature: String Literals
2
+
3
+ A string literal matches exact text. The expression matches if the exact
4
+ text is next in the input.
2
5
 
3
- A string literal has the same syntax as a Ruby string literal and it means to
4
- match if that exact text is next in the input.
6
+ A string literal is written exactly like a Ruby string literal.
5
7
 
6
8
  Scenario Outline: Normal String
7
9
  Given a grammar with:
@@ -1,8 +1,10 @@
1
1
  Feature: Negative Lookahead Operator
2
2
 
3
- The "!" operator before an expression means to match only if the expression
4
- would not match here and never consume any input. This is known as zero-width
5
- negative lookahead.
3
+ A negative lookahead predicate matches only if a parsing expression would NOT
4
+ match and never consumes input.
5
+
6
+ Negative lookahead is written by placing a "!" in front of a parsing
7
+ expression.
6
8
 
7
9
  Scenario Outline: Parsing
8
10
  Given a grammar with:
@@ -0,0 +1,46 @@
1
+ Feature: Nonterminals
2
+
3
+ A nonterminal is a reference to another parse rule that matches according to
4
+ that rule. Nonterminals can be used to factor the grammar or to define
5
+ recursive rules.
6
+
7
+ A nonterminal is simply the name of the other rule.
8
+
9
+ Scenario: Simple example
10
+ Given a grammar with:
11
+ """
12
+ expr <- a* "b"
13
+ a <- "a"
14
+ """
15
+ When I parse "aaab"
16
+ Then the parse result should be [["a", "a", "a"], "b"]
17
+
18
+ Scenario: Recursive definition
19
+ Given a grammar with:
20
+ """
21
+ expr <- xs "y"
22
+ xs <- "x" xs
23
+ / "x"
24
+ """
25
+ When I parse "xxxy"
26
+ Then the parse result should be [["x", ["x", "x"]], "y"]
27
+
28
+ Scenario: Direct left-recursion
29
+ Given a grammar with:
30
+ """
31
+ xs <- xs "x"
32
+ / "x"
33
+ """
34
+ When I parse "xxxx"
35
+ Then the parse result should be [[["x", "x"], "x"], "x"]
36
+
37
+ Scenario: Indirect left-recursion
38
+ Given a grammar with:
39
+ """
40
+ a <- b "x"
41
+ / "y"
42
+ b <- a "y"
43
+ / "x"
44
+ """
45
+ When I parse "xxyx"
46
+ Then the parse result should be [[["x", "x"], "y"], "x"]
@@ -0,0 +1,59 @@
1
+ Feature: One-Or-More
2
+
3
+ The "+" operator following a parsing expression causes it to match repeatedly
4
+ and succeed if the expression matches at least once, i.e. it matches one or
5
+ more times.
6
+
7
+ Scenario Outline: Capturing Expression
8
+ Given a grammar with:
9
+ """
10
+ digits <- DIGIT+
11
+ """
12
+ When I parse <input>
13
+ Then the parse result should be <result>
14
+ And the parse position should be <pos>
15
+
16
+ Examples:
17
+ | input | result | pos |
18
+ | "5" | ["5"] | 1 |
19
+ | "234" | ["2", "3", "4"] | 3 |
20
+ | "foo" | FAIL | 0 |
21
+
22
+ Scenario Outline: Non-Capturing Expression
23
+ Given a grammar with:
24
+ """
25
+ dashes <- ~"-"+
26
+ """
27
+ When I parse <input>
28
+ Then the parse result should be <result>
29
+ And the parse position should be <pos>
30
+
31
+ Examples:
32
+ | input | result | pos |
33
+ | "-" | true | 1 |
34
+ | "---" | true | 3 |
35
+ | "foo" | FAIL | 0 |
36
+
37
+ Scenario Outline: Choice of capturing or non-capturing
38
+ Given a grammar with:
39
+ """
40
+ expr <- ("a" / ~"b")*
41
+ """
42
+ When I parse <input>
43
+ Then the parse result should be <result>
44
+ And the parse position should be <pos>
45
+
46
+ Examples:
47
+ | input | result | pos |
48
+ | "aa" | ["a", "a"] | 2 |
49
+ | "aba" | ["a", "a"] | 3 |
50
+ | "bbc" | [] | 2 |
51
+
52
+ Scenario: Semantic attribute returning true
53
+ Given a grammar with:
54
+ """
55
+ expr <- (ALPHA { true })+
56
+ """
57
+ When I parse "foo "
58
+ Then the parse result should be []
59
+ And the parse position should be 3
@@ -1,7 +1,7 @@
1
1
  Feature: Optional Operator
2
2
 
3
- The "?" operator following an expression makes the it optional, meaning it
4
- succeeds even if no input is matched.
3
+ The "?" operator following a parsing expression makes it optional, so that it
4
+ succeeds even if the expression does not match.
5
5
 
6
6
  Scenario Outline: Capturing Expression
7
7
  Given a grammar with:
@@ -0,0 +1,24 @@
1
+ Feature: Ordered Choice
2
+
3
+ An ordered choice tries a series of parsing expressions in order until one
4
+ matches, and fails if none of the expressions match. The first expression
5
+ that matches is the one that is used.
6
+
7
+ An ordered choice is written as a series of parsing expressions separated by
8
+ "/". The "/" has the lowest precedence.
9
+
10
+ Scenario Outline: Parsing
11
+ Given a grammar with:
12
+ """
13
+ expr <- "A" / "B"
14
+ """
15
+ When I parse <input>
16
+ Then the parse result should be <result>
17
+
18
+ Examples:
19
+ | input | result |
20
+ | "A" | "A" |
21
+ | "AB" | "A" |
22
+ | "B" | "B" |
23
+ | "BA" | "B" |
24
+ | "C" | FAIL |