|
Output rules as a formatted S-Expression
diff --git a/examples/ebnf-peg-parser/meta.rb b/examples/ebnf-peg-parser/meta.rb
index bae601f..2f28b89 100644
--- a/examples/ebnf-peg-parser/meta.rb
+++ b/examples/ebnf-peg-parser/meta.rb
@@ -16,14 +16,14 @@ module EBNFPegMeta
EBNF::Rule.new(:_diff_2, "7.2", [:seq, "-", :postfix]).extend(EBNF::PEG::Rule),
EBNF::Rule.new(:postfix, "8", [:seq, :primary, :_postfix_1]).extend(EBNF::PEG::Rule),
EBNF::Rule.new(:_postfix_1, "8.1", [:opt, :POSTFIX]).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:primary, "9", [:alt, :HEX, :SYMBOL, :ENUM, :O_ENUM, :RANGE, :O_RANGE, :STRING1, :STRING2, :_primary_1]).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:primary, "9", [:alt, :HEX, :SYMBOL, :O_RANGE, :RANGE, :STRING1, :STRING2, :_primary_1]).extend(EBNF::PEG::Rule),
EBNF::Rule.new(:_primary_1, "9.1", [:seq, "(", :expression, ")"]).extend(EBNF::PEG::Rule),
EBNF::Rule.new(:pass, "10", [:seq, "@pass", :expression]).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_terminals, nil, [:seq], kind: :terminals).extend(EBNF::PEG::Rule),
EBNF::Rule.new(:LHS, "11", [:seq, :_LHS_1, :SYMBOL, :_LHS_2, "::="], kind: :terminal).extend(EBNF::PEG::Rule),
EBNF::Rule.new(:_LHS_1, "11.1", [:opt, :_LHS_3], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_LHS_3, "11.3", [:seq, "[", :_LHS_4, "]", :_LHS_5], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_LHS_4, "11.4", [:plus, :SYMBOL], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_LHS_5, "11.5", [:plus, " "], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_LHS_3, "11.3", [:seq, "[", :SYMBOL, "]", :_LHS_4], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_LHS_4, "11.4", [:plus, " "], kind: :terminal).extend(EBNF::PEG::Rule),
EBNF::Rule.new(:_LHS_2, "11.2", [:star, " "], kind: :terminal).extend(EBNF::PEG::Rule),
EBNF::Rule.new(:SYMBOL, "12", [:plus, :_SYMBOL_1], kind: :terminal).extend(EBNF::PEG::Rule),
EBNF::Rule.new(:_SYMBOL_1, "12.1", [:alt, :_SYMBOL_2, :_SYMBOL_3, :_SYMBOL_4, "_", "."], kind: :terminal).extend(EBNF::PEG::Rule),
@@ -36,63 +36,55 @@ module EBNFPegMeta
EBNF::Rule.new(:_HEX_3, "13.3", [:range, "a-f"], kind: :terminal).extend(EBNF::PEG::Rule),
EBNF::Rule.new(:_HEX_4, "13.4", [:range, "A-F"], kind: :terminal).extend(EBNF::PEG::Rule),
EBNF::Rule.new(:_HEX_5, "13.5", [:range, "0-9"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:ENUM, "14", [:diff, :_ENUM_1, :LHS], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_ENUM_1, "14.1", [:alt, :_ENUM_2, :_ENUM_3], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_ENUM_2, "14.2", [:seq, "[", :_ENUM_4], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_ENUM_4, "14.4", [:plus, :R_CHAR], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_ENUM_3, "14.3", [:seq, :_ENUM_5, "]"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_ENUM_5, "14.5", [:plus, :HEX], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:O_ENUM, "15", [:alt, :_O_ENUM_1, :_O_ENUM_2], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_O_ENUM_1, "15.1", [:seq, "[^", :_O_ENUM_3], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_O_ENUM_3, "15.3", [:plus, :R_CHAR], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_O_ENUM_2, "15.2", [:seq, :_O_ENUM_4, "]"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_O_ENUM_4, "15.4", [:plus, :HEX], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:RANGE, "16", [:alt, :_RANGE_1, :_RANGE_2], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_RANGE_1, "16.1", [:seq, "[", :_RANGE_3], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_RANGE_3, "16.3", [:seq, :R_CHAR, "-", :R_CHAR], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_RANGE_2, "16.2", [:seq, :_RANGE_4, "]"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_RANGE_4, "16.4", [:diff, :HEX, :HEX], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:O_RANGE, "17", [:alt, :_O_RANGE_1, :_O_RANGE_2], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_O_RANGE_1, "17.1", [:seq, "[^", :_O_RANGE_3], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_O_RANGE_3, "17.3", [:seq, :R_CHAR, "-", :R_CHAR], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_O_RANGE_2, "17.2", [:seq, :_O_RANGE_4, "]"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_O_RANGE_4, "17.4", [:diff, :HEX, :HEX], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:STRING1, "18", [:seq, "\"", :_STRING1_1, "\""], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_STRING1_1, "18.1", [:star, :_STRING1_2], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_STRING1_2, "18.2", [:diff, :CHAR, "\""], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:STRING2, "19", [:seq, "'", :_STRING2_1, "'"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_STRING2_1, "19.1", [:star, :_STRING2_2], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_STRING2_2, "19.2", [:diff, :CHAR, "'"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:CHAR, "20", [:alt, :_CHAR_1, :_CHAR_2, :_CHAR_3, :_CHAR_4], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_CHAR_1, "20.1", [:range, "#x9#xA#xD"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_CHAR_2, "20.2", [:range, "#x20-#xD7FF"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_CHAR_3, "20.3", [:range, "#xE000-#xFFFD"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_CHAR_4, "20.4", [:range, "#x10000-#x10FFFF"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:R_CHAR, "21", [:diff, :CHAR, "]"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:POSTFIX, "22", [:range, "?*+"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:PASS, "23", [:plus, :_PASS_1], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_PASS_1, "23.1", [:alt, :_PASS_2, :_PASS_3, :_PASS_4, :_PASS_5], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_PASS_2, "23.2", [:range, "#x00-#x20"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_PASS_3, "23.3", [:seq, :_PASS_6, :_PASS_7], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_PASS_6, "23.6", [:alt, :_PASS_8, "//"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_PASS_8, "23.8", [:diff, "#", "#x"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_PASS_7, "23.7", [:star, :_PASS_9], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_PASS_9, "23.9", [:range, "^#x0A#x0Dx"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_PASS_4, "23.4", [:seq, "/*", :_PASS_10, "*/"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_PASS_10, "23.10", [:star, :_PASS_11], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_PASS_11, "23.11", [:alt, :_PASS_12, :_PASS_13], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_PASS_12, "23.12", [:opt, :_PASS_14], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_PASS_14, "23.14", [:seq, "*", :_PASS_15], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_PASS_15, "23.15", [:range, "^/"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_PASS_13, "23.13", [:range, "^*"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_PASS_5, "23.5", [:seq, "(*", :_PASS_16, "*)"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_PASS_16, "23.16", [:star, :_PASS_17], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_PASS_17, "23.17", [:alt, :_PASS_18, :_PASS_19], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_PASS_18, "23.18", [:opt, :_PASS_20], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_PASS_20, "23.20", [:seq, "*", :_PASS_21], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_PASS_21, "23.21", [:range, "^)"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(:_PASS_19, "23.19", [:range, "^*"], kind: :terminal).extend(EBNF::PEG::Rule),
- EBNF::Rule.new(nil, nil, [:seq, :PASS], kind: :pass).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:RANGE, "14", [:seq, "[", :_RANGE_1, :_RANGE_2, :_RANGE_3], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_RANGE_1, "14.1", [:plus, :_RANGE_4], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_RANGE_4, "14.4", [:alt, :_RANGE_5, :_RANGE_6, :R_CHAR, :HEX], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_RANGE_5, "14.5", [:seq, :R_CHAR, "-", :R_CHAR], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_RANGE_6, "14.6", [:seq, :HEX, "-", :HEX], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_RANGE_2, "14.2", [:opt, "-"], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_RANGE_3, "14.3", [:diff, "]", :LHS], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:O_RANGE, "15", [:seq, "[^", :_O_RANGE_1, :_O_RANGE_2, "]"], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_O_RANGE_1, "15.1", [:plus, :_O_RANGE_3], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_O_RANGE_3, "15.3", [:alt, :_O_RANGE_4, :_O_RANGE_5, :R_CHAR, :HEX], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_O_RANGE_4, "15.4", [:seq, :R_CHAR, "-", :R_CHAR], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_O_RANGE_5, "15.5", [:seq, :HEX, "-", :HEX], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_O_RANGE_2, "15.2", [:opt, "-"], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:STRING1, "16", [:seq, "\"", :_STRING1_1, "\""], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_STRING1_1, "16.1", [:star, :_STRING1_2], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_STRING1_2, "16.2", [:diff, :CHAR, "\""], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:STRING2, "17", [:seq, "'", :_STRING2_1, "'"], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_STRING2_1, "17.1", [:star, :_STRING2_2], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_STRING2_2, "17.2", [:diff, :CHAR, "'"], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:CHAR, "18", [:alt, :_CHAR_1, :_CHAR_2, :_CHAR_3, :_CHAR_4], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_CHAR_1, "18.1", [:range, "#x9#xA#xD"], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_CHAR_2, "18.2", [:range, "#x20-#xD7FF"], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_CHAR_3, "18.3", [:range, "#xE000-#xFFFD"], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_CHAR_4, "18.4", [:range, "#x10000-#x10FFFF"], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:R_CHAR, "19", [:diff, :CHAR, :_R_CHAR_1], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_R_CHAR_1, "19.1", [:alt, "]", "-", :HEX], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:POSTFIX, "20", [:range, "?*+"], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:PASS, "21", [:alt, :_PASS_1, :_PASS_2, :_PASS_3, :_PASS_4], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_PASS_1, "21.1", [:range, "#x9#xA#xD#x20"], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_PASS_2, "21.2", [:seq, :_PASS_5, :_PASS_6], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_PASS_5, "21.5", [:alt, :_PASS_7, "//"], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_PASS_7, "21.7", [:diff, "#", "#x"], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_PASS_6, "21.6", [:star, :_PASS_8], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_PASS_8, "21.8", [:range, "^#xA#xD"], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_PASS_3, "21.3", [:seq, "/*", :_PASS_9, "*/"], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_PASS_9, "21.9", [:star, :_PASS_10], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_PASS_10, "21.10", [:alt, :_PASS_11, :_PASS_12], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_PASS_11, "21.11", [:opt, :_PASS_13], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_PASS_13, "21.13", [:seq, "*", :_PASS_14], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_PASS_14, "21.14", [:range, "^/"], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_PASS_12, "21.12", [:range, "^*"], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_PASS_4, "21.4", [:seq, "(*", :_PASS_15, "*)"], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_PASS_15, "21.15", [:star, :_PASS_16], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_PASS_16, "21.16", [:alt, :_PASS_17, :_PASS_18], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_PASS_17, "21.17", [:opt, :_PASS_19], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_PASS_19, "21.19", [:seq, "*", :_PASS_20], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_PASS_20, "21.20", [:range, "^)"], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_PASS_18, "21.18", [:range, "^*"], kind: :terminal).extend(EBNF::PEG::Rule),
+ EBNF::Rule.new(:_pass, nil, [:seq, :PASS], kind: :pass).extend(EBNF::PEG::Rule),
]
end
diff --git a/examples/ebnf-peg-parser/parser.rb b/examples/ebnf-peg-parser/parser.rb
index 94606ec..0088051 100644
--- a/examples/ebnf-peg-parser/parser.rb
+++ b/examples/ebnf-peg-parser/parser.rb
@@ -12,23 +12,6 @@ class EBNFPegParser
include EBNF::PEG::Parser
include EBNF::Terminals
- class ProdResult
- attr_accessor :prod
- attr_accessor :values
-
- def initialize(prod, *values)
- @prod, @values = prod, values
- end
-
- def to_ary
- values.map {|v| v.respond_to?(:to_ary) ? v.to_ary : v}.unshift(@prod)
- end
-
- def inspect
- "(#{prod} #{values.map(&:inspect).join(' ')})"
- end
- end
-
# Abstract syntax tree from parse
#
# @return [Array]
@@ -51,7 +34,7 @@ def inspect
#
# [11] LHS ::= ('[' SYMBOL+ ']' ' '+)? SYMBOL ' '* '::='
terminal(:LHS, LHS) do |value, prod|
- value.to_s.scan(/\[([^\]]+)\]\s*(\w+)\s*::=/).first
+ value.to_s.scan(/(?:\[([^\]]+)\])?\s*(\w+)\s*::=/).first
end
# Match `SYMBOL` terminal
@@ -64,46 +47,34 @@ def inspect
# Match `HEX` terminal
#
# [13] HEX ::= #x' ([a-f] | [A-F] | [0-9])+
- terminal(:HEX, HEX)
-
- # Terminal for `ENUM` is matched as part of a `primary` rule.
- #
- # [14] ENUM ::= ('[' R_CHAR+ | HEX+ ']') - LHS
- terminal(:ENUM, ENUM) do |value|
- [:range, value[1..-2]]
- end
-
- # Terminal for `O_ENUM` is matched as part of a `primary` rule.
- #
- # [15] O_ENUM ::= '[^' R_CHAR+ | HEX+ ']'
- terminal(:O_ENUM, O_ENUM) do |value|
- [:range, value[1..-2]]
+ terminal(:HEX, HEX) do |value|
+ [:hex, value]
end
# Terminal for `RANGE` is matched as part of a `primary` rule.
#
- # [16] `RANGE` ::= '[' (R_CHAR '-' R_CHAR) | (HEX - HEX) ']'
+ # [14] `RANGE` ::= '[' (R_CHAR '-' R_CHAR) | (HEX '-' HEX) ']'
terminal(:RANGE, RANGE) do |value|
[:range, value[1..-2]]
end
# Terminal for `O_RANGE` is matched as part of a `primary` rule.
#
- # [17] O_RANGE ::= '[^' (R_CHAR '-' R_CHAR) | (HEX - HEX) ']'
+ # [15] O_RANGE ::= '[^' (R_CHAR '-' R_CHAR) | (HEX '-' HEX) ']'
terminal(:O_RANGE, O_RANGE) do |value|
[:range, value[1..-2]]
end
# Match double quote string
#
- # [18] STRING1 ::= '"' (CHAR - '"')* '"'
+ # [16] STRING1 ::= '"' (CHAR - '"')* '"'
terminal(:STRING1, STRING1) do |value|
value[1..-2]
end
# Match single quote string
#
- # [19] STRING2 ::= "'" (CHAR - "'")* "'"
+ # [17] STRING2 ::= "'" (CHAR - "'")* "'"
terminal(:STRING2, STRING2) do |value|
value[1..-2]
end
@@ -112,7 +83,7 @@ def inspect
# Match `POSTFIX` terminal
#
- # [22] POSTFIX ::= [?*+]
+ # [20] POSTFIX ::= [?*+]
terminal(:POSTFIX, POSTFIX)
# The `PASS` productions is not used explicitly
@@ -142,24 +113,25 @@ def inspect
production(:declaration, clear_packrat: true) do |value, data, callback|
# value contains a declaration.
# Invoke callback
- callback.call(:terminal) if value == '@terminals'
+ callback.call(:terminals) if value == '@terminals'
nil
end
# Production for end of `rule` non-terminal.
#
- # The `value` parameter, is of the form `[{LHS: "v"}, {expression: "v"}]`.
+ # By setting `as_hash: true` in the `start_production`, the `value` parameter will be in the form `{LHS: "v", expression: "v"}`. Otherwise, it would be expressed using an array of hashes of the form `[{LHS: "v"}, {expression: "v"}]`.
#
# Clears the packrat parser when called.
#
# Create rule from expression value and pass to callback
#
# [3] rule ::= LHS expression
+ start_production(:rule, as_hash: true)
production(:rule, clear_packrat: true) do |value, data, callback|
# value contains an expression.
# Invoke callback
- id, sym = value.first[:LHS]
- expression = value.last[:expression]
+ id, sym = value[:LHS]
+ expression = value[:expression]
callback.call(:rule, EBNF::Rule.new(sym.to_sym, id, expression))
nil
end
@@ -180,7 +152,7 @@ def inspect
# Production for end of `alt` non-terminal.
# Passes through the optimized value of the seq production as follows:
#
- # The `value` parameter, is of the form `[{seq: "v"}, {_alt_1: "v"}]`.
+ # The `value` parameter, is of the form `{seq: "v", _alt_1: "v"}`.
#
# [:seq foo] => foo
# [:seq foo bar] => [:seq foo bar]
@@ -188,11 +160,12 @@ def inspect
# Note that this also may just pass through from `_alt_1`
#
# [5] alt ::= seq ('|' seq)*
+ start_production(:alt, as_hash: true)
production(:alt) do |value|
- if value.last[:_alt_1].length > 0
- [:alt, value.first[:seq]] + value.last[:_alt_1]
+ if value[:_alt_1].length > 0
+ [:alt, value[:seq]] + value[:_alt_1]
else
- value.first[:seq]
+ value[:seq]
end
end
@@ -223,14 +196,15 @@ def inspect
# `Diff` production returns concatenated postfix values
#
- # The `value` parameter, is of the form `[{postfix: "v"}, {_diff_1: "v"}]`.
+ # The `value` parameter, is of the form `{postfix: "v", _diff_1: "v"}`.
#
# [7] diff ::= postfix ('-' postfix)?
+ start_production(:diff, as_hash: true)
production(:diff) do |value|
- if value.last[:_diff_1]
- [:diff, value.first[:postfix], value.last[:_diff_1]]
+ if value[:_diff_1]
+ [:diff, value[:postfix], value[:_diff_1]]
else
- value.first[:postfix]
+ value[:postfix]
end
end
@@ -241,7 +215,7 @@ def inspect
# Production for end of `postfix` non-terminal.
# Either returns the `primary` production value, or as modified by the `postfix`.
#
- # The `value` parameter, is of the form `[{primary: "v"}, {_postfix_1: "v"}]`.
+ # The `value` parameter, is of the form `{primary: "v", _postfix_1: "v"}`.
#
# [:primary] => [:primary]
# [:primary, '*'] => [:star, :primary]
@@ -249,13 +223,14 @@ def inspect
# [:primary, '?'] => [:opt, :primary]
#
# [8] postfix ::= primary POSTFIX?
+ start_production(:postfix, as_hash: true)
production(:postfix) do |value|
# Push result onto input stack, as the `diff` production can have some number of `postfix` values that are applied recursively
- case value.last[:_postfix_1]
- when "*" then [:star, value.first[:primary]]
- when "+" then [:plus, value.first[:primary]]
- when "?" then [:opt, value.first[:primary]]
- else value.first[:primary]
+ case value[:_postfix_1]
+ when "*" then [:star, value[:primary]]
+ when "+" then [:plus, value[:primary]]
+ when "?" then [:opt, value[:primary]]
+ else value[:primary]
end
end
@@ -314,11 +289,11 @@ def initialize(input, **options, &block)
**options
) do |context, *data|
rule = case context
- when :terminal
+ when :terminals
# After parsing `@terminals`
# This changes the state of the parser to treat subsequent rules as terminals.
parsing_terminals = true
- rule = EBNF::Rule.new(nil, nil, data.first, kind: :terminal)
+ rule = EBNF::Rule.new(nil, nil, data.first, kind: :terminals)
when :pass
# After parsing `@pass`
# This defines a specific rule for whitespace.
diff --git a/examples/isoebnf/README.md b/examples/isoebnf/README.md
new file mode 100644
index 0000000..957fb6e
--- /dev/null
+++ b/examples/isoebnf/README.md
@@ -0,0 +1,136 @@
+# ISO EBNF Parser example
+
+This example implements an [ISO/IEC 14977][] parser which parses compatible grammars into [S-Expressions][S-Expression]. This allows the resulting [S-Expressions][S-Expression] to drive a [PEG][]/[Packrat][] Parser to parser documents defined using [ISO/IEC 14977][].
+
+## Parsing the Grammar
+
+ require 'ebnf'
+
+ ebnf = ISOEBNFPegParser.new(File.open("examples/ebnf.isoebnf"))
+
+Output rules and terminals as [S-Expressions][S-Expression]:
+
+ puts ebnf.to_sxp
+
+This generates a [S-Expression][] form of the grammar suitable for use by {EBNF}.
+
+ (
+ (rule syntax (star syntax_rule))
+ (rule syntax_rule
+ (seq meta_identifier defining_symbol definitions_list terminator_symbol))
+ (rule definitions_list
+ (seq single_definition (star (seq definition_separator_symbol definitions_list))))
+ (rule single_definition (seq term (star (seq "," term))))
+ (rule term (seq factor (opt (seq "-" exception))))
+ (rule exception (seq factor))
+ (rule factor (seq (opt (seq integer "*")) primary))
+ (rule primary
+ (alt optional_sequence repeated_sequence special_sequence grouped_sequence
+ meta_identifier terminal_string empty ))
+ (rule optional_sequence
+ (seq start_option_symbol definitions_list end_option_symbol))
+ (rule repeated_sequence
+ (seq start_repeat_symbol definitions_list end_repeat_symbol))
+ (rule grouped_sequence (seq "(" definitions_list ")"))
+ (rule letter
+ (alt "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R"
+ "S" "T" "U" "V" "W" "X" "Y" "Z" "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k"
+ "l" "m" "n" "o" "p" "q" "r" "s" "t" "u" "v" "w" "x" "y" "z" ))
+ (rule decimal_digit (alt "0" "1" "2" "3" "4" "5" "6" "7" "8" "9"))
+ (rule integer (seq decimal_digit (star decimal_digit)))
+ (rule meta_identifier (seq letter (star meta_identifier_character)))
+ (rule meta_identifier_character (alt letter decimal_digit "_"))
+ (rule terminal_string
+ (alt
+ (seq (seq "'" first_terminal_character (star first_terminal_character) "'"))
+ (seq (seq "\"" second_terminal_character (star second_terminal_character) "\""))) )
+ (rule first_terminal_character (seq terminal_character))
+ (rule second_terminal_character (seq terminal_character))
+ (rule special_sequence (seq "?" (star special_sequence_character) "?"))
+ (rule special_sequence_character (seq terminal_character))
+ (rule terminal_character
+ (alt letter decimal_digit concatenate_symbol defining_symbol
+ definition_separator_symbol end_comment_symbol end_group_symbol
+ end_option_symbol end_repeat_symbol except_symbol first_quote_symbol
+ repetition_symbol second_quote_symbol special_sequence_symbol
+ start_comment_symbol start_group_symbol start_option_symbol
+ start_repeat_symbol terminator_symbol other_character ))
+ (rule other_character
+ (alt " " ":" "+" "_" "%" "@" "&" "#" "$" "<" ">" "\\" "^" "`" "~"))
+ (rule empty (seq ""))
+ (rule defining_symbol (alt "=" ":"))
+ (rule definition_separator_symbol (alt "|" "/" "!"))
+ (rule terminator_symbol (alt ";" "."))
+ (rule start_option_symbol (alt "[" "(/"))
+ (rule end_option_symbol (alt "]" "/)"))
+ (rule start_repeat_symbol (alt "{" "(:"))
+ (rule end_repeat_symbol (alt "}" ":)")))
+
+This can then be used as input to {EBNF.parse} to transform [EBNF][] to [PEG][] for parsing examples of the grammar using {EBNF::PEG::Parser}.
+
+ ebnf --input-format sxp --peg ebnf.sxp -o ebnf.peg.sxp
+
+Note, however, that [ISO EBNF][ISO/IEC 14977] doesn't distinguish between terminal rules and non-terminal rules, so all rules are parsed as non-terminal rules with strings the only terminals. Whereas, the W3C [EBNF][] {file:iso-ebnf.ebnf definition of the grammar} does use terminal rules.
+
+When parsing files with this grammar, rules that are all capitalized _will_ be treated as terminal productions, although this is an proprietary interpretation of the specification.
+
+## Example Walkthrough
+
+This example uses the [EBNF][] grammar from {file:iso-ebnf.ebnf} to generate {file:meta}, which includes the resulting `RULES` table, used by {file:parser} to implement a parser for the grammar.
+
+The first step is defining regular expressions for terminals used within the grammar. Note that the parser can operate without terminal definitions, but this can greatly improve parser performance.
+
+The {file:parser} is implemented using the {ISOEBNFPegParser} class, which includes {EBNF::PEG::Parser}.
+
+### Parser basics
+The parser operates directly using the rules from the abstract syntax tree generated by turning the original [ISO EBNF][ISO/IEC 14977] grammar using {EBNF::PEG#make_peg}. Tokens are derived from terminal rules defined in the grammar or contained inline through non-terminal rule definitions. Tokens are either strings, which must be matched exactly, or symbols, which identify a regular expression used to match the terminal and yield a token. The association between terminal symbols and their regular expressions along with processing rules to invoke when they are identified are described in [Terminal definitions](#Terminal_definitions).
+
+The parser starts with the specified rule, `syntax` in this case, and executes that rule, which is expected to completely parse the input file potentially leaving some whitespace.
+
+Non-terminal rules have an expression using one of the following:
+
+`seq`
+: A sequence of rules or terminals. If any (other than `opt` or `star`) to not parse, the rule is terminated as unmatched.
+`opt`
+: An optional rule or terminal. It either results in the matching rule or returns `nil`.
+`alt`
+: A list of alternative rules, which are attempted in order. It terminates with the first matching rule, or is terminated as unmatched, if no such rule is found.
+`plus`
+: A sequence of one or more of the matching rule. If there is no such rule, it is terminated as unmatched; otherwise, the result is an array containing all matched input.
+`rept m n`
+: A sequence of at lest `m` and at most `n` of the matching rule. It will always return an array.
+`star`
+: A sequence of zero or more of the matching rule. It will always return an array.
+
+The starting rule will typically be of the form `(star sub_rule)` which will attempt to parse that sub rule until the end of input.
+
+If a rule matches, it enters a _production_, which may invoke a _start production before matching is attempted, and will call any _production_ either if matched, or unmatched. That _production_ may choose to evaluate the returned abstract syntax tree to simplify the result, or create some semantic representation of that value.
+
+Due to the nature of [PEG][] parsers, the same rule may be attempted at the same input location many times; this is optimized by use of a [Packrat][] memoizing cache, which remembers the result of a previous successful evaluation and short-circuits further execution.
+
+Processing continues by continuing to look for productions sequence and pushing those productions onto the stack. When a production is complete, any associated _production handler_ is invoked, after popping off the top of the `prod_data` stack. The just removed hash is passed as `current` to the _production handler_. This is typically where the work of the parser happens. See [Production definitions](#Production_definitions) for more information.
+
+### Terminal definitions
+The {file:parser} uses a DSL to specify `terminals` and `productions` associated with rules in the grammar. Each `terminal` specifies the rule name, associated regular expression, and a block which is invoked when the parser recognizes the terminal:
+
+ terminal(:integer, /\d+/) do |value, prod|
+ value.to_i
+ end
+
+In this terminal definition, the `integer` terminal is recognized using the `/\d+/`. When found, the value of the integer is returned for use by productions which include it.
+
+### Production definitions
+Looking at the grammar itself, we can see that the first declaration is
+
+ [1] syntax ::= syntax_rule*
+
+[Ruby]: https://ruby-lang.org/
+[YARD]: https://yardoc.org/
+[YARD-GS]: https://rubydoc.info/docs/yard/file/docs/GettingStarted.md
+[PDD]: https://lists.w3.org/Archives/Public/public-rdf-ruby/2010May/0013.html
+[EBNF]: https://www.w3.org/TR/REC-xml/#sec-notation
+[EBNF doc]: https://rubydoc.info/github/dryruby/ebnf/
+[Packrat]: https://pdos.csail.mit.edu/~baford/packrat/thesis/
+[PEG]: https://en.wikipedia.org/wiki/Parsing_expression_grammar
+[ISO/IEC 14977]:https://www.iso.org/standard/26153.html
+[S-expression]: https://en.wikipedia.org/wiki/S-expression
diff --git a/examples/isoebnf/Rakefile b/examples/isoebnf/Rakefile
new file mode 100644
index 0000000..ee6b779
--- /dev/null
+++ b/examples/isoebnf/Rakefile
@@ -0,0 +1,32 @@
+task default: ['iso-ebnf.sxp', 'iso-ebnf.peg.sxp', :meta, :doc]
+
+desc 'Build rules table'
+task meta: "meta.rb"
+
+file "meta.rb" => "../../etc/iso-ebnf.ebnf" do |t|
+ sh %{
+ ebnf --peg --format rb \
+ --mod-name ISOEBNFMeta \
+ --output meta.rb \
+ #{t.prerequisites.first}
+ }
+end
+
+file 'iso-ebnf.sxp' => "../../etc/iso-ebnf.ebnf" do |t|
+ sh %{
+ ebnf --output iso-ebnf.sxp #{t.prerequisites.first}
+ }
+end
+
+file 'iso-ebnf.peg.sxp' => "../../etc/iso-ebnf.ebnf" do |t|
+ sh %{
+ ebnf --peg --output iso-ebnf.peg.sxp #{t.prerequisites.first}
+ }
+end
+
+desc "Generate literal documentation for parser"
+task doc: %w(doc/parser.html)
+
+file "doc/parser.html" => "parser.rb" do
+ `rocco -t doc/layout.mustache parser.rb -o doc`
+end
diff --git a/examples/isoebnf/doc/layout.mustache b/examples/isoebnf/doc/layout.mustache
new file mode 100644
index 0000000..c62137d
--- /dev/null
+++ b/examples/isoebnf/doc/layout.mustache
@@ -0,0 +1,491 @@
+
+
+
+
+ {{ title }}
+
+
+
+
+
+ {{#sources?}}
+
+ {{/sources?}}
+
+
+
+ {{ title }} |
+ |
+
+
+
+ {{#sections}}
+
+ |
+
+ {{{ docs }}}
+ |
+
+
+ |
+
+ {{/sections}}
+
+
+
+
+
+
+ parser.rb |
+ |
+
+
+
+
+
+
+ EBNF Parser for EISO BNF.
+
+Produces an Abstract Synatx Tree in S-Expression form for the input grammar file
+ |
+
+ require 'ebnf'
+require 'ebnf/terminals'
+require 'ebnf/peg/parser'
+require 'meta'
+require 'sxp'
+require 'logger'
+
+class ISOEBNFPegParser
+ include EBNF::PEG::Parser |
+
+
+ |
+
+ The base for terminal-character, which omits "'", '"', and '?'.
+Could be more optimized, and one might quible
+with the overly-strictly defined character set,
+but it is correct.
+ |
+
+ TERMINAL_CHARACTER_BASE = %r{
+ [a-zA-Z0-9] | # letter | decimal digit
+ , | # concatenate symbol
+ = | # defining symbol
+ [\|\/!] | # definition separator symbol
+ \*\) | # end comment symbol
+ \) | # end group symbol
+ \] | # end option symbol
+ \} | # end repeat symbol
+ \- | # except symbol
+
+# DIVIDER
+
+ \* | # repetition symbol
+
+# DIVIDER
+
+ \(\* | # start comment symbol
+ \( | # start group symbol
+ \[ | # start option symbol
+ \{ | # start repeat symbol
+ [;\.] | # terminator symbol
+ [:+_%@&$<>^\x20\x23\\`~] # other character
+ }x
+
+ TERMINAL_CHARACTER = %r{#{TERMINAL_CHARACTER_BASE}|['"\?]}
+ FIRST_TERMINAL_CHARACTER = %r{#{TERMINAL_CHARACTER_BASE}|["\?]}
+ SECOND_TERMINAL_CHARACTER = %r{#{TERMINAL_CHARACTER_BASE}|['\?]}
+ SPECIAL_SEQUENCE_CHARACTER = %r{#{TERMINAL_CHARACTER_BASE}|['"]} |
+
+
+ |
+
+ \' | # first quote symbol
+ |
+
+
+ |
+
+
+ |
+
+ \" | # second quote symbol
+\? | # special sequence symbol
+ |
+
+ terminal(:integer, /\d+/) do |value, prod|
+ value.to_i
+ end |
+
+
+ |
+
+ Abstract syntax tree from parse
+
+@return [ArrayEBNF::Rule]
+ |
+
+ terminal(:meta_identifier, /[a-zA-Z][a-zA-Z0-9_]*/) do |value|
+ value.to_sym
+ end |
+
+
+ |
+
+ [14] integer ::= decimal_digit+
+ |
+
+ terminal(:terminal_string, /(?:'#{FIRST_TERMINAL_CHARACTER}+')|(?:"#{SECOND_TERMINAL_CHARACTER}+")/x) do |value|
+ value[1..-2]
+ end |
+
+
+ |
+
+ [15] meta_identifier ::= letter meta_identifier_character*
+ |
+
+ terminal(:special_sequence, /\?#{SPECIAL_SEQUENCE_CHARACTER}+\?/) |
+
+
+ |
+
+ [17] terminal_string ::= ("'" first_terminal_character+ "'")
+| ('"' second_terminal_character+ '"')
+ |
+
+ terminal(:terminal_character, TERMINAL_CHARACTER) |
+
+
+ |
+
+ [20] special_sequence ::= '?' special_sequence_character* '?'
+ |
+
+ terminal(:empty, //)
+
+
+# DIVIDER
+
+ terminal(:definition_separator_symbol, /[\|\/!]/) |
+
+
+ |
+
+ [22] terminal_character ::= [a-zA-Z0-9]
+| [,=;*}#x2d?([{;]
+| '*)'
+| '(*'
+| ']'
+| other_character
+ |
+
+ terminal(:terminator_symbol, /[;\.]/) |
+
+
+ |
+
+ [25] empty ::= ''
+ |
+
+ terminal(:start_option_symbol, /\[|(?:\(\/)/) |
+
+
+ |
+
+ [26] definition_separator_symbol ::= '|' | '/' | '!'
+ |
+
+ terminal(:end_option_symbol, /\]/) |
+
+
+ |
+
+ [27] terminator_symbol ::= ';' | '.'
+ |
+
+ terminal(:start_repeat_symbol, /{|\(:/) |
+
+
+ |
+
+ `[28] startoptionsymbol ::= '['
+ |
+
+ terminal(:end_repeat_symbol, /}|:\)/) |
+
+
+ |
+
+ [29] end_option_symbol ::= ']'
+ |
+
+
+ |
+
+
+ |
+
+ [30] start_repeat_symbol ::= '{' | '(:'
+ |
+
+ production(:syntax_rule, clear_packrat: true) do |value, data, callback| |
+
+
+ |
+
+ [31] end_repeat_symbol ::= '}' | ':)'
+ |
+
+ sym = value[0][:meta_identifier]
+ definitions_list = value[2][:definitions_list]
+ callback.call(:rule, EBNF::Rule.new(sym.to_sym, nil, definitions_list))
+ nil
+ end |
+
+
+
+
+ Non-terminal productions
+ |
+
+ start_production(:definitions_list, as_hash: true)
+ production(:definitions_list) do |value|
+ if value[:_definitions_list_1].length > 0
+ [:alt, value[:single_definition]] + value[:_definitions_list_1]
+ else
+ value[:single_definition]
+ end
+ end
+ production(:_definitions_list_1) do |value|
+ Array(value.first)
+ end
+ start_production(:_definitions_list_2, as_hash: true)
+ production(:_definitions_list_2) do |value|
+ if Array(value[:definitions_list]).first == :alt
+ value[:definitions_list][1..-1]
+ else
+ [value[:definitions_list]]
+ end
+ end |
+
+
+ |
+
+ [2] syntax_rule ::= meta_identifier '=' definitions_list terminator_symbol
+ |
+
+ start_production(:single_definition, as_hash: true)
+ production(:single_definition) do |value|
+ if value[:_single_definition_1].length > 0
+ [:seq, value[:term]] + value[:_single_definition_1]
+ else
+ value[:term]
+ end
+ end
+ production(:_single_definition_1) do |value|
+ value.map {|a1| a1.last[:term]}.compact # Get rid of '|'
+ end |
+
+
+ |
+
+ value contains an expression.
+Invoke callback
+ |
+
+ start_production(:term, as_hash: true)
+ production(:term) do |value|
+ if value[:_term_1]
+ [:diff, value[:factor], value[:_term_1]]
+ else
+ value[:factor]
+ end
+ end
+ production(:_term_1) do |value|
+ value.last[:exception] if value
+ end |
+
+
+ |
+
+ Setting as_hash: true in the start production makes the value of the form of a hash, rather than an array of hashes.
+
+[3] definitions_list ::= single_definition (definition_separator_symbol definitions_list)*
+ |
+
+ start_production(:exception, as_hash: true)
+ production(:exception) do |value|
+ value[:factor]
+ end |
+
+
+ |
+
+ [4] single_definition ::= term (',' term)*
+ |
+
+ start_production(:factor, as_hash: true)
+ production(:factor) do |value|
+ if value[:_factor_1]
+ [:rept, value[:_factor_1], value[:_factor_1], value[:primary]]
+ else
+ value[:primary]
+ end
+ end
+ production(:_factor_2) do |value|
+ value.first[:integer]
+ end |
+
+
+ |
+
+ [5] term ::= factor ('-' exception)?
+ |
+
+ production(:optional_sequence) do |value|
+ [:opt, value[1][:definitions_list]]
+ end |
+
+
+ |
+
+ [6] exception ::= factor
+ |
+
+ production(:repeated_sequence) do |value|
+ [:star, value[1][:definitions_list]]
+ end |
+
+
+ |
+
+ [7] factor ::= (integer '*')? primary
+ |
+
+ production(:grouped_sequence) do |value|
+ [:seq, value[1][:definitions_list]]
+ end |
+
+
+ |
+
+ [9] optional_sequence ::= start_option_symbol definitions_list end_option_symbol
+ |
+
+ def initialize(input, **options, &block) |
+
+
+ |
+
+ [10] repeated_sequence ::= start_repeat_symbol definitions_list end_repeat_symbol
+ |
+
+ if options.has_key?(:level)
+ options[:logger] = Logger.new(STDERR)
+ options[:logger].level = options[:level]
+ options[:logger].formatter = lambda {|severity, datetime, progname, msg| "#{severity} #{msg}\n"}
+ end |
+
+
+ |
+
+ [11] grouped_sequence ::= '(' definitions_list ')'
+ |
+
+ @input = input.respond_to?(:read) ? input.read : input.to_s
+
+ parsing_terminals = false
+ @ast = []
+ parse(@input,
+ :syntax,
+ ISOEBNFMeta::RULES,
+ whitespace: %r{([\x09-\x0d\x20]|(?:\(\*(?:(?:\*[^\)])|[^*])*\*\)))+},
+ **options
+ ) do |context, *data|
+ rule = case context
+ when :rule |
+
+
+
+
+ Parser invocation.
+
+On start, yield ourselves if a block is given, otherwise, return this parser instance
+
+@param [#read, #to_s] input
+@param [Hash{Symbol => Object}] options
+@option options [Boolean] :level
+ Trace level. 0(debug), 1(info), 2(warn), 3(error).
+@return [EBNFParser]
+ |
+
+ rule = data.first
+ rule.kind = :terminal if parsing_terminals
+ rule
+ end
+ @ast << rule if rule
+ end
+ @ast
+ end |
+
+
+ |
+
+ If the level option is set, instantiate a logger for collecting trace information.
+ |
+
+ def to_sxp
+ require 'sxp' unless defined?(SXP) |
+
+
+ |
+
+ Read input, if necessary, which will be used in a Scanner.
+ |
+
+ SXP::Generator.string(@ast.map(&:for_sxp))
+ end
+end |
+
+
+ |
+
+ A rule which has already been turned into a Rule object.
+ |
+
+
+ |
+
+
+ |
+
+ Output formatted S-Expression of grammar
+ |
+
+
+ |
+
+
+ |
+
+ Output rules as a formatted S-Expression
+
+ |
+
+
+ |
+
+
+ \|\s*}, '')
+ (ndx > 0 ? (rule.alt? ? '|' : '') : '::=')
+ when :abnf
+ formatted.sub!(%r{\s*/\s*}, '')
+ (ndx > 0 ? '=/' : '=')
+ else
+ formatted.sub!(%r{\s*\|\s*}, '')
+ (ndx > 0 ? (rule.alt? ? '|' : '') : '=')
+ end
+ lines << OpenStruct.new(id: ("[#{rule.id}]" if rule.id),
+ sym: (rule.sym if ndx == 0 || format == :abnf),
+ assign: assign,
+ formatted: formatted)
+ end
+ if format == :isoebnf
+ lines << OpenStruct.new(assign: ';')
+ end
+ lines
+ else
+ OpenStruct.new(id: ("[#{rule.id}]" if rule.id),
+ sym: rule.sym,
+ assign: (format == :ebnf ? '::=' : '='),
+ formatted: (formatted_expr + (format == :isoebnf ? ' ;' : '')))
+ end
+ end
+ end.flatten
+ out.write eruby.evaluate(format: format, rules: formatted_rules)
return
rescue LoadError
- $stderr.puts "Generating HTML requires haml gem to be loaded"
+ $stderr.puts "Generating HTML requires erubis gem to be loaded"
end
end
# Format each rule, considering the available rhs size
rules.each do |rule|
buffer = if rule.pass?
- "%-#{lhs_length-2}s" % "@pass"
+ "\n%-#{lhs_length-2}s " % "@pass"
+ elsif rule.kind == :terminals
+ "\n%-#{lhs_length-2}s" % "@terminals"
else
lhs_fmt % {id: "[#{rule.id}]", sym: rule.sym}
end
- formatted_expr = format(rule.expr)
- if formatted_expr.length > rhs_length
- buffer << format(rule.expr, ("\n" + " " * lhs_length))
+ formatted_expr = self.send(format_meth, rule.expr)
+ if formatted_expr.length > rhs_length && (format != :abnf || rule.alt?)
+ if format == :abnf
+ # No whitespace, use =/
+ self.send(format_meth, rule.expr, sep: "--rule-extensions--").
+ split(/\s*--rule-extensions--\s*/).each_with_index do |formatted, ndx|
+ if ndx > 0
+ buffer << "\n" + lhs_fmt.sub('= ', '=/') % {id: "[#{rule.id}]", sym: rule.sym}
+ end
+ buffer << formatted.sub(/\s*\/\s*/, '')
+ end
+ else
+ # Space out past "= "
+ buffer << self.send(format_meth, rule.expr, sep: ("\n" + " " * (lhs_length + (rule.alt? ? 2 : 4) - (format == :ebnf ? 0 : 2))))
+ buffer << ("\n" + " " * (lhs_length) + ';') if format == :isoebnf
+ end
else
- buffer << formatted_expr
+ buffer << formatted_expr + (format == :isoebnf ? ' ;' : '')
end
+ buffer << "\n\n" if [:terminals, :pass].include?(rule.kind)
out.puts(buffer)
end
end
protected
+
+ ##
+ # W3C EBNF Formatters
+ ##
+
# Format the expression part of a rule
- def format(expr, sep = nil)
+ def format_ebnf(expr, sep: nil, embedded: false)
return (@options[:html] ? %(#{expr}) : expr.to_s) if expr.is_a?(Symbol)
if expr.is_a?(String)
- if expr.length == 1
- return format_char(expr)
- elsif expr =~ /\A#x\h+/
- return (@options[:html] ? %(#{expr}) : expr)
- elsif expr =~ /"/
- return (@options[:html] ? %('#{escape(expr, "'")}') : %('#{escape(expr, "'")}'))
- else
- return (@options[:html] ? %("#{escape(expr, '"')}") : %("#{escape(expr, '"')}"))
- end
+ return expr.length == 1 ?
+ format_ebnf_char(expr) :
+ format_ebnf_string(expr, expr.include?('"') ? "'" : '"')
end
parts = {
alt: (@options[:html] ? "| " : "| "),
@@ -129,40 +233,75 @@ def format(expr, sep = nil)
rparen = (@options[:html] ? ") " : ")")
case expr.first
+ when :istr
+ # Looses fidelity, but, oh well ...
+ format_ebnf(expr.last, embedded: true)
when :alt, :diff
this_sep = (sep ? sep : " ") + parts[expr.first.to_sym]
- expr[1..-1].map {|e| format(e)}.join(this_sep)
+ res = expr[1..-1].map {|e| format_ebnf(e, embedded: true)}.join(this_sep)
+ embedded ? (lparen + res + rparen) : res
when :star, :plus, :opt
- raise "Expected star expression to have a single operand" unless expr.length == 2
char = parts[expr.first.to_sym]
- r = format(expr[1])
- (r.start_with?("(") || Array(expr[1]).length == 1) ? "#{r}#{char}" : "(#{r})#{char}"
+ r = format_ebnf(expr[1], embedded: true)
+ "#{r}#{char}"
when :hex
- (@options[:html] ? %(#{expr.last}) : expr.last)
+ escape_ebnf_hex(expr.last[2..-1].hex.chr(Encoding::UTF_8))
when :range
- format_range(expr.last)
+ format_ebnf_range(expr.last)
when :seq
this_sep = (sep ? sep : " ")
- expr[1..-1].map {|e| r = format(e); Array(e).length > 2 ? "#{lparen}#{r}#{rparen}" : r}.join(this_sep)
+ res = expr[1..-1].map do |e|
+ format_ebnf(e, embedded: true)
+ end.join(this_sep)
+ embedded ? (lparen + res + rparen) : res
+ when :rept
+ # Expand repetition
+ min, max, value = expr[1..-1]
+ if min == 0 && max == 1
+ format_ebnf([:opt, value], sep: sep, embedded: embedded)
+ elsif min == 0 && max == '*'
+ format_ebnf([:star, value], sep: sep, embedded: embedded)
+ elsif min == 1 && max == '*'
+ format_ebnf([:plus, value], sep: sep, embedded: embedded)
+ else
+ val2 = [:seq]
+ while min > 0
+ val2 << value
+ min -= 1
+ max -= 1 unless max == '*'
+ end
+ if max == '*'
+ val2 << [:star, value]
+ else
+ opt = nil
+ while max > 0
+ opt = [:opt, opt ? [:seq, value, opt] : value]
+ max -= 1
+ end
+ val2 << opt if opt
+ end
+ format_ebnf(val2, sep: sep, embedded: embedded)
+ end
else
raise "Unknown operator: #{expr.first}"
end
end
# Format a single-character string, prefering hex for non-main ASCII
- def format_char(c)
+ def format_ebnf_char(c)
case c.ord
- when 0x22 then (@options[:html] ? %('"') : %{'"'})
- when (0x23..0x7e) then (@options[:html] ? %("#{c}") : %{"#{c}"})
- else (@options[:html] ? %(#{escape_hex(c)}) : escape_hex(c))
+ when (0x21) then (@options[:html] ? %("#{c}") : %{"#{c}"})
+ when 0x22 then (@options[:html] ? %('"') : %{'"'})
+ when (0x23..0x7e) then (@options[:html] ? %("#{c}") : %{"#{c}"})
+ when (0x80..0xFFFD) then (@options[:html] ? %("#{c}") : %{"#{c}"})
+ else escape_ebnf_hex(c)
end
end
# Format a range
- def format_range(string)
+ def format_ebnf_range(string)
lbrac = (@options[:html] ? "[ " : "[")
rbrac = (@options[:html] ? "] " : "]")
- dash = (@options[:html] ? "- " : "-")
buffer = lbrac
s = StringScanner.new(string)
@@ -171,53 +310,386 @@ def format_range(string)
when s.scan(/\A[!"\u0024-\u007e]+/)
buffer << (@options[:html] ? %(#{s.matched}) : s.matched)
when s.scan(/\A#x\h+/)
- buffer << (@options[:html] ? %(#{s.matched}) : s.matched)
- when s.scan(/\A-/)
- buffer << dash
+ buffer << escape_ebnf_hex(s.matched[2..-1].hex.chr(Encoding::UTF_8))
else
- buffer << (@options[:html] ? %(#{escape_hex(s.getch)}) : escape_hex(s.getch))
+ buffer << escape_ebnf_hex(s.getch)
end
end
buffer + rbrac
end
# Escape a string, using as many UTF-8 characters as possible
- def escape(string, quote = '"')
- buffer = ""
+ def format_ebnf_string(string, quote = '"')
string.each_char do |c|
- buffer << case (u = c.ord)
- when (0x00..0x1f) then "#x%02X" % u
- when quote.ord then "#x%02X" % u
- else c
+ case c.ord
+ when 0x00..0x19, quote.ord
+ raise RangeError, "cannot format #{string.inspect} as an EBNF String: #{c.inspect} is out of range" unless
+ ISOEBNF::TERMINAL_CHARACTER.match?(c)
end
end
- buffer
+
+ "#{quote}#{string}#{quote}"
end
- def escape_hex(u)
+ def escape_ebnf_hex(u)
fmt = case u.ord
+ when 0x00..0x20 then "#x%02X"
when 0x0000..0x00ff then "#x%02X"
when 0x0100..0xffff then "#x%04X"
else "#x%08X"
end
- sprintf(fmt, u.ord)
- end
-
- HAML_DESC = %q(
- %table.grammar
- %tbody#grammar-productions
- - rules.each do |rule|
- %tr{id: "grammar-production-#{rule.sym}"}
- - if rule.pass?
- %td{colspan: 3}
- %code<="@pass"
- - else
- %td<= "[#{rule.id}]"
- %td<
- %code<= rule.sym
- %td<= "::="
- %td
- != yield rule
+ char = fmt % u.ord
+ if @options[:html]
+ if u.ord <= 0x20
+ char = %(#{char})
+ elsif u.ord < 0x7F
+ char = %(#{char})
+ elsif u.ord == 0x7F
+ char = %(#{char})
+ elsif u.ord <= 0xFF
+ char = %(#{char})
+ else
+ char = %(#{char})
+ end
+ %(#{char})
+ else
+ char
+ end
+ end
+
+ ##
+ # ABNF Formatters
+ ##
+
+ # Format the expression part of a rule
+ def format_abnf(expr, sep: nil, embedded: false, sensitive: true)
+ return (@options[:html] ? %(#{expr}) : expr.to_s) if expr.is_a?(Symbol)
+ if expr.is_a?(String)
+ if expr.length == 1
+ return format_abnf_char(expr)
+ elsif expr.start_with?('%')
+ # Already encoded
+ return expr
+ elsif expr =~ /"/
+ # Split into segments
+ segments = expr.split('"')
+
+ return format_abnf_char(expr) if segments.empty?
+
+ seq = segments.inject([]) {|memo, s| memo.concat([[:hex, "#x22"], s])}[1..-1]
+ seq.unshift(:seq)
+ return format_abnf(seq, sep: nil, embedded: false)
+ else
+ return (@options[:html] ? %("#{'%s' if sensitive}#{expr}") : %(#{'%s' if sensitive}"#{expr}"))
+ end
+ end
+ parts = {
+ alt: (@options[:html] ? "/ " : "/ "),
+ star: (@options[:html] ? "* " : "*"),
+ plus: (@options[:html] ? "+ " : "1*"),
+ opt: (@options[:html] ? "? " : "?")
+ }
+ lbrac = (@options[:html] ? "[ " : "[")
+ rbrac = (@options[:html] ? "] " : "]")
+ lparen = (@options[:html] ? "( " : "(")
+ rparen = (@options[:html] ? ") " : ")")
+
+ case expr.first
+ when :istr
+ # FIXME: if string part is segmented, need to do something different
+ format_abnf(expr.last, embedded: true, sensitive: false)
+ when :alt
+ this_sep = (sep ? sep : " ") + parts[expr.first.to_sym]
+ res = expr[1..-1].map {|e| format_abnf(e, embedded: true)}.join(this_sep)
+ embedded ? (lparen + res + rparen) : res
+ when :diff
+ raise RangeError, "ABNF does not support the diff operator"
+ when :opt
+ char = parts[expr.first.to_sym]
+ r = format_abnf(expr[1], embedded: true)
+ "#{lbrac}#{r}#{rbrac}"
+ when :plus, :star
+ char = parts[expr.first.to_sym]
+ r = format_abnf(expr[1], embedded: true)
+ "#{char}#{r}"
+ when :hex
+ escape_abnf_hex(expr.last[2..-1].hex.chr)
+ when :range
+ # Returns an [:alt] or [:not [:alt]] if composed of multiple sequences
+ # Note: ABNF does not support the `not` operator
+ res = format_abnf_range(expr.last)
+ res.is_a?(Array) ?
+ format_abnf(res, embedded: true) :
+ res
+ when :seq
+ this_sep = (sep ? sep : " ")
+ res = expr[1..-1].map do |e|
+ format_abnf(e, embedded: true)
+ end.join(this_sep)
+ embedded ? (lparen + res + rparen) : res
+ when :rept
+ # Expand repetition
+ min, max, value = expr[1..-1]
+ r = format_abnf(value, embedded: true)
+ if min == max
+ "#{min}#{r}"
+ elsif min == 0 && max == '*'
+ "#{parts[:star]}#{r}"
+ elsif min > 0 && max == '*'
+ "#{min}#{parts[:star]}#{r}"
+ else
+ "#{min}#{parts[:star]}#{max}#{r}"
+ end
+ else
+ raise "Unknown operator: #{expr.first}"
+ end
+ end
+
+ # Format a single-character string, prefering hex for non-main ASCII
+ def format_abnf_char(c)
+ if /[\x20-\x21\x23-\x7E]/.match?(c)
+ c.inspect
+ else
+ escape_abnf_hex(c)
+ end
+ end
+
+ # Format a range
+ #
+ # Presumes range has already been validated
+ def format_abnf_range(string)
+ alt, o_dash = [:alt], false
+
+ raise RangeError, "cannot format #{string.inspect} an ABNF range" if string.start_with?('^')
+
+ if string.end_with?('-')
+ o_dash = true
+ string = string[0..-2]
+ end
+
+ scanner = StringScanner.new(string)
+ hexes, deces = [], []
+ in_range = false
+ # Build op (alt) from different ranges/enums
+ while !scanner.eos?
+ if hex = scanner.scan(Terminals::HEX)
+ # Append any decimal values
+ alt << "%d" + deces.join(".") unless deces.empty?
+ deces = []
+
+ if in_range
+ # Add "." sequences for any previous hexes
+ alt << "%x" + hexes[0..-2].join(".") if hexes.length > 1
+ alt << "%x#{hexes.last}-#{hex[2..-1]}"
+ in_range, hexes = false, []
+ else
+ hexes << hex[2..-1]
+ end
+ elsif dec = scanner.scan(Terminals::R_CHAR)
+ # Append any hexadecimal values
+ alt << "%x" + hexes.join(".") unless hexes.empty?
+ hexes = []
+
+ if in_range
+ # Add "." sequences for any previous hexes
+ alt << "%d" + deces[0..-2].join(".") if deces.length > 1
+ alt << "%d#{deces.last}-#{dec.codepoints.first}"
+ in_range, deces = false, []
+ else
+ deces << dec.codepoints.first.to_s
+ end
+ end
+
+ in_range = true if scanner.scan(/\-/)
+ end
+
+ deces << '45' if o_dash
+
+ # Append hexes and deces as "." sequences (should be only one)
+ alt << "%d" + deces.join(".") unless deces.empty?
+ alt << "%x" + hexes.join(".") unless hexes.empty?
+
+ # FIXME: HTML abbreviations?
+ if alt.length == 2
+ # Just return the range or enum
+ alt.last
+ else
+ # Return the alt, which will be further formatted
+ alt
+ end
+ end
+
+ def escape_abnf_hex(u)
+ fmt = case u.ord
+ when 0x0000..0x00ff then "%02X"
+ when 0x0100..0xffff then "%04X"
+ else "%08X"
+ end
+ char = "%x" + (fmt % u.ord)
+ if @options[:html]
+ if u.ord <= 0x20
+ char = %(#{char})
+ elsif u.ord <= 0x7F
+ char = %(#{char})
+ elsif u.ord == 0x7F
+ char = %(#{char})
+ elsif u.ord <= 0xFF
+ char = %(#{char})
+ else
+ char = %(#{char})
+ end
+ %(#{char})
+ else
+ char
+ end
+ end
+
+ ##
+ # ISO EBNF Formatters
+ ##
+
+ # Format the expression part of a rule
+ def format_isoebnf(expr, sep: nil, embedded: false)
+ return (@options[:html] ? %(#{expr}) : expr.to_s) if expr.is_a?(Symbol)
+ if expr.is_a?(String)
+ expr = expr[2..-1].hex.chr if expr =~ /\A#x\h+/
+ expr.chars.each do |c|
+ raise RangeError, "cannot format #{expr.inspect} as an ISO EBNF String: #{c.inspect} is out of range" unless
+ ISOEBNF::TERMINAL_CHARACTER.match?(c)
+ end
+ if expr =~ /"/
+ return (@options[:html] ? %('#{expr}') : %('#{expr}'))
+ else
+ return (@options[:html] ? %("#{expr}") : %("#{expr}"))
+ end
+ end
+ parts = {
+ alt: (@options[:html] ? "| " : "| "),
+ diff: (@options[:html] ? "- " : "- "),
+ }
+ lparen = (@options[:html] ? "( " : "(")
+ rparen = (@options[:html] ? ") " : ")")
+
+ case expr.first
+ when :istr
+ # Looses fidelity, but, oh well ...
+ format_isoebnf(expr.last, embedded: true)
+ when :alt, :diff
+ this_sep = (sep ? sep : " ") + parts[expr.first.to_sym]
+ res = expr[1..-1].map {|e| format_isoebnf(e, embedded: true)}.join(this_sep)
+ embedded ? (lparen + res + rparen) : res
+ when :opt
+ r = format_isoebnf(expr[1], embedded: true)
+ "[#{r}]"
+ when :star
+ r = format_isoebnf(expr[1], embedded: true)
+ "{#{r}}"
+ when :plus
+ r = format_isoebnf(expr[1], embedded: true)
+ "#{r}, {#{r}}"
+ when :hex
+ format_isoebnf(expr[1], embedded: true)
+ when :range
+ res = format_isoebnf_range(expr.last)
+ res.is_a?(Array) ?
+ format_isoebnf(res, embedded: true) :
+ res
+ when :seq
+ this_sep = "," + (sep ? sep : " ")
+ res = expr[1..-1].map do |e|
+ format_isoebnf(e, embedded: true)
+ end.join(this_sep)
+ embedded ? (lparen + res + rparen) : res
+ when :rept
+ # Expand repetition
+ min, max, value = expr[1..-1]
+ if min == 0 && max == 1
+ format_isoebnf([:opt, value], sep: sep, embedded: embedded)
+ elsif min == 0 && max == '*'
+ format_isoebnf([:star, value], sep: sep, embedded: embedded)
+ elsif min == 1 && max == '*'
+ format_isoebnf([:plus, value], sep: sep, embedded: embedded)
+ else
+ val2 = [:seq]
+ while min > 0
+ val2 << value
+ min -= 1
+ max -= 1 unless max == '*'
+ end
+ if max == '*'
+ val2 << [:star, value]
+ else
+ opt = nil
+ while max > 0
+ opt = [:opt, opt ? [:seq, value, opt] : value]
+ max -= 1
+ end
+ val2 << opt if opt
+ end
+ format_isoebnf(val2, sep: sep, embedded: embedded)
+ end
+ else
+ raise "Unknown operator: #{expr.first}"
+ end
+ end
+
+ # Format a range
+ # Range is formatted as a aliteration of characters
+ def format_isoebnf_range(string)
+ chars = []
+ o_dash = false
+
+ raise RangeError, "cannot format #{string.inspect} an ABNF range" if string.start_with?('^')
+
+ if string.end_with?('-')
+ o_dash = true
+ string = string[0..-2]
+ end
+
+ scanner = StringScanner.new(string)
+ in_range = false
+ # Build chars from different ranges/enums
+ while !scanner.eos?
+ char = if hex = scanner.scan(Terminals::HEX)
+ hex[2..-1].hex.ord.char(Encoding::UTF_8)
+ else scanner.scan(Terminals::R_CHAR)
+ end
+ raise RangeError, "cannot format #{string.inspect} as an ISO EBNF Aliteration: #{char.inspect} is out of range" unless
+ char && ISOEBNF::TERMINAL_CHARACTER.match?(char)
+
+ if in_range
+ # calculate characters from chars.last to this char
+ raise RangeError, "cannot format #{string.inspect} as an ISO EBNF Aliteration" unless chars.last < char
+ chars.concat (chars.last..char).to_a[1..-1]
+ in_range = false
+ else
+ chars << char
+ end
+
+ in_range = true if scanner.scan(/\-/)
+ end
+
+ chars << '-' if o_dash
+
+ # Possibly only a single character (no character?)
+ chars.length == 1 ? chars.last.inspect : chars.unshift(:alt)
+ end
+
+ ERB_DESC = %q(
+
+
+ <% for rule in @rules %>
+ >
+ <% if rule.id %>
+ | <%= rule.id %> |
+ <% end %>
+ <%== rule.sym %> |
+ <%= rule.assign %> |
+ <%= rule.formatted %> |
+
+ <% end %>
+
+
).gsub(/^ /, '')
end
end
diff --git a/spec/abnf_spec.rb b/spec/abnf_spec.rb
new file mode 100644
index 0000000..91eae38
--- /dev/null
+++ b/spec/abnf_spec.rb
@@ -0,0 +1,253 @@
+# coding: utf-8
+$:.unshift "."
+require 'spec_helper'
+require 'ebnf'
+require 'sxp'
+
+describe EBNF::ABNF do
+ let(:logger) {RDF::Spec.logger}
+ after(:each) do |example|
+ puts logger.to_s if example.exception && !example.exception.is_a?(RSpec::Expectations::ExpectationNotMetError)
+ end
+
+ context "rule variations" do
+ {
+ "legal rule name": [
+ 'rulename = "foo"',
+ %{((terminal rulename (istr "foo")))}
+ ],
+ "binary character": [
+ "bin = %b11",
+ %{((terminal bin (hex "#x3")))}
+ ],
+ "binary string": [
+ "bin = %b1.10.11",
+ %{((rule bin (seq (hex "#x1") (hex "#x2") (hex "#x3"))))}
+ ],
+ "binary string (ascii range)": [
+ "bin = %b1100010.1101001.1101110",
+ %{((rule bin (seq "bin")))}
+ ],
+ "binary string (mixed range)": [
+ "bin = %b1100010.1.1101110",
+ %{((rule bin (seq "b" (hex "#x1") "n")))}
+ ],
+ "binary range": [
+ "bin = %b1100010-1101110",
+ %{((terminal bin (range "#x62-#x6e")))}
+ ],
+ "decimal char": [
+ "dec = %d22",
+ %{((terminal dec (hex "#x16")))}
+ ],
+ "decimal string": [
+ "dec = %d1.2.3",
+ %{((rule dec (seq (hex "#x1") (hex "#x2") (hex "#x3"))))}
+ ],
+ "decimal string (ascii range)": [
+ "dec = %d100.101.99",
+ %{((rule dec (seq "dec")))}
+ ],
+ "decimal string (mixed range)": [
+ "dec = %d100.1.99",
+ %{((rule dec (seq "d" (hex "#x1") "c")))}
+ ],
+ "decimal range": [
+ "dec = %d22-40",
+ %{((terminal dec (range "#x16-#x28")))}
+ ],
+ "hex character": [
+ "hex = %x1f",
+ %{((terminal hex (hex "#x1f")))}
+ ],
+ "hex string": [
+ "hex = %x1.a.c",
+ %{((rule hex (seq (hex "#x1") (hex "#xa") (hex "#xc"))))}
+ ],
+ "hex string (ascii range)": [
+ "hex = %x68.65.78",
+ %{((rule hex (seq "hex")))}
+ ],
+ "hex string (mixed range)": [
+ "hex = %x68.1.78",
+ %{((rule hex (seq "h" (hex "#x1") "x")))}
+ ],
+ "hex range": [
+ "hex = %x22-40",
+ %{((terminal hex (range "#x22-#x40")))}
+ ],
+ "aliteration": [
+ %(baz = foo / bar),
+ %{((rule baz (alt foo bar)))}
+ ],
+ "aliteration 2": [
+ %(buzz = foo / bar / baz),
+ %{((rule buzz (alt foo bar baz)))}
+ ],
+ "incremental alternatives": [
+ %(ruleset = alt1 / alt2\nruleset =/ alt3\nruleset =/ alt4 / alt5),
+ %{((rule ruleset (alt alt1 alt2 alt3 alt4 alt5)))}
+ ],
+ "concatenated chars and ranges": [
+ %(char-line = %x0D.0A %x20-7E %x0D.0A),
+ %{((rule char-line (seq (seq (hex "#xd") (hex "#xa")) (range "#x20-#x7e") (seq (hex "#xd") (hex "#xa")))))}
+ ],
+ "sequence group": [
+ %(sequence-group = elem (foo / bar) blat),
+ %{((rule sequence-group (seq elem (alt foo bar) blat)))}
+ ],
+ "rept *": [
+ %(rept = *A),
+ %{((rule rept (star A)))}
+ ],
+ "rept 0*": [
+ %(rept = 0*A),
+ %{((rule rept (star A)))}
+ ],
+ "rept 1*": [
+ %(rept = 1*A),
+ %{((rule rept (plus A)))}
+ ],
+ "rept 2*": [
+ %(rept = 2*A),
+ %{((rule rept (rept 2 "*" A)))}
+ ],
+ "rept *1": [
+ %(rept = *1A),
+ %{((rule rept (rept 0 1 A)))}
+ ],
+ "rept 0*2": [
+ %(rept = 0*2A),
+ %{((rule rept (rept 0 2 A)))}
+ ],
+ "rept 1*3": [
+ %(rept = 1*3A),
+ %{((rule rept (rept 1 3 A)))}
+ ],
+ "rept 3": [
+ %(rept = 3A),
+ %{((rule rept (rept 3 3 A)))}
+ ],
+ "opt": [
+ %(opt = [foo bar]),
+ %{((rule opt (opt (seq foo bar))))}
+ ],
+ "comment": [
+ %(foo = %x61 ; a),
+ %{((terminal foo (hex "#x61")))}
+ ],
+ "prose-value": [
+ %(prose = < free form >),
+ %{((rule prose (seq "< free form >")))}
+ ]
+ }.each do |title, (input, expect)|
+ it title do
+ input << "\n" unless input.end_with?("\n")
+ expect(parse(input).to_sxp).to produce(expect, logger)
+ end
+ end
+ end
+
+ context "Case-Sensitive String Support in ABNF" do
+ {
+ "case insensitive": [
+ %(rulename = %i"aBc"),
+ %{((terminal rulename (istr "aBc")))}
+ ],
+ "case sensitive": [
+ %(rulename = %s"aBc"),
+ %{((rule rulename (seq "aBc")))}
+ ],
+ }.each do |title, (input, expect)|
+ it title do
+ input << "\n" unless input.end_with?("\n")
+ expect(parse(input).to_sxp).to produce(expect, logger)
+ end
+ end
+ end
+
+ context "Core Rules" do
+ {
+ "ALPHA": [
+ "builtin = ALPHA",
+ %{((rule builtin (seq ALPHA)) (terminal ALPHA (range "#x41-#x5A#x61-#x7A")))}
+ ],
+ "BIT": [
+ "builtin = BIT",
+ %{((rule builtin (seq BIT)) (terminal BIT (alt "0" "1")))}
+ ],
+ "CR": [
+ "builtin = CR",
+ %{((rule builtin (seq CR)) (terminal CR (hex "#x0D")))}
+ ],
+ "CRLF": [
+ "builtin = CRLF",
+ %{((rule builtin (seq CRLF)) (terminal CRLF (seq (opt CR) LF)))}
+ ],
+ "CTL": [
+ "builtin = CTL",
+ %{((rule builtin (seq CTL)) (terminal CTL (alt (range "#x00-#x1F") (hex "#x7F"))))}
+ ],
+ "DIGIT": [
+ "builtin = DIGIT",
+ %{((rule builtin (seq DIGIT)) (terminal DIGIT (range "#x30-#x39")))}
+ ],
+ "DQUOTE": [
+ "builtin = DQUOTE",
+ %{((rule builtin (seq DQUOTE)) (terminal DQUOTE (hex "#x22")))}
+ ],
+ "HEXDIG": [
+ "builtin = HEXDIG",
+ %{((rule builtin (seq HEXDIG)) (terminal HEXDIG (alt DIGIT (range "A-F"))))}
+ ],
+ "HTAB": [
+ "builtin = HTAB",
+ %{((rule builtin (seq HTAB)) (terminal HTAB (hex "#x09")))}
+ ],
+ "LF": [
+ "builtin = LF",
+ %{((rule builtin (seq LF)) (terminal LF (hex "#x0A")))}
+ ],
+ "LWSP": [
+ "builtin = LWSP",
+ %{((rule builtin (seq LWSP)) (terminal LWSP (star (alt WSP (seq CRLF WSP)))))}
+ ],
+ "WSP": [
+ "builtin = WSP",
+ %{((rule builtin (seq WSP)) (terminal WSP (alt SP HTAB)))}
+ ],
+ }.each do |title, (input, expect)|
+ it title do
+ input << "\n" unless input.end_with?("\n")
+ expect(parse(input).to_sxp).to produce(expect, logger)
+ end
+ end
+ end
+
+ context "illegal syntax" do
+ {
+ "illegal rule name": "rule.name = CRLF\n",
+ "no line ending": "rule.name = CRLF",
+ "illegal binary": "bin = %b2\n",
+ "illegal binary range": "bin = %b10-20\n",
+ "illegal decimal": "dec = %d2f\n",
+ "illegal decimal range": "dec = %d22-4060-80\n",
+ "illegal hex": "hex = %x2g\n",
+ "illegal hex range": "hex = %x22-4060-80\n",
+ }.each do |title, input|
+ it title do
+ expect {parse(input)}.to raise_error(SyntaxError)
+ end
+ end
+ end
+
+ it "parses ABNF grammar" do
+ gram = parse(File.open(File.expand_path("../../etc/abnf.abnf", __FILE__)))
+ expect(gram).to be_valid
+ end
+
+ def parse(input, **options)
+ @debug = []
+ EBNF.parse(input, debug: @debug, format: :abnf, **options)
+ end
+end
diff --git a/spec/base_spec.rb b/spec/base_spec.rb
index 50d14d9..7510b48 100644
--- a/spec/base_spec.rb
+++ b/spec/base_spec.rb
@@ -3,35 +3,37 @@
require 'spec_helper'
require 'ebnf'
require 'sxp'
+require 'rdf/turtle'
describe EBNF::Base do
- describe ".new" do
+ subject {PARSED_EBNF_GRAMMAR.dup}
+
+ describe "#initialize" do
{
%{[2] Prolog ::= BaseDecl? PrefixDecl*} =>
%{((rule Prolog "2" (seq (opt BaseDecl) (star PrefixDecl))))},
%{
@terminals
- [3] terminal ::= [A-Z_]+
- } => %{((terminal terminal "3" (plus (range "A-Z_"))))},
+ [3] terminal ::= [A-Z]+
+ } => %{((terminals _terminals (seq))
+ (terminal terminal "3" (plus (range "A-Z"))))},
%{
[9] primary ::= HEX
| RANGE
- | ENUM
| O_RANGE
- | O_ENUM
| STRING1
| STRING2
| '(' expression ')'
- } => %{((rule primary "9" (alt HEX RANGE ENUM O_RANGE O_ENUM STRING1 STRING2 (seq "(" expression ")"))))},
+ } => %{((rule primary "9" (alt HEX RANGE O_RANGE STRING1 STRING2 (seq "(" expression ")"))))},
%{#[1] rule ::= 'FOO'} => %{()},
%{//[1] rule ::= 'FOO'} => %{()},
%{[18] SolutionModifier ::= _SolutionModifier_1 _SolutionModifier_2} =>
%{((rule SolutionModifier "18" (seq _SolutionModifier_1 _SolutionModifier_2)))},
%{[18.1] _SolutionModifier_1 ::= _empty | GroupClause} =>
%{((rule _SolutionModifier_1 "18.1" (alt _empty GroupClause)))},
- %q{[18] STRING1 ::= '"' (CHAR | [\t\'\[\]\(\)\-])* '"'} =>
- %q{((terminal STRING1 "18" (seq "\"" (star (alt CHAR (range "\t'[]()-"))) "\"")))},
+ %q{[18] STRING1 ::= '"' (CHAR - '"')* '"'} =>
+ %q{((terminal STRING1 "18" (seq "\"" (star (diff CHAR "\"")) "\"")))},
%q{[161s] WS ::= #x20 | #x9 | #xD | #xA} =>
%q{((terminal WS "161s" (alt (hex "#x20") (hex "#x9") (hex "#xD") (hex "#xA"))))},
%q{[1] shexDoc ::= directive* # leading CODE} =>
@@ -44,7 +46,7 @@
%q{((rule shexDoc "1" (star directive)))},
%q{[1] shexDoc ::= /* leading CODE */ directive*} =>
%q{((rule shexDoc "1" (star directive)))},
- %q{[1] shexDoc (* leading CODE *) ::= directive*} =>
+ %q{[1] shexDoc ::= (* leading CODE *) directive*} =>
%q{((rule shexDoc "1" (star directive)))},
%q{[156s] STRING_LITERAL1 ::= "'" ([^#x27#x5C#xA#xD] | ECHAR | UCHAR)* "'" /* #x27=' #x5C=\ #xA=new line #xD=carriage return */} =>
%q{((terminal STRING_LITERAL1 "156s"
@@ -60,12 +62,94 @@
expect(ast.to_sxp).to produce(expected, @debug)
end
end
+
+ it "rejects unknown format" do
+ expect {parse("foo", format: :unknown)}.to raise_error "unknown input format :unknown"
+ end
+ end
+
+ describe "#renumber!" do
+ it "creates identifiers for grammars without identifiers" do
+ gram = EBNF.parse("a ::= b d ::= e")
+ gram.renumber!
+ expect(gram.ast.map(&:id)).to eq %w{1 2}
+ end
+
+ it "renumbers grammars with identifiers" do
+ gram = EBNF.parse("[10] a ::= b [20] d ::= e")
+ gram.renumber!
+ expect(gram.ast.map(&:id)).to eq %w{1 2}
+ end
+ end
+
+ describe "#validate!" do
+ let(:simple) {EBNF.parse("a ::= b")}
+ it "notes invalid grammar" do
+ expect do
+ expect {simple.validate!}.to raise_error SyntaxError, "In rule a: No rule found for b"
+ end.to write(:something).to(:error)
+ end
+
+ it "validates EBNF" do
+ expect {subject.validate!}.not_to raise_error
+ end
+ end
+
+ describe "#valid?" do
+ let(:simple) {EBNF.parse("a ::= b")}
+ it "notes invalid grammar" do
+ expect do
+ expect(simple.valid?).to be_falsey
+ end.to write(:something).to(:error)
+ end
+
+ it "validates EBNF" do
+ expect(subject).to be_valid
+ end
+ end
+
+ describe "#each" do
+ it "yields each rule" do
+ rules = subject.ast.select {|r| r.rule?}
+ expect {|b| subject.each(:rule, &b)}.to yield_control.exactly(rules.length).times
+ end
+ it "yields each terminal" do
+ terminals = subject.ast.select {|r| r.terminal?}
+ expect {|b| subject.each(:terminal, &b)}.to yield_control.exactly(terminals.length).times
+ end
+ end
+
+ describe "#to_sxp" do
+ specify {expect(subject.to_sxp).to include("(rule ebnf")}
+ end
+
+ describe "#to_s" do
+ specify {expect(subject.to_s).to include("[1] ebnf")}
+ end
+
+ describe "#to_html" do
+ specify {expect(subject.to_s).to include("[1] ebnf")}
+ end
+
+ describe "#to_ruby" do
+ specify {expect {subject.to_ruby}.to write(:something).to(:output)}
+ end
+
+ describe "#to_ttl" do
+ let(:reader) {RDF::Turtle::Reader.new(subject.to_ttl, base_uri: 'http://example.org/')}
+ specify {expect(reader).to be_valid}
end
describe "#dup" do
specify {expect(parse(%{[2] Prolog ::= BaseDecl? PrefixDecl*}).dup).to be_a(EBNF::Base)}
end
+ describe "#find_rule" do
+ it "finds ebnf" do
+ expect(subject.find_rule(:ebnf).sym).to eql :ebnf
+ end
+ end
+
def parse(value, **options)
@debug = []
options = {debug: @debug}.merge(options)
diff --git a/spec/bnf_spec.rb b/spec/bnf_spec.rb
index 4fe65ab..137cfbb 100644
--- a/spec/bnf_spec.rb
+++ b/spec/bnf_spec.rb
@@ -16,16 +16,14 @@
%{
[9] primary ::= HEX
| RANGE
- | ENUM
| O_RANGE
- | O_ENUM
| STRING1
| STRING2
| '(' expression ')'
} =>
%{((rule _empty "0" (seq))
- (rule primary "9" (alt HEX RANGE ENUM O_RANGE O_ENUM STRING1 STRING2 _primary_1 ))
+ (rule primary "9" (alt HEX RANGE O_RANGE STRING1 STRING2 _primary_1 ))
(rule _primary_1 "9.1" (seq "(" expression ")")))},
%{
[1] R1 ::= 1 2
diff --git a/spec/ebnf_spec.rb b/spec/ebnf_spec.rb
index 4fdfd77..1664976 100644
--- a/spec/ebnf_spec.rb
+++ b/spec/ebnf_spec.rb
@@ -11,28 +11,25 @@
%{((rule Prolog "2" (seq (opt BaseDecl) (star PrefixDecl))))},
%{
@terminals
- [3] terminal ::= [A-Z_]+
- } => %{((terminal terminal "3" (plus (range "A-Z_"))))},
+ [3] terminal ::= [A-Z]+
+ } => %{((terminals _terminals (seq))
+ (terminal terminal "3" (plus (range "A-Z"))))},
%{
[9] primary ::= HEX
| RANGE
- | ENUM
| O_RANGE
- | O_ENUM
| STRING1
| STRING2
| '(' expression ')'
- } => %{((rule primary "9" (alt HEX RANGE ENUM O_RANGE O_ENUM STRING1 STRING2 (seq "(" expression ")"))))},
+ } => %{((rule primary "9" (alt HEX RANGE O_RANGE STRING1 STRING2 (seq "(" expression ")"))))},
%{
primary ::= HEX
| RANGE
- | ENUM
| O_RANGE
- | O_ENUM
| STRING1
| STRING2
| '(' expression ')'
- } => %{((rule primary (alt HEX RANGE ENUM O_RANGE O_ENUM STRING1 STRING2 (seq "(" expression ")"))))},
+ } => %{((rule primary (alt HEX RANGE O_RANGE STRING1 STRING2 (seq "(" expression ")"))))},
}.each do |input, expected|
context input do
subject {EBNF.parse(input)}
@@ -59,7 +56,7 @@
end
context "README" do
- let(:ebnf) {EBNF.parse(File.open(File.expand_path("../../etc/ebnf.ebnf", __FILE__)))}
+ let(:ebnf) {PARSED_EBNF_GRAMMAR.dup}
subject {ebnf}
it "creates ast" do
@@ -82,18 +79,24 @@
expect(subject.to_s).not_to be_empty
end
- context "BNF" do
+ context "LL1" do
before {subject.make_bnf}
- context "LL1" do
- before do
- subject.first_follow(:ebnf)
- subject.build_tables
- end
+ before do
+ subject.first_follow(:ebnf)
+ subject.build_tables
+ end
+
+ it "#to_ruby" do
+ expect {subject.to_ruby}.to write(:something).to(:output)
+ end
+ end
+
+ context "PEG" do
+ before {subject.make_peg}
- it "#to_ruby" do
- expect {subject.to_ruby}.to write(:something).to(:output)
- end
+ it "#to_ruby" do
+ expect {subject.to_ruby}.to write(:something).to(:output)
end
end
end
diff --git a/spec/examples/ebnf-parser-spec.rb b/spec/examples/ebnf-parser-spec.rb
deleted file mode 100644
index 9cd92f5..0000000
--- a/spec/examples/ebnf-parser-spec.rb
+++ /dev/null
@@ -1,46 +0,0 @@
-# coding: utf-8
-require 'spec_helper'
-$:.unshift(File.expand_path("../../../examples/ebnf-parser", __FILE__))
-require 'parser'
-
-describe EBNFParser do
- describe ".new" do
- {
- %{[2] Prolog ::= BaseDecl? PrefixDecl*} =>
- %{((rule Prolog "2" (seq (opt BaseDecl) (star PrefixDecl))))},
- %{
- @terminals
- [3] terminal ::= [A-Z_]+
- } => %{((terminal terminal "3" (plus (range "A-Z_"))))},
- %{
- [9] primary ::= HEX
- | RANGE
- | ENUM
- | O_RANGE
- | O_ENUM
- | STRING1
- | STRING2
- | '(' expression ')'
-
- } => %{((rule primary "9" (alt HEX RANGE ENUM O_RANGE O_ENUM STRING1 STRING2 (seq "(" expression ")"))))},
- %{#[1] rule ::= 'FOO'} => %{()},
- %{//[1] rule ::= 'FOO'} => %{()},
- %{[18] SolutionModifier ::= _SolutionModifier_1 _SolutionModifier_2} =>
- %{((rule SolutionModifier "18" (seq _SolutionModifier_1 _SolutionModifier_2)))},
- %{[18.1] _SolutionModifier_1 ::= _empty | GroupClause} =>
- %{((rule _SolutionModifier_1 "18.1" (alt _empty GroupClause)))},
- %q{[18] STRING1 ::= '"' ((CHAR - '"') | '\\t')* '"'} =>
- %q{((terminal STRING1 "18" (seq "\"" (star (alt (diff CHAR "\"") "\t")) "\"")))}
- }.each do |input, expected|
- it "parses #{input.inspect}" do
- expect(parse(input, validate: true).ast.to_sxp).to produce(expected, @debug)
- end
- end
- end
-
- def parse(value, **options)
- @debug = []
- options = {debug: @debug}.merge(options)
- EBNFParser.new(value, **options)
- end
-end
\ No newline at end of file
diff --git a/spec/isoebnf_spec.rb b/spec/isoebnf_spec.rb
new file mode 100644
index 0000000..ddb7fd1
--- /dev/null
+++ b/spec/isoebnf_spec.rb
@@ -0,0 +1,237 @@
+# coding: utf-8
+$:.unshift "."
+require 'spec_helper'
+require 'ebnf'
+require 'sxp'
+
+describe EBNF::ISOEBNF do
+ let(:logger) {RDF::Spec.logger}
+ after(:each) do |example|
+ puts logger.to_s if example.exception && !example.exception.is_a?(RSpec::Expectations::ExpectationNotMetError)
+ end
+
+ context "rule variations" do
+ {
+ "legal meta_identifier": [
+ 'rulename = "foo" ;',
+ %{((rule rulename (seq "foo")))}
+ ],
+ "digits": [
+ %{
+ digit_excluding_zero = "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
+ digit = "0" | digit_excluding_zero ;
+ },
+ %{((rule digit_excluding_zero (alt "1" "2" "3" "4" "5" "6" "7" "8" "9"))
+ (rule digit (alt "0" digit_excluding_zero)))}
+ ],
+ "sequence of numbers": [
+ %{
+ twelve = "1", "2" ;
+ two_hundred_one = "2", "0", "1" ;
+ three_hundred_twelve = "3", twelve ;
+ twelve_thousand_two_hundred_one = twelve, two_hundred_one ;
+ },
+ %{((rule twelve (seq "1" "2"))
+ (rule two_hundred_one (seq "2" "0" "1"))
+ (rule three_hundred_twelve (seq "3" twelve))
+ (rule twelve_thousand_two_hundred_one (seq twelve two_hundred_one)))}
+ ],
+ "natural number": [
+ %{natural_number = digit_excluding_zero, { digit } ;},
+ %{((rule natural_number (seq digit_excluding_zero (star digit))))}
+ ],
+ "integer": [
+ %{integer = "0" | [ "-" ], natural_number ;},
+ %{((rule integer (alt "0" (seq (opt "-") natural_number))))}
+ ],
+ "simple grammar": [
+ %q{
+ letter = "A" | "B" | "C" | "D" | "E" | "F" | "G"
+ | "H" | "I" | "J" | "K" | "L" | "M" | "N"
+ | "O" | "P" | "Q" | "R" | "S" | "T" | "U"
+ | "V" | "W" | "X" | "Y" | "Z" | "a" | "b"
+ | "c" | "d" | "e" | "f" | "g" | "h" | "i"
+ | "j" | "k" | "l" | "m" | "n" | "o" | "p"
+ | "q" | "r" | "s" | "t" | "u" | "v" | "w"
+ | "x" | "y" | "z" ;
+ digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
+ symbol = "[" | "]" | "{" | "}" | "(" | ")" | "<" | ">"
+ | "'" | '"' | "=" | "|" | "." | "," | ";" ;
+ character = letter | digit | symbol | "_" ;
+
+ identifier = letter , { letter | digit | "_" } ;
+ terminal = "'" , character , { character } , "'"
+ | '"' , character , { character } , '"' ;
+
+ lhs = identifier ;
+ rhs = identifier
+ | terminal
+ | "[" , rhs , "]"
+ | "{" , rhs , "}"
+ | "(" , rhs , ")"
+ | rhs , "|" , rhs
+ | rhs , "," , rhs ;
+
+ rule = lhs , "=" , rhs , ";" ;
+ grammar = { rule } ;
+ },
+ %q{((rule letter
+ (alt "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R"
+ "S" "T" "U" "V" "W" "X" "Y" "Z" "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k"
+ "l" "m" "n" "o" "p" "q" "r" "s" "t" "u" "v" "w" "x" "y" "z" ))
+ (rule digit (alt "0" "1" "2" "3" "4" "5" "6" "7" "8" "9"))
+ (rule symbol (alt "[" "]" "{" "}" "(" ")" "<" ">" "'" "\"" "=" "|" "." "," ";"))
+ (rule character (alt letter digit symbol "_"))
+ (rule identifier (seq letter (star (alt letter digit "_"))))
+ (rule terminal
+ (alt (seq "'" character (star character) "'") (seq "\"" character (star character) "\"")))
+ (rule lhs (seq identifier))
+ (rule rhs
+ (alt identifier terminal
+ (seq "[" rhs "]")
+ (seq "{" rhs "}")
+ (seq "(" rhs ")")
+ (seq rhs "|" rhs)
+ (seq rhs "," rhs)) )
+ (rule rule (seq lhs "=" rhs ";"))
+ (rule grammar (star rule)))}
+ ],
+ "pascal": [
+ %q{
+ (* a simple program syntax in EBNF − Wikipedia *)
+ program = 'PROGRAM', white_space, identifier, white_space,
+ 'BEGIN', white_space,
+ { assignment, ";", white_space },
+ 'END.' ;
+ identifier = alphabetic_character, { alphabetic_character | digit } ;
+ number = [ "-" ], digit, { digit } ;
+ string = '"' , { all_characters - '"' }, '"' ;
+ assignment = identifier , ":=" , ( number | identifier | string ) ;
+ alphabetic_character = "A" | "B" | "C" | "D" | "E" | "F" | "G"
+ | "H" | "I" | "J" | "K" | "L" | "M" | "N"
+ | "O" | "P" | "Q" | "R" | "S" | "T" | "U"
+ | "V" | "W" | "X" | "Y" | "Z" ;
+ digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
+ white_space = ? white_space characters ? ;
+ all_characters = ? all visible characters ? ;
+ },
+ %q{((rule program
+ (seq "PROGRAM" white_space identifier white_space "BEGIN" white_space
+ (star (seq assignment ";" white_space)) "END." ))
+ (rule identifier (seq alphabetic_character (star (alt alphabetic_character digit))))
+ (rule number (seq (opt "-") digit (star digit)))
+ (rule string (seq "\"" (star (diff all_characters "\"")) "\""))
+ (rule assignment (seq identifier ":=" (seq (alt number identifier string))))
+ (rule alphabetic_character
+ (alt "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R"
+ "S" "T" "U" "V" "W" "X" "Y" "Z" ))
+ (rule digit (alt "0" "1" "2" "3" "4" "5" "6" "7" "8" "9"))
+ (rule white_space (seq "? white_space characters ?"))
+ (rule all_characters (seq "? all visible characters ?")))}
+ ],
+ "AA": [
+ %{AA = "A";},
+ %{((terminal AA (seq "A")))}
+ ],
+ "BB": [
+ %{BB = 3 * AA, "B";},
+ %{ ((terminal BB (seq (rept 3 3 AA) "B")))}
+ ],
+ "CC": [
+ %{CC = 3 * [AA], "C";},
+ %{((terminal CC (seq (rept 3 3 (opt AA)) "C")))}
+ ],
+ "DD": [
+ %{DD = {AA}, "D";},
+ %{((terminal DD (seq (star AA) "D")))}
+ ],
+ "EE": [
+ %{EE = AA, {AA}, "E";},
+ %{((terminal EE (seq AA (star AA) "E")))}
+ ],
+ "FF": [
+ %{FF = 3 * AA, 3 * [AA], "F";},
+ %{((terminal FF (seq (rept 3 3 AA) (rept 3 3 (opt AA)) "F")))}
+ ],
+ "GG": [
+ %{GG = {3 * AA}, "G";},
+ %{((terminal GG (seq (star (rept 3 3 AA)) "G")))}
+ ],
+ "space": [
+ %{space = ? US-ASCII character 32 ?;},
+ %{((rule space (seq "? US-ASCII character 32 ?")))} # XXX probably not
+ ],
+ "something": [
+ %{something = foo, ( bar );},
+ %{((rule something (seq foo (seq bar))))}
+ ],
+ "diff": [
+ %{first_terminal_character = terminal_character - "'" ;},
+ %{((rule first_terminal_character (diff terminal_character "'")))},
+ ],
+ }.each do |title, (input, expect)|
+ it title do
+ input << "\n" unless input.end_with?("\n")
+ expect(parse(input).to_sxp).to produce(expect, logger)
+ end
+ end
+ end
+
+ context "alternate terminal characters" do
+ {
+ "digits /": [
+ %{
+ digit_excluding_zero = "1" / "2" / "3" / "4" / "5" / "6" / "7" / "8" / "9" ;
+ digit = "0" / digit_excluding_zero ;
+ },
+ %{((rule digit_excluding_zero (alt "1" "2" "3" "4" "5" "6" "7" "8" "9"))
+ (rule digit (alt "0" digit_excluding_zero)))}
+ ],
+ "digits !": [
+ %{
+ digit_excluding_zero = "1" ! "2" ! "3" ! "4" ! "5" ! "6" ! "7" ! "8" ! "9" ;
+ digit = "0" ! digit_excluding_zero ;
+ },
+ %{((rule digit_excluding_zero (alt "1" "2" "3" "4" "5" "6" "7" "8" "9"))
+ (rule digit (alt "0" digit_excluding_zero)))}
+ ],
+ #"integer (/ /)": [
+ # %{integer = "0" | (/ "-" /), natural_number ;},
+ # %{((rule integer (alt "0" (seq (opt "-") natural_number))))}
+ #],
+ "natural number (: :)": [
+ %{natural_number = digit_excluding_zero, (: digit :) ;},
+ %{((rule natural_number (seq digit_excluding_zero (star digit))))}
+ ],
+ "legal meta_identifier .": [
+ 'rulename = "foo" .',
+ %{((rule rulename (seq "foo")))}
+ ],
+ }.each do |title, (input, expect)|
+ it title do
+ input << "\n" unless input.end_with?("\n")
+ expect(parse(input).to_sxp).to produce(expect, logger)
+ end
+ end
+ end
+
+ context "illegal syntax" do
+ {
+ "something": "something = foo ( bar );"
+ }.each do |title, input|
+ it title do
+ expect {parse(input)}.to raise_error(SyntaxError)
+ end
+ end
+ end
+
+ it "parses ISO EBNF grammar" do
+ gram = parse(File.open(File.expand_path("../../etc/iso-ebnf.isoebnf", __FILE__)))
+ expect(gram).to be_valid
+ end
+
+ def parse(input, **options)
+ @debug = []
+ EBNF.parse(input, debug: @debug, format: :isoebnf, **options)
+ end
+end
diff --git a/spec/ll1/data/meta.rb b/spec/ll1/data/meta.rb
index e143b86..96a33a9 100644
--- a/spec/ll1/data/meta.rb
+++ b/spec/ll1/data/meta.rb
@@ -1,14 +1,11 @@
-# This file is automatically generated by /Users/gregg/Projects/ebnf/bin/ebnf
-# BRANCH derived from ../../etc/ebnf.ebnf
+# This file is automatically generated by ebnf version 2.0.0
+# Derived from etc/ebnf.ebnf
module EBNFParserMeta
START = :ebnf
-
BRANCH = {
:alt => {
"(" => [:seq, :_alt_1],
- :ENUM => [:seq, :_alt_1],
:HEX => [:seq, :_alt_1],
- :O_ENUM => [:seq, :_alt_1],
:O_RANGE => [:seq, :_alt_1],
:RANGE => [:seq, :_alt_1],
:STRING1 => [:seq, :_alt_1],
@@ -34,9 +31,7 @@ module EBNFParserMeta
},
:diff => {
"(" => [:postfix, :_diff_1],
- :ENUM => [:postfix, :_diff_1],
:HEX => [:postfix, :_diff_1],
- :O_ENUM => [:postfix, :_diff_1],
:O_RANGE => [:postfix, :_diff_1],
:RANGE => [:postfix, :_diff_1],
:STRING1 => [:postfix, :_diff_1],
@@ -49,10 +44,8 @@ module EBNFParserMeta
"-" => [:_diff_2],
"@pass" => [],
"@terminals" => [],
- :ENUM => [],
:HEX => [],
:LHS => [],
- :O_ENUM => [],
:O_RANGE => [],
:RANGE => [],
:STRING1 => [],
@@ -80,9 +73,7 @@ module EBNFParserMeta
},
:expression => {
"(" => [:alt],
- :ENUM => [:alt],
:HEX => [:alt],
- :O_ENUM => [:alt],
:O_RANGE => [:alt],
:RANGE => [:alt],
:STRING1 => [:alt],
@@ -94,9 +85,7 @@ module EBNFParserMeta
},
:postfix => {
"(" => [:primary, :_postfix_1],
- :ENUM => [:primary, :_postfix_1],
:HEX => [:primary, :_postfix_1],
- :O_ENUM => [:primary, :_postfix_1],
:O_RANGE => [:primary, :_postfix_1],
:RANGE => [:primary, :_postfix_1],
:STRING1 => [:primary, :_postfix_1],
@@ -109,10 +98,8 @@ module EBNFParserMeta
"-" => [],
"@pass" => [],
"@terminals" => [],
- :ENUM => [],
:HEX => [],
:LHS => [],
- :O_ENUM => [],
:O_RANGE => [],
:POSTFIX => [:POSTFIX],
:RANGE => [],
@@ -123,9 +110,7 @@ module EBNFParserMeta
},
:primary => {
"(" => [:_primary_1],
- :ENUM => [:ENUM],
:HEX => [:HEX],
- :O_ENUM => [:O_ENUM],
:O_RANGE => [:O_RANGE],
:RANGE => [:RANGE],
:STRING1 => [:STRING1],
@@ -140,9 +125,7 @@ module EBNFParserMeta
},
:seq => {
"(" => [:diff, :_seq_1],
- :ENUM => [:diff, :_seq_1],
:HEX => [:diff, :_seq_1],
- :O_ENUM => [:diff, :_seq_1],
:O_RANGE => [:diff, :_seq_1],
:RANGE => [:diff, :_seq_1],
:STRING1 => [:diff, :_seq_1],
@@ -154,10 +137,8 @@ module EBNFParserMeta
")" => [],
"@pass" => [],
"@terminals" => [],
- :ENUM => [:_seq_2],
:HEX => [:_seq_2],
:LHS => [],
- :O_ENUM => [:_seq_2],
:O_RANGE => [:_seq_2],
:RANGE => [:_seq_2],
:STRING1 => [:_seq_2],
@@ -167,9 +148,7 @@ module EBNFParserMeta
},
:_seq_2 => {
"(" => [:diff, :_seq_1],
- :ENUM => [:diff, :_seq_1],
:HEX => [:diff, :_seq_1],
- :O_ENUM => [:diff, :_seq_1],
:O_RANGE => [:diff, :_seq_1],
:RANGE => [:diff, :_seq_1],
:STRING1 => [:diff, :_seq_1],
@@ -183,10 +162,8 @@ module EBNFParserMeta
"-",
"@pass",
"@terminals",
- :ENUM,
:HEX,
:LHS,
- :O_ENUM,
:O_RANGE,
:POSTFIX,
:RANGE,
@@ -200,9 +177,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"("],
@@ -223,9 +198,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"("],
@@ -236,9 +209,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"("],
@@ -254,9 +225,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"("],
@@ -284,9 +253,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"("],
@@ -296,9 +263,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"("],
@@ -306,9 +271,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"("],
@@ -322,9 +285,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"("],
@@ -334,9 +295,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"("],
@@ -348,9 +307,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"("],
@@ -358,9 +315,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"("],
@@ -369,9 +324,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"("],
@@ -379,9 +332,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"("],
@@ -390,9 +341,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"("],
@@ -401,9 +350,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"("],
@@ -465,9 +412,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"@terminals",
@@ -481,9 +426,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"@terminals",
@@ -497,9 +440,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"@terminals",
@@ -513,9 +454,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"@terminals",
@@ -529,9 +468,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"@terminals",
@@ -573,9 +510,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"@terminals",
@@ -590,9 +525,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"@terminals",
@@ -607,9 +540,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"@terminals",
@@ -625,9 +556,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"@terminals",
@@ -643,9 +572,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"@terminals",
@@ -661,9 +588,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"@terminals",
@@ -679,9 +604,7 @@ module EBNFParserMeta
:HEX,
:SYMBOL,
:RANGE,
- :ENUM,
:O_RANGE,
- :O_ENUM,
:STRING1,
:STRING2,
"@terminals",
@@ -734,6 +657,17 @@ module EBNFParserMeta
:LHS,
"@pass"],
}.freeze
+ CLEANUP = {
+ :_alt_1 => :star,
+ :_alt_3 => :merge,
+ :_diff_1 => :opt,
+ :ebnf => :star,
+ :_ebnf_2 => :merge,
+ :_postfix_1 => :opt,
+ :seq => :plus,
+ :_seq_1 => :star,
+ :_seq_2 => :merge,
+ }.freeze
PASS = [
:PASS
].freeze
diff --git a/spec/ll1/data/parser.rb b/spec/ll1/data/parser.rb
index 6317492..e9a0079 100644
--- a/spec/ll1/data/parser.rb
+++ b/spec/ll1/data/parser.rb
@@ -29,14 +29,6 @@ class EBNFParser
input[:terminal] = token.value
end
- terminal(:ENUM, ENUM, unescape: true) do |prod, token, input|
- input[:terminal] = [:range, token.value[1..-2]]
- end
-
- terminal(:O_ENUM, O_ENUM, unescape: true) do |prod, token, input|
- input[:terminal] = [:range, token.value[1..-2]]
- end
-
terminal(:RANGE, RANGE, unescape: true) do |prod, token, input|
input[:terminal] = [:range, token.value[1..-2]]
end
@@ -61,10 +53,15 @@ class EBNFParser
input[:terminal] = token.value
end
+ production(:ebnf) do |input, current, callback|
+ # Cause method_missing to invoke something in our context
+ to_sxp
+ end
+
production(:declaration) do |input, current, callback|
# current contains a declaration.
# Invoke callback
- callback.call(:terminal) if current[:terminal] == '@terminals'
+ callback.call(:terminals) if current[:terminal] == '@terminals'
end
production(:rule) do |input, current, callback|
@@ -145,6 +142,8 @@ class EBNFParser
end
production(:_diff_1) do |input, current, callback|
+ # Gratuitous call to exercise method
+ add_prod_data(:_diff_1, "foo")
input[:diff] ||= [:diff]
# Add optimized value of `postfix`, if any
@@ -152,6 +151,8 @@ class EBNFParser
end
production(:postfix) do |input, current, callback|
+ # Gratuitous call to exercise method
+ add_prod_datum(:postfix, "foo")
# Push result onto input stack, as the `diff` production can have some number of `postfix` values that are applied recursively
input[:postfix] = case current[:postfix]
when "*" then [:star, current[:primary]]
@@ -162,6 +163,8 @@ class EBNFParser
end
production(:primary) do |input, current, callback|
+ # Gratuitous call to exercise method
+ add_prod_datum(:primary, ["foo"])
input[:primary] = if current[:expression]
v = current[:expression][1..-1]
v = v.first if v.length == 1
@@ -199,9 +202,9 @@ def initialize(input, **options, &block)
**options
) do |context, *data|
rule = case context
- when :terminal
+ when :terminals
parsing_terminals = true
- next
+ rule = EBNF::Rule.new(nil, nil, data.first, kind: :terminals)
when :pass
rule = EBNF::Rule.new(nil, nil, data.first, kind: :pass)
when :rule
@@ -218,6 +221,6 @@ def initialize(input, **options, &block)
def to_sxp
require 'sxp' unless defined?(SXP)
# Output rules as a formatted S-Expression
- SXP::Generator.string(@ast.sort_by{|r| r.id.to_f}.map(&:for_sxp))
+ SXP::Generator.string(@ast.map(&:for_sxp))
end
end
diff --git a/spec/ll1/lexer_spec.rb b/spec/ll1/lexer_spec.rb
index f0aa643..76354f9 100644
--- a/spec/ll1/lexer_spec.rb
+++ b/spec/ll1/lexer_spec.rb
@@ -196,46 +196,6 @@
end
end
- describe "#lineno" do
- it "for white space" do
- inputs = {
- "" => 1,
- "\n" => 2,
- "\n\n" => 3,
- "\r\n" => 2,
- }
- inputs.each do |input, lineno|
- lexer = tokenize(input)
- lexer.to_a # consumes the input
- expect(lexer.lineno).to eq lineno
- end
- end
-
- context "STRING_LITERAL_LONG_QUOTE" do
- it "tracks line numbers" do
- input = %(
- :Test a rdfs:Class ;
- rdfs:subClassOf mf:ManifestEntry;
- rdfs:label "Superclass of all CSVW tests" ;
- rdfs:comment """
- All CSVW tests have an input file referenced using `mf:action`. Positive
- and Negative Evaluation Tests also have a result file referenced using
- `mf:result` . Other tests may take different inputs and options as defined
- for each test class.
- """ ;
- :b :c .
- )
- expect(tokenize(input).to_a.map(&:lineno)).to include(
- 2, 2, 2, 2,
- 3, 3, 3,
- 4, 4, 4,
- 5, 5, 10,
- 11, 11, 11
- )
- end
- end
- end
-
it "matches input longer than low water mark when buffer is low" do
input = StringIO.new %("""123456789 123456789 """ """123456789 123456789 """)
lexer = EBNF::LL1::Lexer.new(input, terminals,
@@ -246,68 +206,159 @@
expect(lexer.shift.type).to eq :STRING_LITERAL_LONG_QUOTE
expect(lexer.shift.type).to eq :STRING_LITERAL_LONG_QUOTE
end
+ end
- context "yielding tokens" do
- it "annotates tokens with the current line number" do
- results = %w(1 2 3 4)
- tokenize("1\n2\n3\n4").each_token do |token|
- expect(token.type).to eq :INTEGER
- expect(token.value).to eq results.shift
- end
+ describe "#valid?" do
+ it "validates legal input" do
+ expect(tokenize(%q(:a "b" ))).to be_valid
+ end
+
+ it "invalidates illegal input" do
+ expect(tokenize(%q(:a 'open))).not_to be_valid
+ end
+ end
+
+ describe "#lineno" do
+ it "for white space" do
+ inputs = {
+ "" => 1,
+ "\n" => 2,
+ "\n\n" => 3,
+ "\r\n" => 2,
+ }
+ inputs.each do |input, lineno|
+ lexer = tokenize(input)
+ lexer.to_a # consumes the input
+ expect(lexer.lineno).to eq lineno
end
end
- describe "#first/#shift/#recover" do
- subject {tokenize("1\n2\n3\n4")}
- it "returns tokens in first/shift sequence" do
- %w{1 2 3 4}.each do |v|
- expect(subject.first.value).to eq v
- subject.shift
- end
- expect(subject.first).to be_nil
+ context "STRING_LITERAL_LONG_QUOTE" do
+ it "tracks line numbers" do
+ input = %(
+ :Test a rdfs:Class ;
+ rdfs:subClassOf mf:ManifestEntry;
+ rdfs:label "Superclass of all CSVW tests" ;
+ rdfs:comment """
+ All CSVW tests have an input file referenced using `mf:action`. Positive
+ and Negative Evaluation Tests also have a result file referenced using
+ `mf:result` . Other tests may take different inputs and options as defined
+ for each test class.
+ """ ;
+ :b :c .
+ )
+ expect(tokenize(input).to_a.map(&:lineno)).to include(
+ 2, 2, 2, 2,
+ 3, 3, 3,
+ 4, 4, 4,
+ 5, 5, 10,
+ 11, 11, 11
+ )
end
+ end
+ end
- context "with unrecognized token" do
- subject {tokenize("< space > 'foo' 1")}
+ describe "#first/#shift/#recover" do
+ subject {tokenize("1\n2\n3\n4")}
+ it "returns tokens in first/shift sequence" do
+ %w{1 2 3 4}.each do |v|
+ expect(subject.first.value).to eq v
+ subject.shift
+ end
+ expect(subject.first).to be_nil
+ end
- it "raises error with #first" do
- expect {subject.first}.to raise_error(EBNF::LL1::Lexer::Error, /Invalid token/)
- end
-
- it "recovers to next token" do
- subject.recover
- expect(subject.first.value).to eq "'foo'"
- end
+ context "with unrecognized token" do
+ subject {tokenize("< space > 'foo' 1")}
+
+ it "raises error with #first" do
+ expect {subject.first}.to raise_error(EBNF::LL1::Lexer::Error, /Invalid token/)
end
+
+ it "recovers to next token" do
+ subject.recover
+ expect(subject.first.value).to eq "'foo'"
+ end
+ end
- describe "#first" do
- it "returns a token when passed as an argument" do
- expect(subject.first(:INTEGER)).to be_a(EBNF::LL1::Lexer::Token)
- end
+ describe "#first" do
+ it "returns a token when passed as an argument" do
+ expect(subject.first(:INTEGER)).to be_a(EBNF::LL1::Lexer::Token)
+ end
- it "does not return a token unless passed as an argument" do
- expect {subject.first(:Double)}.to raise_error(EBNF::LL1::Lexer::Error, 'Invalid token "1"')
- end
+ it "does not return a token unless passed as an argument" do
+ expect {subject.first(:Double)}.to raise_error(EBNF::LL1::Lexer::Error, 'Invalid token "1"')
end
end
+ end
- describe EBNF::LL1::Lexer::Terminal do
- {
- "returns itself with no map entry": {
- input: "FOO",
- map: {},
- expect: "FOO"
- },
- "returns map value if specified": {
- input: "FOO",
- map: {"foo" => 'bar'},
- expect: "bar"
- },
- }.each do |name, params|
- it name do
- term = described_class.new(:nil, params[:regexp], map: params[:map])
- expect(term.canonicalize(params[:input])).to eq params[:expect]
- end
+ describe EBNF::LL1::Lexer::Token do
+ subject {described_class.new(:type, 'value', lineno: 1)}
+
+ describe "#type" do
+ its(:type) {is_expected.to eq :type}
+ end
+
+ describe "#value" do
+ its(:value) {is_expected.to eq 'value'}
+ end
+
+ describe "#lineno" do
+ its(:lineno) {is_expected.to eq 1}
+ end
+
+ describe "#[]" do
+ it "returns type at 0 index" do
+ expect(subject[0]).to eq :type
+ end
+
+ it "returns value at 1 index" do
+ expect(subject[1]).to eq 'value'
+ end
+
+ it "returns nil for other indexes" do
+ expect(subject[2]).to be_nil
+ end
+ end
+
+ describe "#===" do
+ specify {expect(subject).to be === :type}
+ specify {expect(subject).to be === 'value'}
+ end
+
+ describe "#to_hash" do
+ specify {expect(subject.to_hash).to eql({type: :type, value: 'value'})}
+ end
+
+ describe "#to_s" do
+ specify {expect(subject.to_s).to eq ":type"}
+ end
+
+ describe "#representation" do
+ specify {expect(subject.representation).to eq :type}
+ end
+
+ describe "#to_a" do
+ specify {expect(subject.to_a).to eq [:type, 'value']}
+ end
+ end
+
+ describe EBNF::LL1::Lexer::Terminal do
+ {
+ "returns itself with no map entry": {
+ input: "FOO",
+ map: {},
+ expect: "FOO"
+ },
+ "returns map value if specified": {
+ input: "FOO",
+ map: {"foo" => 'bar'},
+ expect: "bar"
+ },
+ }.each do |name, params|
+ it name do
+ term = described_class.new(:nil, params[:regexp], map: params[:map])
+ expect(term.canonicalize(params[:input])).to eq params[:expect]
end
end
end
diff --git a/spec/ll1/parser_spec.rb b/spec/ll1/parser_spec.rb
index b1cc445..3d85c0b 100644
--- a/spec/ll1/parser_spec.rb
+++ b/spec/ll1/parser_spec.rb
@@ -58,6 +58,12 @@ class LL1ParserTest
subject.parse("foo", nil, branch: {a: {b: ["c"]}})
}.to raise_error(EBNF::LL1::Parser::Error, "Starting production not defined")
end
+
+ it "raises error on inalid input" do
+ expect {
+ subject.parse("bar", :foo, branch: {foo: {bar: ["baz"]}})
+ }.to raise_error(EBNF::LL1::Parser::Error, /Invalid token "bar"/)
+ end
end
require_relative "data/parser"
diff --git a/spec/ll1_spec.rb b/spec/ll1_spec.rb
index 35356bd..7dbac19 100644
--- a/spec/ll1_spec.rb
+++ b/spec/ll1_spec.rb
@@ -86,12 +86,12 @@
[18] IRIREF ::= '<' ("range" | UCHAR)* '>'
[29t] SPARQL_BASE ::= [Bb][Aa][Ss][Ee]
},
- %{
- ((rule _empty "0" (first _eps) (seq))
- (terminal IRIREF "18" (seq "<" (star (alt "range" UCHAR)) ">"))
- (rule sparqlBase "29s" (first SPARQL_BASE) (seq SPARQL_BASE IRIREF))
- (rule _sparqlBase_1 "29s.1" (first IRIREF) (seq IRIREF))
- (terminal SPARQL_BASE "29t" (seq (range "Bb") (range "Aa") (range "Ss") (range "Ee"))))
+ %{(
+ (rule _empty "0" (first _eps) (seq))
+ (terminal IRIREF "18" (seq "<" (star (alt "range" UCHAR)) ">"))
+ (rule sparqlBase "29s" (first SPARQL_BASE) (seq SPARQL_BASE IRIREF))
+ (terminal SPARQL_BASE "29t" (seq (range "Bb") (range "Aa") (range "Ss") (range "Ee")))
+ (rule _sparqlBase_1 "29s.1" (first IRIREF) (seq IRIREF)))
}, nil
],
"declaration (FF.1)" => [
@@ -372,6 +372,11 @@
expect(false).to produce(true, @debug)
}.to raise_error("Table creation failed with errors")
expect(ebnf.errors.to_s).to match(expected)
+
+ sio = StringIO.new
+ ebnf.to_ruby(sio)
+ sio.rewind
+ expect(sio.read).to match(/Note, grammar has errors/)
end
end
end
diff --git a/spec/native_spec.rb b/spec/native_spec.rb
new file mode 100644
index 0000000..8c71fea
--- /dev/null
+++ b/spec/native_spec.rb
@@ -0,0 +1,137 @@
+# coding: utf-8
+$:.unshift "."
+require 'spec_helper'
+require 'ebnf'
+require 'sxp'
+
+describe EBNF::Native do
+ let(:logger) {RDF::Spec.logger}
+ after(:each) do |example|
+ puts logger.to_s if example.exception && !example.exception.is_a?(RSpec::Expectations::ExpectationNotMetError)
+ end
+
+ context "rule variations" do
+ {
+ "legal rule name": [
+ 'rulename ::= "foo"',
+ %{((rule rulename (seq "foo")))}
+ ],
+ "prolog": [
+ %{[2] Prolog ::= BaseDecl? PrefixDecl*},
+ %{((rule Prolog "2" (seq (opt BaseDecl) (star PrefixDecl))))}
+ ],
+ "aliteration": [
+ %{[2] declaration ::= '@terminals' | '@pass'},
+ %{((rule declaration "2" (alt "@terminals" "@pass")))},
+ ],
+ "posfix": [
+ %{[9] postfix ::= primary ( [?*+] )?},
+ %{((rule postfix "9" (seq primary (opt (range "?*+")))))},
+ ],
+ "diff": [
+ %{[18] STRING2 ::= "'" (CHAR - "'")* "'"},
+ %{((terminal STRING2 "18" (seq "'" (star (diff CHAR "'")) "'")))},
+ ],
+ "IRIREF": [
+ %([18] IRIREF ::= '<' ([^<>"{}|^`\]-[#x00-#x20] | UCHAR)* '>'),
+ %{((terminal IRIREF "18"
+ (seq "<"
+ (star
+ (alt
+ (diff (range "^<>\\\"{}|^`") (range "#x00-#x20"))
+ UCHAR))
+ ">")))},
+ ],
+ }.each do |title, (input, expect)|
+ it title do
+ expect(parse(input).to_sxp).to produce(expect, logger)
+ end
+ end
+
+ context "without rule identifiers" do
+ {
+ "prolog": [
+ %{Prolog ::= BaseDecl? PrefixDecl*},
+ %{((rule Prolog (seq (opt BaseDecl) (star PrefixDecl))))}
+ ],
+ "aliteration": [
+ %{declaration ::= '@terminals' | '@pass'},
+ %{((rule declaration (alt "@terminals" "@pass")))},
+ ],
+ "posfix": [
+ %{postfix ::= primary ( [?*+] )?},
+ %{((rule postfix (seq primary (opt (range "?*+")))))},
+ ],
+ "diff": [
+ %{STRING2 ::= "'" (CHAR - "'")* "'"},
+ %{((terminal STRING2 (seq "'" (star (diff CHAR "'")) "'")))},
+ ],
+ "IRIREF": [
+ %(IRIREF ::= '<' ([^<>"{}|^`\]-[#x00-#x20] | UCHAR)* '>'),
+ %{((terminal IRIREF
+ (seq "<"
+ (star
+ (alt
+ (diff (range "^<>\\\"{}|^`") (range "#x00-#x20"))
+ UCHAR))
+ ">")))},
+ ],
+ }.each do |title, (input, expect)|
+ it title do
+ expect(parse(input).to_sxp).to produce(expect, logger)
+ end
+ end
+ end
+ end
+
+ describe "#expression" do
+ {
+ "'abc' def" => %{(seq "abc" def)},
+ %{[0-9]} => %{(range "0-9")},
+ %{#x00B7} => %{(hex "#x00B7")},
+ %{[#x0300-#x036F]} => %{(range "#x0300-#x036F")},
+ %{[^<>'{}|^`]-[#x00-#x20]} => %{(diff (range "^<>'{}|^`") (range "#x00-#x20"))},
+ %{a b c} => %{(seq a b c)},
+ %{a? b c} => %{(seq (opt a) b c)},
+ %{a - b} => %{(diff a b)},
+ %{(a - b) - c} => %{(diff (diff a b) c)},
+ %{a b? c} => %{(seq a (opt b) c)},
+ %{a | b | c} => %{(alt a b c)},
+ %{a? b+ c*} => %{(seq (opt a) (plus b) (star c))},
+ %{foo | x xlist} => %{(alt foo (seq x xlist))},
+ %{a | (b - c)} => %{(alt a (diff b c))},
+ %{a b | c d} => %{(alt (seq a b) (seq c d))},
+ %{BaseDecl? PrefixDecl*} => %{(seq (opt BaseDecl) (star PrefixDecl))},
+ %{NCCHAR1 | '-' | [0-9] | #x00B7 | [#x0300-#x036F] | [#x203F-#x2040]} =>
+ %{(alt NCCHAR1 "-" (range "0-9") (hex "#x00B7") (range "#x0300-#x036F") (range "#x203F-#x2040"))},
+ %{'<' ([^<>"{}|^`\]-[#x00-#x20] | UCHAR)* '>'} =>
+ %{(seq "<" (star (alt (diff (range "^<>\\\"{}|^`") (range "#x00-#x20")) UCHAR)) ">")}
+ }.each do |input, expected|
+ it "given #{input.inspect} produces #{expected}" do
+ rule = parse("rule ::= #{input}").ast.first
+ expect(rule.expr.to_sxp).to produce(expected, @debug)
+ end
+ end
+ end
+
+ context "illegal syntax" do
+ {
+ "diff missing second operand": %{rule ::= a -},
+ "unrecognized terminal" => %{rule ::= %foo%},
+ }.each do |title, input|
+ it title do
+ expect {parse(input)}.to raise_error(SyntaxError)
+ end
+ end
+ end
+
+ it "parses EBNF grammar" do
+ gram = parse(File.open(File.expand_path("../../etc/ebnf.ebnf", __FILE__)))
+ expect(gram).to be_valid
+ end
+
+ def parse(input, **options)
+ @debug = []
+ EBNF.parse(input, debug: @debug, format: :native, **options)
+ end
+end
diff --git a/spec/parser_spec.rb b/spec/parser_spec.rb
index 1da0f06..c72935b 100644
--- a/spec/parser_spec.rb
+++ b/spec/parser_spec.rb
@@ -4,73 +4,147 @@
require 'ebnf'
require 'sxp'
-describe EBNF::Base do
- describe "#ruleParts" do
+describe EBNF::Parser do
+ let(:logger) {RDF::Spec.logger}
+ after(:each) do |example|
+ puts logger.to_s if example.exception && !example.exception.is_a?(RSpec::Expectations::ExpectationNotMetError)
+ end
+
+ context "rule variations" do
{
- %{[2] Prolog ::= BaseDecl? PrefixDecl*} =>
- %{(rule Prolog "2" (seq (opt BaseDecl) (star PrefixDecl)))},
- %{[2] declaration ::= '@terminals' | '@pass'} =>
- %{(rule declaration "2" (alt "@terminals" "@pass"))},
- %{[9] postfix ::= primary ( [?*+] )?} =>
- %{(rule postfix "9" (seq primary (opt (range "?*+"))))},
- %{[18] STRING2 ::= "'" (CHAR - "'")* "'"} =>
- %{(terminal STRING2 "18" (seq "'" (star (diff CHAR "'")) "'"))},
- }.each do |input, expected|
- it "given #{input.inspect} produces #{expected}" do
- expect(ebnf(:ruleParts, input).to_sxp).to produce(expected, @debug)
+ "legal rule name": [
+ 'rulename ::= "foo"',
+ %{((rule rulename (seq "foo")))}
+ ],
+ "prolog": [
+ %{[2] Prolog ::= BaseDecl? PrefixDecl*},
+ %{((rule Prolog "2" (seq (opt BaseDecl) (star PrefixDecl))))}
+ ],
+ "aliteration": [
+ %{[2] declaration ::= '@terminals' | '@pass'},
+ %{((rule declaration "2" (alt "@terminals" "@pass")))},
+ ],
+ "posfix": [
+ %{[9] postfix ::= primary ( [?*+] )?},
+ %{((rule postfix "9" (seq primary (opt (range "?*+")))))},
+ ],
+ "diff": [
+ %{[18] STRING2 ::= "'" (CHAR - "'")* "'"},
+ %{((terminal STRING2 "18" (seq "'" (star (diff CHAR "'")) "'")))},
+ ],
+ "IRIREF": [
+ %([18] IRIREF ::= '<' ([^<>"{}|^`\]-[#x00-#x20] | UCHAR)* '>'),
+ %{((terminal IRIREF "18"
+ (seq "<"
+ (star
+ (alt
+ (diff (range "^<>\\\"{}|^`") (range "#x00-#x20"))
+ UCHAR))
+ ">")))},
+ ],
+ "minimal whitespace": [
+ %{[xx]minimal::=whitespace[yy]whitespace::=PASS},
+ %{((rule minimal "xx" (seq whitespace (range "yy")))
+ (rule whitespace (seq PASS)))}
+ ]
+ }.each do |title, (input, expect)|
+ it title do
+ expect(parse(input).to_sxp).to produce(expect, logger)
+ end
+ end
+
+ context "without rule identifiers" do
+ {
+ "prolog": [
+ %{Prolog ::= BaseDecl? PrefixDecl*},
+ %{((rule Prolog (seq (opt BaseDecl) (star PrefixDecl))))}
+ ],
+ "aliteration": [
+ %{declaration ::= '@terminals' | '@pass'},
+ %{((rule declaration (alt "@terminals" "@pass")))},
+ ],
+ "posfix": [
+ %{postfix ::= primary ( [?*+] )?},
+ %{((rule postfix (seq primary (opt (range "?*+")))))},
+ ],
+ "diff": [
+ %{STRING2 ::= "'" (CHAR - "'")* "'"},
+ %{((terminal STRING2 (seq "'" (star (diff CHAR "'")) "'")))},
+ ],
+ "IRIREF": [
+ %(IRIREF ::= '<' ([^<>"{}|^`\]-[#x00-#x20] | UCHAR)* '>'),
+ %{((terminal IRIREF
+ (seq "<"
+ (star
+ (alt
+ (diff (range "^<>\\\"{}|^`") (range "#x00-#x20"))
+ UCHAR))
+ ">")))},
+ ],
+ }.each do |title, (input, expect)|
+ it title do
+ expect(parse(input).to_sxp).to produce(expect, logger)
+ end
end
end
end
-
+
describe "#expression" do
{
- "'abc' def" => %{((seq "abc" def) "")},
- %{[0-9]} => %{((range "0-9") "")},
- %{#x00B7} => %{((hex "#x00B7") "")},
- %{[#x0300-#x036F]} => %{((range "#x0300-#x036F") "")},
- %{[^<>'{}|^`]-[#x00-#x20]} => %{((diff (range "^<>'{}|^`") (range "#x00-#x20")) "")},
- %{a b c} => %{((seq a b c) "")},
- %{a? b c} => %{((seq (opt a) b c) "")},
- %(a - b) => %{((diff a b) "")},
- %((a - b) - c) => %{((diff (diff a b) c) "")},
- %(a b? c) => %{((seq a (opt b) c) "")},
- %(a | b | c) => %{((alt a b c) "")},
- %(a? b+ c*) => %{((seq (opt a) (plus b) (star c)) "")},
- %( | x xlist) => %{((alt (seq ()) (seq x xlist)) "")},
- %(a | (b - c)) => %{((alt a (diff b c)) "")},
- %(a b | c d) => %{((alt (seq a b) (seq c d)) "")},
- %{a) b c} => %{(a " b c")},
- %(BaseDecl? PrefixDecl*) => %{((seq (opt BaseDecl) (star PrefixDecl)) "")},
- %(NCCHAR1 | '-' | [0-9] | #x00B7 | [#x0300-#x036F] | [#x203F-#x2040]) =>
- %{((alt NCCHAR1 "-" (range "0-9") (hex "#x00B7") (range "#x0300-#x036F") (range "#x203F-#x2040")) "")}
+ "'abc' def" => %{(seq "abc" def)},
+ %{[0-9]} => %{(range "0-9")},
+ %{#x00B7} => %{(hex "#x00B7")},
+ %{[#x0300-#x036F]} => %{(range "#x0300-#x036F")},
+ %{[^<>'{}|^`]-[#x00-#x20]} => %{(diff (range "^<>'{}|^`") (range "#x00-#x20"))},
+ %{a b c} => %{(seq a b c)},
+ %{a? b c} => %{(seq (opt a) b c)},
+ %{a - b} => %{(diff a b)},
+ %{(a - b) - c} => %{(diff (diff a b) c)},
+ %{a b? c} => %{(seq a (opt b) c)},
+ %{a | b | c} => %{(alt a b c)},
+ %{a? b+ c*} => %{(seq (opt a) (plus b) (star c))},
+ %{foo | x xlist} => %{(alt foo (seq x xlist))},
+ %{a | (b - c)} => %{(alt a (diff b c))},
+ %{a b | c d} => %{(alt (seq a b) (seq c d))},
+ %{[a-z]} => %{(range "a-z")},
+ %{[a-zA-Z]} => %{(range "a-zA-Z")},
+ %{[#x20-#x22]} => %{(range "#x20-#x22")},
+ %{[abc]} => %{(range "abc")},
+ %{[abc-]} => %{(range "abc-")},
+ %{[#x20#x21#x22]} => %{(range "#x20#x21#x22")},
+ %{BaseDecl? PrefixDecl*} => %{(seq (opt BaseDecl) (star PrefixDecl))},
+ %{NCCHAR1 | '-' | [0-9] | #x00B7 | [#x0300-#x036F] | [#x203F-#x2040]} =>
+ %{(alt NCCHAR1 "-" (range "0-9") (hex "#x00B7") (range "#x0300-#x036F") (range "#x203F-#x2040"))},
+ %{'<' ([^<>"{}|^`\]-[#x00-#x20] | UCHAR)* '>'} =>
+ %{(seq "<" (star (alt (diff (range "^<>\\\"{}|^`") (range "#x00-#x20")) UCHAR)) ">")},
}.each do |input, expected|
it "given #{input.inspect} produces #{expected}" do
- expect(ebnf(:expression, input).to_sxp).to produce(expected, @debug)
+ rule = parse("rule ::= #{input}").ast.first
+ expect(rule.expr.to_sxp).to produce(expected, @debug)
end
end
end
- describe "#diff" do
+ context "illegal syntax" do
{
- %{'abc' def} => %{("abc" " def")},
- %{[0-9]} => %{((range "0-9") "")},
- %{#x00B7} => %{((hex "#x00B7") "")},
- %{[#x0300-#x036F]} => %{((range "#x0300-#x036F") "")},
- %{[^<>'{}|^`]-[#x00-#x20]} => %{((diff (range "^<>'{}|^`") (range "#x00-#x20")) "")},
- %{a b c} => %{(a " b c")},
- %{a? b c} => %{((opt a) " b c")},
- %{( [?*+] )?} => %{((opt (range "?*+")) "")},
- %(a - b) => %{((diff a b) "")},
- }.each do |input, expected|
- it "given #{input.inspect} produces #{expected}" do
- expect(ebnf(:diff, input).to_sxp).to produce(expected, @debug)
+ "illegal rule name": %{$rule.name ::= foo},
+ "diff missing second operand": %{rule ::= a -},
+ "unrecognized terminal" => %{rule ::= %foo%},
+ "unopened paren" => %{rule ::= a) b c}
+ }.each do |title, input|
+ it title do
+ expect {parse(input)}.to raise_error(SyntaxError)
end
end
end
-
- def ebnf(method, value, **options)
+
+ it "parses EBNF grammar" do
+ gram = parse(File.open(File.expand_path("../../etc/ebnf.ebnf", __FILE__)))
+ expect(gram).to be_valid
+ end
+
+ def parse(input, **options)
@debug = []
- options = {debug: @debug}.merge(options)
- EBNF::Base.new("", **options).send(method, value)
+ EBNF.parse(input, debug: @debug, format: :ebnf, **options)
end
end
diff --git a/spec/peg/data/parser.rb b/spec/peg/data/parser.rb
index de7cb26..b15964b 100644
--- a/spec/peg/data/parser.rb
+++ b/spec/peg/data/parser.rb
@@ -26,14 +26,6 @@ class EBNFPegParser
terminal(:HEX, HEX)
- terminal(:ENUM, ENUM, unescape: true) do |value|
- [:range, value[1..-2]]
- end
-
- terminal(:O_ENUM, O_ENUM, unescape: true) do |value|
- [:range, value[1..-2]]
- end
-
terminal(:RANGE, RANGE, unescape: true) do |value|
[:range, value[1..-2]]
end
@@ -52,17 +44,23 @@ class EBNFPegParser
terminal(:POSTFIX, POSTFIX)
+ production(:ebnf) do |input|
+ # Cause method_missing to invoke something in our context
+ to_sxp
+ end
+
production(:declaration, clear_packrat: true) do |value, data, callback|
# current contains a declaration.
# Invoke callback
- callback.call(:terminal) if value == '@terminals'
+ callback.call(:terminals) if value == '@terminals'
end
+ start_production(:rule, as_hash: true)
production(:rule, clear_packrat: true) do |value, data, callback|
# current contains an expression.
# Invoke callback
- id, sym = value.first[:LHS]
- expression = value.last[:expression]
+ id, sym = value[:LHS]
+ expression = value[:expression]
callback.call(:rule, EBNF::Rule.new(sym.to_sym, id, expression))
end
@@ -86,11 +84,12 @@ class EBNFPegParser
value.length == 1 ? value.first : ([:seq] + value)
end
+ start_production(:diff, as_hash: true)
production(:diff) do |value|
- if value.last[:_diff_1]
- [:diff, value.first[:postfix], value.last[:_diff_1]]
+ if value[:_diff_1]
+ [:diff, value[:postfix], value[:_diff_1]]
else
- value.first[:postfix]
+ value[:postfix]
end
end
@@ -98,13 +97,14 @@ class EBNFPegParser
value.last[:postfix] if value
end
+ start_production(:postfix, as_hash: true)
production(:postfix) do |value|
# Push result onto input stack, as the `diff` production can have some number of `postfix` values that are applied recursively
- case value.last[:_postfix_1]
- when "*" then [:star, value.first[:primary]]
- when "+" then [:plus, value.first[:primary]]
- when "?" then [:opt, value.first[:primary]]
- else value.first[:primary]
+ case value[:_postfix_1]
+ when "*" then [:star, value[:primary]]
+ when "+" then [:plus, value[:primary]]
+ when "?" then [:opt, value[:primary]]
+ else value[:primary]
end
end
@@ -112,9 +112,10 @@ class EBNFPegParser
Array(value).length > 2 ? value[1][:expression] : value
end
+ start_production(:pass, as_hash: true)
production(:pass) do |value, data, callback|
# Invoke callback
- callback.call(:pass, value.last[:expression])
+ callback.call(:pass, value[:expression])
end
# ## Parser invocation.
@@ -142,9 +143,9 @@ def initialize(input, **options, &block)
**options
) do |context, *data|
rule = case context
- when :terminal
+ when :terminals
parsing_terminals = true
- next
+ rule = EBNF::Rule.new(nil, nil, data.first, kind: :terminals)
when :pass
rule = EBNF::Rule.new(nil, nil, data.first, kind: :pass)
when :rule
@@ -161,6 +162,6 @@ def initialize(input, **options, &block)
def to_sxp
require 'sxp' unless defined?(SXP)
# Output rules as a formatted S-Expression
- SXP::Generator.string(@ast.sort_by{|r| r.id.to_f}.map(&:for_sxp))
+ SXP::Generator.string(@ast.map(&:for_sxp))
end
end
diff --git a/spec/peg/parser_spec.rb b/spec/peg/parser_spec.rb
index 1df502f..5fffbc5 100644
--- a/spec/peg/parser_spec.rb
+++ b/spec/peg/parser_spec.rb
@@ -81,9 +81,10 @@ class PegParserTest
{
"" => %r{syntax error, expecting "0-9", :integer },
- "10 x 1" => %r{syntax error, expecting "0-9", "\+", :operator},
+ "10 x 1" => %r{syntax error, expecting "\+", :operator},
"1-1" => %r{syntax error, expecting "0-9", "\+", :operator},
"foo" => %r{syntax error, expecting "0-9", :integer},
+ "3 1 + 2" => %r{syntax error, expecting "\+", :operator}
}.each do |input, expected|
it "fails to parse #{input.inspect} to #{expected.inspect}" do
expect {
diff --git a/spec/peg/rule_spec.rb b/spec/peg/rule_spec.rb
index 40e8aed..e3838c1 100644
--- a/spec/peg/rule_spec.rb
+++ b/spec/peg/rule_spec.rb
@@ -29,6 +29,16 @@
input: "C",
expect: :unmatched
},
+ "(not A) with 'A'" => {
+ rule: [:not, "A"],
+ input: "A",
+ expect: :unmatched
+ },
+ "(not A) with 'B'" => {
+ rule: [:not, "A"],
+ input: "B",
+ expect: nil
+ },
"(opt A) with 'A'" => {
rule: [:opt, "A"],
input: "A",
@@ -123,13 +133,148 @@
it name do
rule = EBNF::Rule.new(:rule, "0", params[:rule]).extend(EBNF::PEG::Rule)
rule.parser = parser
- expect(parser).to receive(:onStart).with(Symbol)
+ expect(parser).to receive(:onStart).with(Symbol).and_return({})
expect(parser).to receive(:onFinish).with(params[:expect]).and_return(params[:expect])
expect(parser).not_to receive(:onTerminal).with(Symbol)
expect(rule.parse(EBNF::LL1::Scanner.new(params[:input]))).to eql(params[:expect])
end
end
+
+ context "with as_hash: true" do
+ {
+ "(alt 'A' 'B') with 'A'" => {
+ rule: [:alt, "A", "B"],
+ input: "A",
+ expect: "A"
+ },
+ "(alt 'A' 'B') with ' A '" => {
+ rule: [:alt, "A", "B"],
+ input: " A ",
+ expect: "A"
+ },
+ "(alt 'A' 'B') with 'B'" => {
+ rule: [:alt, "A", "B"],
+ input: "B",
+ expect: "B"
+ },
+ "(alt 'A' 'B') with 'C'" => {
+ rule: [:alt, "A", "B"],
+ input: "C",
+ expect: :unmatched
+ },
+ "(not A) with 'A'" => {
+ rule: [:not, "A"],
+ input: "A",
+ expect: :unmatched
+ },
+ "(not A) with 'B'" => {
+ rule: [:not, "A"],
+ input: "B",
+ expect: nil
+ },
+ "(opt A) with 'A'" => {
+ rule: [:opt, "A"],
+ input: "A",
+ expect: "A"
+ },
+ "(opt A) with 'A' and whitespace" => {
+ rule: [:opt, "A"],
+ input: " A",
+ expect: "A"
+ },
+ "(opt A) with 'B'" => {
+ rule: [:opt, "A"],
+ input: "B",
+ expect: nil
+ },
+ "(plus A) with ''" => {
+ rule: [:plus, "A"],
+ input: "",
+ expect: :unmatched
+ },
+ "(plus A) with 'A'" => {
+ rule: [:plus, "A"],
+ input: "A",
+ expect: %w(A)
+ },
+ "(plus A) with 'A B'" => {
+ rule: [:plus, "A"],
+ input: "A B",
+ expect: %w(A)
+ },
+ "(plus A) with 'AAA'" => {
+ rule: [:plus, "A"],
+ input: "AAA",
+ expect: %w(A A A)
+ },
+ "(plus A) with ' A A A '" => {
+ rule: [:plus, "A"],
+ input: " A A A ",
+ expect: %w(A A A)
+ },
+ "(seq 'A' 'B')" => {
+ rule: [:seq, "A", "B"],
+ input: "A B",
+ expect: {A: "A", B: "B"}
+ },
+ "(seq 'A' 'B') with no whitespace" => {
+ rule: [:seq, "A", "B"],
+ input: "AB",
+ expect: {A: "A", B: "B"}
+ },
+ "(seq 'A' 'B') with added whitespace" => {
+ rule: [:seq, "A", "B"],
+ input: " A B ",
+ expect: {A: "A", B: "B"}
+ },
+ "(seq 'A' 'B') with 'A'" => {
+ rule: [:seq, "A", "B"],
+ input: " A ",
+ expect: :unmatched
+ },
+ "(seq 'A' 'B') with 'AC'" => {
+ rule: [:seq, "A", "B"],
+ input: "AC",
+ expect: :unmatched
+ },
+ "(star A) with ''" => {
+ rule: [:star, "A"],
+ input: "",
+ expect: []
+ },
+ "(star A) with 'A'" => {
+ rule: [:star, "A"],
+ input: "A",
+ expect: %w(A)
+ },
+ "(star A) with 'A B'" => {
+ rule: [:star, "A"],
+ input: "A B",
+ expect: %w(A)
+ },
+ "(star A) with 'AAA'" => {
+ rule: [:star, "A"],
+ input: "AAA",
+ expect: %w(A A A)
+ },
+ "(star A) with ' A A A '" => {
+ rule: [:star, "A"],
+ input: " A A A ",
+ expect: %w(A A A)
+ },
+ }.each do |name, params|
+ it name do
+ rule = EBNF::Rule.new(:rule, "0", params[:rule]).extend(EBNF::PEG::Rule)
+ rule.parser = parser
+ expect(parser).to receive(:onStart).with(Symbol).and_return({as_hash: true})
+ expect(parser).to receive(:onFinish).with(params[:expect]).and_return(params[:expect])
+ expect(parser).not_to receive(:onTerminal).with(Symbol)
+
+ expect(rule.parse(EBNF::LL1::Scanner.new(params[:input]))).to eql(params[:expect])
+ end
+ end
+ end
end
context "terminal rules" do
@@ -169,6 +314,24 @@
input: "B",
expect: :unmatched
},
+ '(istr "foo") with "foo"' => {
+ rule: [:istr, "foo"],
+
+ input: "foo",
+ expect: "foo"
+ },
+ '(istr "foo") with "FOO"' => {
+ rule: [:istr, "foo"],
+
+ input: "FOO",
+ expect: "FOO"
+ },
+ '(istr "fOo") with "FoO"' => {
+ rule: [:istr, "fOo"],
+
+ input: "FoO",
+ expect: "FoO"
+ },
"(range A-C) with 'A'" => {
rule: [:range, "A-C"],
input: "A",
@@ -253,7 +416,7 @@
it name do
rule = EBNF::Rule.new(:rule, "0", params[:rule], kind: :terminal).extend(EBNF::PEG::Rule)
rule.parser = parser
- expect(parser).to receive(:onStart).with(Symbol)
+ expect(parser).to receive(:onStart).with(Symbol).and_return({})
expect(parser).to receive(:onFinish).with(params[:expect]).and_return(params[:expect])
expect(parser).not_to receive(:onTerminal)
expect(parser).to receive(:find_terminal_regexp).with(:rule)
diff --git a/spec/peg_spec.rb b/spec/peg_spec.rb
index e940757..a354203 100644
--- a/spec/peg_spec.rb
+++ b/spec/peg_spec.rb
@@ -14,15 +14,13 @@
%{
[9] primary ::= HEX
| RANGE
- | ENUM
| O_RANGE
- | O_ENUM
| STRING1
| STRING2
| '(' expression ')'
} =>
- %{((rule primary "9" (alt HEX RANGE ENUM O_RANGE O_ENUM STRING1 STRING2 _primary_1))
+ %{((rule primary "9" (alt HEX RANGE O_RANGE STRING1 STRING2 _primary_1))
(rule _primary_1 "9.1" (seq "(" expression ")")))},
%{[1] start ::= A B C} =>
%{((rule start "1" (seq A B C)))},
diff --git a/spec/rule_spec.rb b/spec/rule_spec.rb
index 00c630f..36b2d5e 100644
--- a/spec/rule_spec.rb
+++ b/spec/rule_spec.rb
@@ -6,70 +6,309 @@
describe EBNF::Rule do
let(:debug) {[]}
- let(:ebnf) {EBNF.parse("", debug: debug)}
- subject {EBNF::Rule.new("rule", "0", [], ebnf: ebnf)}
+ let(:ebnf) {EBNF.parse(File.open(File.expand_path("../../etc/ebnf.ebnf", __FILE__)))}
+ subject {EBNF::Rule.new(:rule, "0", [:seq, :foo])}
- describe "#ttl_expr" do
+ describe ".from_sxp" do
+ context "accepts valid variations" do
+ {
+ "ebnf[1]": [
+ %{(rule ebnf "1" (star (alt declaration rule)))},
+ EBNF::Rule.new(:ebnf, "1", [:star, [:alt, :declaration, :rule]])
+ ],
+ "ebnf[1] parsed": [
+ [:rule, :ebnf, "1", [:star, [:alt, :declaration, :rule]]],
+ EBNF::Rule.new(:ebnf, "1", [:star, [:alt, :declaration, :rule]], kind: :rule)
+ ],
+ "pass": [
+ %{(pass _pass (plus (range "#x9#xA#xD#x20")))},
+ EBNF::Rule.new(nil, nil, [:plus, [:range, "#x9#xA#xD#x20"]], kind: :pass)
+ ],
+ "alt": [
+ %{(rule alt (alt a b c))},
+ EBNF::Rule.new(:alt, nil, [:alt, :a, :b, :c], kind: :rule)
+ ],
+ "diff": [
+ %{(terminal R_CHAR "21" (diff CHAR "]"))},
+ EBNF::Rule.new(:R_CHAR, "21", [:diff, :CHAR, "]"], kind: :terminal)
+ ],
+ "istr": [
+ %{(terminal nc (istr "foo"))},
+ EBNF::Rule.new(:nc, nil, [:istr, "foo"], kind: :terminal)
+ ],
+ "not": [
+ %{(rule _a_1 "n.1" (not op1))},
+ EBNF::Rule.new(:_a_1, "n.1", [:not, :op1], kind: :rule)
+ ],
+ "opt": [
+ %{(rule _diff_1 "7.1" (opt _diff_2))},
+ EBNF::Rule.new(:_diff_1, "7.1", [:opt, :_diff_2], kind: :rule)
+ ],
+ "plus": [
+ %{(rule seq "6" (plus diff))},
+ EBNF::Rule.new(:seq, "6", [:plus, :diff], kind: :rule)
+ ],
+ "rept": [
+ %{(rule rept "6" (rept 1 "*" diff))},
+ EBNF::Rule.new(:rept, "6", [:rept, 1, "*", :diff])
+ ],
+ "rept m.n": [
+ %{(rule rept "6" (rept 3 5 diff))},
+ EBNF::Rule.new(:rept, "6", [:rept, 3, 5, :diff])
+ ],
+ "seq": [
+ %{(rule seq (seq a b c))},
+ EBNF::Rule.new(:seq, nil, [:seq, :a, :b, :c], kind: :rule)
+ ],
+ "star": [
+ %{(rule _alt_1 "5.1" (star _alt_2))},
+ EBNF::Rule.new(:_alt_1, "5.1", [:star, :_alt_2], kind: :rule)
+ ]
+ }.each do |title, (sxp, expected)|
+ it title do
+ res = EBNF::Rule.from_sxp(sxp)
+ expect(res).to eq expected
+ end
+ end
+ end
+
+ context "rejects invalid variations" do
+ {
+ "alt (empty)": %{(rule alt (alt))},
+ "diff (empty)": %{(terminal R_CHAR "21" (diff))},
+ "diff (one)": %{(terminal R_CHAR "21" (diff CHAR))},
+ "diff (three)": %{(terminal R_CHAR "21" (diff CHAR "]" ","))},
+ "hex (empty)": %{(terminal hex (hex))},
+ "hex (two)": %{(terminal hex (hex #x01 #x02))},
+ "istr (empty)": %{(terminal nc (istr))},
+ "istr (two)": %{(terminal nc (istr "foo" "bar"))},
+ "not (empty)": %{(rule _a_1 "n.1" (not))},
+ "not (two)": %{(rule _a_1 "n.1" (not op1 op2))},
+ "opt (empty)": %{(rule _diff_1 "7.1" (opt))},
+ "plus (empty)": %{(rule seq "6" (plus))},
+ "plus (two)": %{(rule seq "6" (plus diff extra))},
+ "rept (empty)": %{(rule rept "6" (rept))},
+ "rept (one)": %{(rule rept "6" (rept 1))},
+ "rept (two)": %{(rule rept "6" (rept 1 "*"))},
+ "rept (four)": %{(rule rept "6" (rept 1 "*" diff extra))},
+ "rept (float min)": %{(rule rept "6" (rept 1.1 1 diff))},
+ "rept (negative min)": %{(rule rept "6" (rept -1 1 diff))},
+ "rept (float max)": %{(rule rept "6" (rept 1 1.1 diff))},
+ "rept (negative max)": %{(rule rept "6" (rept 1 -1 diff))},
+ "star (empty)": %{(rule _alt_1 "5.1" (star))},
+ "star (two)": %{(rule _alt_1 "5.1" (star diff extra))},
+ "not op": %{(rule _bad nil (_bad))}
+ }.each do |title, (sxp, expected)|
+ it title do
+ expect {EBNF::Rule.from_sxp(sxp)}.to raise_error(ArgumentError)
+ end
+ end
+ end
+ end
+
+ describe "#to_sxp" do
{
- "ebnf[1]" => [
- [:star, [:alt, :declaration, :rule]],
- %{g:star [ g:alt ( :declaration :rule ) ] .}
+ "ebnf[1]": [
+ EBNF::Rule.new(:ebnf, "1", [:star, [:alt, :declaration, :rule]]),
+ %{(rule ebnf "1" (star (alt declaration rule)))},
],
- "ebnf[2]" => [
- [:alt, "@terminals", "@pass"],
- %{g:alt ( "@terminals" "@pass" ) .}
+ "pass": [
+ EBNF::Rule.new(nil, nil, [:plus, [:range, "#x20\\t\\r\\n"]], kind: :pass),
+ %{(pass _pass (plus (range "#x20\\\\t\\\\r\\\\n")))},
],
- "ebnf[5]" => [
- :alt,
- %{g:seq ( :alt ) .}
+ "alt": [
+ EBNF::Rule.new(:alt, nil, [:alt, :a, :b, :c], kind: :rule),
+ %{(rule alt (alt a b c))},
],
- "ebnf[9]" => [
- [:seq, :primary, [:opt, [:range, "?*+"]]],
- %{g:seq ( :primary [ g:opt [ re:matches "[?*+]" ] ] ) .}
+ "diff": [
+ EBNF::Rule.new(:R_CHAR, "21", [:diff, :CHAR, "]"], kind: :terminal),
+ %{(terminal R_CHAR "21" (diff CHAR "]"))},
],
- "IRIREF" => [
- [:seq, "<", [:star, [:alt, [:range, "^#x00-#x20<>\"{}|^`\\"], :UCHAR]], ">"],
- %{g:seq ( "<" [ g:star [ g:alt ( [ re:matches "[^\\\\u0000-\\\\u0020<>\\\"{}|^`\\\\]" ] :UCHAR ) ] ] ">" ) .}
+ "istr": [
+ EBNF::Rule.new(:nc, nil, [:istr, "foo"], kind: :terminal),
+ %{(terminal nc (istr "foo"))},
+ ],
+ "not": [
+ EBNF::Rule.new(:_a_1, "n.1", [:not, :op1], kind: :rule),
+ %{(rule _a_1 "n.1" (not op1))},
+ ],
+ "opt": [
+ EBNF::Rule.new(:_diff_1, "7.1", [:opt, :_diff_2], kind: :rule),
+ %{(rule _diff_1 "7.1" (opt _diff_2))},
+ ],
+ "plus": [
+ EBNF::Rule.new(:seq, "6", [:plus, :diff], kind: :rule),
+ %{(rule seq "6" (plus diff))},
+ ],
+ "rept": [
+ EBNF::Rule.new(:rept, "6", [:rept, 1, "*", :diff]),
+ %{(rule rept "6" (rept 1 "*" diff))},
+ ],
+ "rept m.n": [
+ EBNF::Rule.new(:rept, "6", [:rept, 3, 5, :diff]),
+ %{(rule rept "6" (rept 3 5 diff))},
+ ],
+ "seq": [
+ EBNF::Rule.new(:seq, nil, [:seq, :a, :b, :c], kind: :rule),
+ %{(rule seq (seq a b c))},
+ ],
+ "star": [
+ EBNF::Rule.new(:_alt_1, "5.1", [:star, :_alt_2], kind: :rule),
+ %{(rule _alt_1 "5.1" (star _alt_2))},
]
- }.each do |title, (expr, expected)|
+ }.each do |title, (rule, sxp)|
it title do
- res = subject.send(:ttl_expr, expr, "g", 0, false)
- res.each {|r| expect(r).to be_a(String)}
+ expect(rule.to_sxp).to eq sxp
+ end
+ end
+ end
- expect(res.join("\n").gsub(/\s+/, ' ')).to produce(expected, debug)
+ describe "#to_ttl" do
+ {
+ "ebnf[1]": [
+ EBNF::Rule.new(:ebnf, "1", [:star, [:alt, :declaration, :rule]]),
+ %{
+ :ebnf rdfs:label "ebnf";
+ dc:identifier "1";
+ g:star
+ [ g:alt (
+ :declaration
+ :rule
+ ) ] .},
+ ],
+ "pass": [
+ EBNF::Rule.new(nil, nil, [:plus, [:range, "#x20\\t\\r\\n"]], kind: :pass),
+ %{
+ :_pass rdfs:label "_pass";
+ g:plus [ re:matches "[\\\\u0020\\\\t\\\\r\\\\n]" ] .},
+ ],
+ "alt": [
+ EBNF::Rule.new(:alt, nil, [:alt, :a, :b, :c], kind: :rule),
+ %{
+ :alt rdfs:label "alt";
+ g:alt ( :a :b :c ) .},
+ ],
+ "diff": [
+ EBNF::Rule.new(:R_CHAR, "21", [:diff, :CHAR, "]"], kind: :terminal),
+ %{
+ :R_CHAR rdfs:label "R_CHAR";
+ dc:identifier "21";
+ re:diff ( :CHAR "]" ) .},
+ ],
+ "istr": [
+ EBNF::Rule.new(:nc, nil, [:istr, "foo"], kind: :terminal),
+ %{
+ :nc rdfs:label "nc";
+ re:matches "foo" .},
+ ],
+ "not": [
+ EBNF::Rule.new(:_a_1, "n.1", [:not, :op1], kind: :rule),
+ %{
+ :_a_1 rdfs:label "_a_1";
+ dc:identifier "n.1";
+ g:not :op1 .},
+ ],
+ "opt": [
+ EBNF::Rule.new(:_diff_1, "7.1", [:opt, :_diff_2], kind: :rule),
+ %{
+ :_diff_1 rdfs:label "_diff_1";
+ dc:identifier "7.1";
+ g:opt :_diff_2 .},
+ ],
+ "plus": [
+ EBNF::Rule.new(:seq, "6", [:plus, :diff], kind: :rule),
+ %{
+ :seq rdfs:label "seq";
+ dc:identifier "6";
+ g:plus :diff .},
+ ],
+ "rept": [
+ EBNF::Rule.new(:rept, "6", [:rept, 1, "*", :diff]),
+ %{
+ :rept rdfs:label "rept";
+ dc:identifier "6";
+ g:min 1;
+ g:max "*";
+ g:rept :diff .},
+ ],
+ "rept m.n": [
+ EBNF::Rule.new(:rept, "6", [:rept, 3, 5, :diff]),
+ %{
+ :rept rdfs:label "rept";
+ dc:identifier "6";
+ g:min 3;
+ g:max 5;
+ g:rept :diff .},
+ ],
+ "seq": [
+ EBNF::Rule.new(:seq, nil, [:seq, :a, :b, :c], kind: :rule),
+ %{
+ :seq rdfs:label "seq";
+ g:seq ( :a :b :c ) .},
+ ],
+ "star": [
+ EBNF::Rule.new(:_alt_1, "5.1", [:star, :_alt_2], kind: :rule),
+ %{
+ :_alt_1 rdfs:label "_alt_1";
+ dc:identifier "5.1";
+ g:star :_alt_2 .},
+ ]
+ }.each do |title, (rule, ttl)|
+ it title do
+ expect(rule.to_ttl.gsub(/\s+/m, " ")).to eq ttl.gsub(/\s+/m, " ")
end
end
end
-
- describe "#cclass" do
+
+ describe "#to_ruby" do
{
- "passes normal stuff" => [
- %{^<>'{}|^`},
- %{[^<>'{}|^`]}
+ "ebnf[1]": [
+ EBNF::Rule.new(:ebnf, "1", [:star, [:alt, :declaration, :rule]]),
+ %{EBNF::Rule.new(:ebnf, "1", [:star, [:alt, :declaration, :rule]])},
],
- "turns regular hex range into unicode range" => [
- %{#x0300-#x036F},
- %{[\\u0300-\\u036F]}
+ "pass": [
+ EBNF::Rule.new(nil, nil, [:plus, [:range, "#x20\\t\\r\\n"]], kind: :pass),
+ %{EBNF::Rule.new(:_pass, nil, [:plus, [:range, \"#x20\\\\t\\\\r\\\\n\"]], kind: :pass)},
],
- "turns short hex range into unicode range" => [
- %{#xC0-#xD6},
- %{[\\u00C0-\\u00D6]}
+ "alt": [
+ EBNF::Rule.new(:alt, nil, [:alt, :a, :b, :c], kind: :rule),
+ %{EBNF::Rule.new(:alt, nil, [:alt, :a, :b, :c])},
],
- "turns 3 char hex range into unicode range" => [
- %{#x370-#x37D},
- %{[\\u0370-\\u037D]}
+ "diff": [
+ EBNF::Rule.new(:R_CHAR, "21", [:diff, :CHAR, "]"], kind: :terminal),
+ %{EBNF::Rule.new(:R_CHAR, "21", [:diff, :CHAR, "]"], kind: :terminal)},
],
- "turns long hex range into unicode range" => [
- %{#x000300-#x00036F},
- %{[\\U00000300-\\U0000036F]}
+ "not": [
+ EBNF::Rule.new(:_a_1, "n.1", [:not, :op1], kind: :rule),
+ %{EBNF::Rule.new(:_a_1, "n.1", [:not, :op1])},
],
- "turns 5 char hex range into unicode range" => [
- %{#x00370-#x0037D},
- %{[\\U00000370-\\U0000037D]}
+ "opt": [
+ EBNF::Rule.new(:_diff_1, "7.1", [:opt, :_diff_2], kind: :rule),
+ %{EBNF::Rule.new(:_diff_1, "7.1", [:opt, :_diff_2])},
],
- }.each do |title, (input, expected)|
+ "plus": [
+ EBNF::Rule.new(:seq, "6", [:plus, :diff], kind: :rule),
+ %{EBNF::Rule.new(:seq, "6", [:plus, :diff])},
+ ],
+ "rept": [
+ EBNF::Rule.new(:rept, "6", [:rept, 1, "*", :diff]),
+ %{EBNF::Rule.new(:rept, "6", [:rept, 1, "*", :diff])},
+ ],
+ "rept m.n": [
+ EBNF::Rule.new(:rept, "6", [:rept, 3, 5, :diff]),
+ %{EBNF::Rule.new(:rept, "6", [:rept, 3, 5, :diff])},
+ ],
+ "seq": [
+ EBNF::Rule.new(:seq, nil, [:seq, :a, :b, :c], kind: :rule),
+ %{EBNF::Rule.new(:seq, nil, [:seq, :a, :b, :c])},
+ ],
+ "star": [
+ EBNF::Rule.new(:_alt_1, "5.1", [:star, :_alt_2], kind: :rule),
+ %{EBNF::Rule.new(:_alt_1, "5.1", [:star, :_alt_2])},
+ ]
+ }.each do |title, (rule, ruby)|
it title do
- expect(subject.send(:cclass, input)).to produce(expected, debug)
+ expect(rule.to_ruby).to eq ruby
end
end
end
@@ -77,13 +316,13 @@
describe "#to_bnf" do
{
"no-rewrite" => [
- [:seq],
- [EBNF::Rule.new(:rule, "0", [:seq])]
+ [:seq, :foo],
+ [EBNF::Rule.new(:rule, "0", [:seq, :foo])]
],
"embedded rule" => [
- [:seq, [:alt]],
+ [:seq, [:alt, :foo]],
[EBNF::Rule.new(:rule, "0", [:seq, :_rule_1]),
- EBNF::Rule.new(:_rule_1, "0.1", [:alt])]
+ EBNF::Rule.new(:_rule_1, "0.1", [:alt, :foo])]
],
"opt rule" => [
[:opt, :foo],
@@ -106,17 +345,18 @@
EBNF::Rule.new(:_rule_1, "0.1", [:alt, :_empty, :_rule_2]),
EBNF::Rule.new(:_rule_2, "0.2", [:seq, :foo, :_rule_1])]
],
- "diff rule" => [
- [:diff, "a", "b"],
- [EBNF::Rule.new(:rule, "0", [:diff, "a", "b"], kind: :terminal)]
- ],
+ # Diff may be a Rule or a Terminal now.
+ #"diff rule" => [
+ # [:diff, "a", "b"],
+ # [EBNF::Rule.new(:rule, "0", [:diff, "a", "b"])]
+ #],
"hex rule" => [
[:hex, "#x00B7"],
[EBNF::Rule.new(:rule, "0", [:hex, "#x00B7"], kind: :terminal)]
],
"range rule" => [
- [:range, "a", "b"],
- [EBNF::Rule.new(:rule, "0", [:range, "a", "b"], kind: :terminal)]
+ [:range, "a"],
+ [EBNF::Rule.new(:rule, "0", [:range, "a"], kind: :terminal)]
],
"ebnf[1]" => [
[:star, [:alt, :declaration, :rule]],
@@ -150,18 +390,31 @@
end
end
end
+
+ context "exceptions" do
+ {
+ "diff" => [:diff, "foo", "foobar"],
+ "not" => [:not, "foo"],
+ "rept" => [:rept, 1, 2, "foo"],
+ }.each do |title, expr|
+ it title do
+ rule = EBNF::Rule.new(:rule, "0", expr)
+ expect {rule.to_bnf}.to raise_error(RuntimeError)
+ end
+ end
+ end
end
describe "#to_peg" do
{
"no-rewrite" => [
- [:seq],
- [EBNF::Rule.new(:rule, "0", [:seq])]
+ [:seq, :foo],
+ [EBNF::Rule.new(:rule, "0", [:seq, :foo])]
],
"embedded rule" => [
- [:seq, [:alt]],
+ [:seq, [:alt, :foo]],
[EBNF::Rule.new(:rule, "0", [:seq, :_rule_1]),
- EBNF::Rule.new(:_rule_1, "0.1", [:alt])]
+ EBNF::Rule.new(:_rule_1, "0.1", [:alt, :foo])]
],
"opt rule" => [
[:opt, :foo],
@@ -183,15 +436,16 @@
],
"diff rule" => [
[:diff, "a", "b"],
- [EBNF::Rule.new(:rule, "0", [:diff, "a", "b"], kind: :terminal)]
+ [EBNF::Rule.new(:rule, "0", [:seq, :_rule_1, "a"]),
+ EBNF::Rule.new(:_rule_1, "0.1", [:not, "b"])]
],
"hex rule" => [
[:hex, "#x00B7"],
[EBNF::Rule.new(:rule, "0", [:hex, "#x00B7"], kind: :terminal)]
],
"range rule" => [
- [:range, "a", "b"],
- [EBNF::Rule.new(:rule, "0", [:range, "a", "b"], kind: :terminal)]
+ [:range, "a"],
+ [EBNF::Rule.new(:rule, "0", [:range, "a"], kind: :terminal)]
],
"ebnf[1]" => [
[:star, [:alt, :declaration, :rule]],
@@ -219,8 +473,586 @@
end
it "extends with EBNF::PEG::Rule" do
- rule = EBNF::Rule.new(:rule, "0", [:seq]).to_peg.first
+ rule = EBNF::Rule.new(:rule, "0", [:seq, :foo]).to_peg.first
expect(rule).to be_a(EBNF::PEG::Rule)
end
end
+
+ describe "#to_regexp" do
+ {
+ hex: [:hex, "#x20", / /],
+ range: [:range, "a-b", /[a-b]/],
+ range2: [:range, "a-zA-Z", /[a-zA-Z]/],
+ range3: [:range, "abc-", /[abc-]/],
+ }.each do |title, (op, exp, regexp)|
+ it title do
+ expect(EBNF::Rule.new(title, nil, [op, exp]).to_regexp).to eql regexp
+ end
+ end
+
+ {
+ istr: ["foo", /foo/ui],
+ }.each do |title, (exp, regexp)|
+ it title, ruby: "!jruby" do
+ expect(EBNF::Rule.new(title, nil, [title, exp]).to_regexp).to eql regexp
+ end
+ end
+
+ it "raises an error for other operation" do
+ expect {EBNF::Rule.new(:seq, nil, [:seq, :a]).to_regexp}.to raise_error(/Can't turn/)
+ end
+ end
+
+ describe "#terminal?" do
+ {
+ "ebnf[1]": [
+ EBNF::Rule.new(:ebnf, "1", [:star, [:alt, :declaration, :rule]]),
+ false,
+ ],
+ "pass": [
+ EBNF::Rule.new(nil, nil, [:plus, [:range, "#x20\\t\\r\\n"]], kind: :pass),
+ false,
+ ],
+ "alt": [
+ EBNF::Rule.new(:alt, nil, [:alt, :a, :b, :c], kind: :rule),
+ false,
+ ],
+ "diff": [
+ EBNF::Rule.new(:R_CHAR, "21", [:diff, :CHAR, "]"], kind: :terminal),
+ true,
+ ],
+ "istr": [
+ EBNF::Rule.new(:nc, nil, [:istr, "foo"], kind: :terminal),
+ true,
+ ],
+ "not": [
+ EBNF::Rule.new(:_a_1, "n.1", [:not, :op1], kind: :rule),
+ false,
+ ],
+ "opt": [
+ EBNF::Rule.new(:_diff_1, "7.1", [:opt, :_diff_2], kind: :rule),
+ false,
+ ],
+ "plus": [
+ EBNF::Rule.new(:seq, "6", [:plus, :diff], kind: :rule),
+ false,
+ ],
+ "rept": [
+ EBNF::Rule.new(:rept, "6", [:rept, 1, "*", :diff]),
+ false,
+ ],
+ "rept m.n": [
+ EBNF::Rule.new(:rept, "6", [:rept, 3, 5, :diff]),
+ false,
+ ],
+ "seq": [
+ EBNF::Rule.new(:seq, nil, [:seq, :a, :b, :c], kind: :rule),
+ false,
+ ],
+ "star": [
+ EBNF::Rule.new(:_alt_1, "5.1", [:star, :_alt_2], kind: :rule),
+ false,
+ ]
+ }.each do |title, (rule, bool)|
+ it "#{title} => #{bool.inspect}" do
+ expect(rule.terminal?).to eq bool
+ end
+ end
+ end
+
+ describe "#pass?" do
+ {
+ "ebnf[1]": [
+ EBNF::Rule.new(:ebnf, "1", [:star, [:alt, :declaration, :rule]]),
+ false,
+ ],
+ "pass": [
+ EBNF::Rule.new(nil, nil, [:plus, [:range, "#x20\\t\\r\\n"]], kind: :pass),
+ true,
+ ],
+ "alt": [
+ EBNF::Rule.new(:alt, nil, [:alt, :a, :b, :c], kind: :rule),
+ false,
+ ],
+ "diff": [
+ EBNF::Rule.new(:R_CHAR, "21", [:diff, :CHAR, "]"], kind: :terminal),
+ false,
+ ],
+ "istr": [
+ EBNF::Rule.new(:nc, nil, [:istr, "foo"], kind: :terminal),
+ false,
+ ],
+ "not": [
+ EBNF::Rule.new(:_a_1, "n.1", [:not, :op1], kind: :rule),
+ false,
+ ],
+ "opt": [
+ EBNF::Rule.new(:_diff_1, "7.1", [:opt, :_diff_2], kind: :rule),
+ false,
+ ],
+ "plus": [
+ EBNF::Rule.new(:seq, "6", [:plus, :diff], kind: :rule),
+ false,
+ ],
+ "rept": [
+ EBNF::Rule.new(:rept, "6", [:rept, 1, "*", :diff]),
+ false,
+ ],
+ "rept m.n": [
+ EBNF::Rule.new(:rept, "6", [:rept, 3, 5, :diff]),
+ false,
+ ],
+ "seq": [
+ EBNF::Rule.new(:seq, nil, [:seq, :a, :b, :c], kind: :rule),
+ false,
+ ],
+ "star": [
+ EBNF::Rule.new(:_alt_1, "5.1", [:star, :_alt_2], kind: :rule),
+ false,
+ ]
+ }.each do |title, (rule, bool)|
+ it "#{title} => #{bool.inspect}" do
+ expect(rule.pass?).to eq bool
+ end
+ end
+ end
+
+ describe "#rule?" do
+ {
+ "ebnf[1]": [
+ EBNF::Rule.new(:ebnf, "1", [:star, [:alt, :declaration, :rule]]),
+ true,
+ ],
+ "pass": [
+ EBNF::Rule.new(nil, nil, [:plus, [:range, "#x20\\t\\r\\n"]], kind: :pass),
+ false,
+ ],
+ "alt": [
+ EBNF::Rule.new(:alt, nil, [:alt, :a, :b, :c], kind: :rule),
+ true,
+ ],
+ "diff": [
+ EBNF::Rule.new(:R_CHAR, "21", [:diff, :CHAR, "]"], kind: :terminal),
+ false,
+ ],
+ "istr": [
+ EBNF::Rule.new(:nc, nil, [:istr, "foo"], kind: :terminal),
+ false,
+ ],
+ "not": [
+ EBNF::Rule.new(:_a_1, "n.1", [:not, :op1], kind: :rule),
+ true,
+ ],
+ "opt": [
+ EBNF::Rule.new(:_diff_1, "7.1", [:opt, :_diff_2], kind: :rule),
+ true,
+ ],
+ "plus": [
+ EBNF::Rule.new(:seq, "6", [:plus, :diff], kind: :rule),
+ true,
+ ],
+ "rept": [
+ EBNF::Rule.new(:rept, "6", [:rept, 1, "*", :diff]),
+ true,
+ ],
+ "rept m.n": [
+ EBNF::Rule.new(:rept, "6", [:rept, 3, 5, :diff]),
+ true,
+ ],
+ "seq": [
+ EBNF::Rule.new(:seq, nil, [:seq, :a, :b, :c], kind: :rule),
+ true,
+ ],
+ "star": [
+ EBNF::Rule.new(:_alt_1, "5.1", [:star, :_alt_2], kind: :rule),
+ true,
+ ]
+ }.each do |title, (rule, bool)|
+ it "#{title} => #{bool.inspect}" do
+ expect(rule.rule?).to eq bool
+ end
+ end
+ end
+
+ describe "#alt?" do
+ {
+ "ebnf[1]": [
+ EBNF::Rule.new(:ebnf, "1", [:star, [:alt, :declaration, :rule]]),
+ false,
+ ],
+ "pass": [
+ EBNF::Rule.new(nil, nil, [:plus, [:range, "#x20\\t\\r\\n"]], kind: :pass),
+ false,
+ ],
+ "alt": [
+ EBNF::Rule.new(:alt, nil, [:alt, :a, :b, :c], kind: :rule),
+ true,
+ ],
+ "diff": [
+ EBNF::Rule.new(:R_CHAR, "21", [:diff, :CHAR, "]"], kind: :terminal),
+ false,
+ ],
+ "istr": [
+ EBNF::Rule.new(:nc, nil, [:istr, "foo"], kind: :terminal),
+ false,
+ ],
+ "not": [
+ EBNF::Rule.new(:_a_1, "n.1", [:not, :op1], kind: :rule),
+ false,
+ ],
+ "opt": [
+ EBNF::Rule.new(:_diff_1, "7.1", [:opt, :_diff_2], kind: :rule),
+ false,
+ ],
+ "plus": [
+ EBNF::Rule.new(:seq, "6", [:plus, :diff], kind: :rule),
+ false,
+ ],
+ "rept": [
+ EBNF::Rule.new(:rept, "6", [:rept, 1, "*", :diff]),
+ false,
+ ],
+ "rept m.n": [
+ EBNF::Rule.new(:rept, "6", [:rept, 3, 5, :diff]),
+ false,
+ ],
+ "seq": [
+ EBNF::Rule.new(:seq, nil, [:seq, :a, :b, :c], kind: :rule),
+ false,
+ ],
+ "star": [
+ EBNF::Rule.new(:_alt_1, "5.1", [:star, :_alt_2], kind: :rule),
+ false,
+ ]
+ }.each do |title, (rule, bool)|
+ it "#{title} => #{bool.inspect}" do
+ expect(rule.alt?).to eq bool
+ end
+ end
+ end
+
+ describe "#seq?" do
+ {
+ "ebnf[1]": [
+ EBNF::Rule.new(:ebnf, "1", [:star, [:alt, :declaration, :rule]]),
+ false,
+ ],
+ "pass": [
+ EBNF::Rule.new(nil, nil, [:plus, [:range, "#x20\\t\\r\\n"]], kind: :pass),
+ false,
+ ],
+ "alt": [
+ EBNF::Rule.new(:alt, nil, [:alt, :a, :b, :c], kind: :rule),
+ false,
+ ],
+ "diff": [
+ EBNF::Rule.new(:R_CHAR, "21", [:diff, :CHAR, "]"], kind: :terminal),
+ false,
+ ],
+ "istr": [
+ EBNF::Rule.new(:nc, nil, [:istr, "foo"], kind: :terminal),
+ false,
+ ],
+ "not": [
+ EBNF::Rule.new(:_a_1, "n.1", [:not, :op1], kind: :rule),
+ false,
+ ],
+ "opt": [
+ EBNF::Rule.new(:_diff_1, "7.1", [:opt, :_diff_2], kind: :rule),
+ false,
+ ],
+ "plus": [
+ EBNF::Rule.new(:seq, "6", [:plus, :diff], kind: :rule),
+ false,
+ ],
+ "rept": [
+ EBNF::Rule.new(:rept, "6", [:rept, 1, "*", :diff]),
+ false,
+ ],
+ "rept m.n": [
+ EBNF::Rule.new(:rept, "6", [:rept, 3, 5, :diff]),
+ false,
+ ],
+ "seq": [
+ EBNF::Rule.new(:seq, nil, [:seq, :a, :b, :c], kind: :rule),
+ true,
+ ],
+ "star": [
+ EBNF::Rule.new(:_alt_1, "5.1", [:star, :_alt_2], kind: :rule),
+ false,
+ ]
+ }.each do |title, (rule, bool)|
+ it "#{title} => #{bool.inspect}" do
+ expect(rule.seq?).to eq bool
+ end
+ end
+ end
+
+ describe "#==" do
+ let(:rule1) {EBNF::Rule.new(:foo, nil, [:seq, "FOO"])}
+ let(:rule2) {EBNF::Rule.new(:foo, nil, [:seq, "FOO"])}
+ let(:rule3) {EBNF::Rule.new(:bar, nil, [:seq, "FOO"])}
+
+ it "equals itself" do
+ expect(rule1).to eq(rule1)
+ end
+ it "equals an equivalent rule" do
+ expect(rule1).to eq(rule2)
+ end
+ it "does not equal a rule with a different symbol that has the same expression" do
+ expect(rule1).not_to eq(rule3)
+ end
+ end
+
+ describe "#eql?" do
+ let(:rule1) {EBNF::Rule.new(:foo, nil, [:seq, "FOO"])}
+ let(:rule2) {EBNF::Rule.new(:foo, nil, [:seq, "FOO"])}
+ let(:rule3) {EBNF::Rule.new(:bar, nil, [:seq, "FOO"])}
+
+ it "equals itself" do
+ expect(rule1).to eql(rule1)
+ end
+ it "equals an equivalent rule" do
+ expect(rule1).to eql(rule2)
+ end
+ it "equals a rule with a different symbol that has the same expression" do
+ expect(rule1).to eql(rule3)
+ end
+ end
+
+ describe "#translate_codepoints" do
+ {
+ "#x20" => " ",
+ "#xffff" => "\u{ffff}"
+ }.each do |str, cp|
+ specify {expect(subject.translate_codepoints(str)).to eql(cp)}
+ end
+ end
+
+ describe "#non_terminals" do
+ subject {ebnf}
+ {
+ _pass: [],
+ ebnf: [:declaration, :rule],
+ declaration: [:pass],
+ alt: [:seq],
+ seq: [:diff],
+ diff: [:postfix],
+ postfix: [:primary],
+ primary: [],
+ pass: [],
+ LHS: [],
+ SYMBOL: [],
+ HEX: [],
+ RANGE: [],
+ O_RANGE: [],
+ STRING1: [],
+ STRING2: [],
+ CHAR: [],
+ R_CHAR: [],
+ POSTFIX: [],
+ PASS: []
+ }.each do |sym, expected|
+ it "#{sym} => #{expected.inspect}" do
+ res = subject.ast.find {|r| r.sym == sym}
+ expect(res.non_terminals(subject.ast).map(&:sym)).to eq expected
+ end
+ end
+ end
+
+ describe "#terminals" do
+ subject {ebnf}
+ {
+ _pass: [:PASS],
+ ebnf: [],
+ declaration: ["@terminals"],
+ alt: [],
+ seq: [],
+ diff: [],
+ postfix: [],
+ primary: [:HEX, :SYMBOL, :O_RANGE, :RANGE, :STRING1, :STRING2, "("],
+ pass: ["@pass"],
+ LHS: ["["],
+ SYMBOL: ["a-z", "A-Z", "0-9", "_", "."],
+ HEX: ["#x"],
+ RANGE: ["["],
+ O_RANGE: ["[^"],
+ STRING1: ['"'],
+ STRING2: ["'"],
+ CHAR: ["#x9#xA#xD", "#x20-#xD7FF", "#xE000-#xFFFD", "#x10000-#x10FFFF"],
+ R_CHAR: [:CHAR, "]", "-", :HEX],
+ POSTFIX: ["?*+"],
+ PASS: ["#x9#xA#xD#x20", "#", "#x", "//", "/*", "(*"]
+ }.each do |sym, expected|
+ it "#{sym} => #{expected.inspect}" do
+ res = subject.ast.find {|r| r.sym == sym}
+ expect(res.terminals(subject.ast).map {|r| r.is_a?(EBNF::Rule) ? r.sym : r}).to eq expected
+ end
+ end
+ end
+
+ describe "#symbols" do
+ subject {ebnf}
+ {
+ _pass: [:PASS],
+ ebnf: [:declaration, :rule],
+ declaration: [:pass],
+ alt: [:seq],
+ seq: [:diff],
+ diff: [:postfix],
+ postfix: [:primary, :POSTFIX],
+ primary: [:HEX, :SYMBOL, :O_RANGE, :RANGE, :STRING1, :STRING2, :expression],
+ pass: [:expression],
+ LHS: [:SYMBOL],
+ SYMBOL: [],
+ HEX: [],
+ RANGE: [:R_CHAR, :HEX, :LHS],
+ O_RANGE: [:R_CHAR, :HEX],
+ STRING1: [:CHAR],
+ STRING2: [:CHAR],
+ CHAR: [],
+ R_CHAR: [:CHAR, :HEX],
+ POSTFIX: [],
+ PASS: []
+ }.each do |sym, expected|
+ it "#{sym} => #{expected.inspect}" do
+ res = subject.ast.find {|r| r.sym == sym}
+ expect(res.symbols).to eq expected
+ end
+ end
+ end
+
+ describe "#validate!" do
+ let(:gram) {EBNF.parse("a ::= 'b'?")}
+ subject {gram.ast.first}
+
+ {
+ "mixed enum char and hex": [
+ "a ::= [b#x20]",
+ %(In rule a: Range must be of form HEX+ or R_CHAR+: was "b#x20")
+ ],
+ "mixed enum char and hex (2)": [
+ "a ::= [#x20z]",
+ %(In rule a: Range must be of form HEX+ or R_CHAR+: was "#x20z")
+ ],
+ }.each do |name, (rule, message)|
+ it name do
+ expect(EBNF.parse(rule)).to be_valid
+ end
+ end
+
+ {
+ "missing rule": [
+ "a ::= b",
+ /In rule a: No rule found for b/
+ ],
+ "illegal string": [
+ %{a ::= "\u{01}"},
+ /syntax error/
+ ],
+ "empty range": [
+ "a ::= []",
+ /syntax error/
+ ],
+ "mixed range char and hex": [
+ "a ::= [b-#x20]",
+ /Range contains illegal components/
+ ],
+ "mixed range char and hex (2)": [
+ "a ::= [#x20-b]",
+ /Range contains illegal components/
+ ],
+ "incomplete range": [
+ "a ::= [-b]",
+ /syntax error,/
+ ],
+ "extra range": [
+ "a ::= [a-b-c]",
+ /syntax error,/
+ ],
+ }.each do |name, (rule, message)|
+ it name do
+ expect {EBNF.parse(rule, validate: true)}.to raise_error SyntaxError, message
+ end
+ end
+
+ # Validate rules that can only be created through modification
+ {
+ "alt (empty)": [:alt],
+ "diff (empty)": [:diff],
+ "diff (one)": [:diff, 'A'],
+ "diff (three)": [:diff, 'A', 'B', 'C'],
+ "hex (empty)": [:hex],
+ "hex (two)": [:hex, '#x01', '#x02'],
+ "hex (string)": [:hex, 'string'],
+ "istr (empty)": [:istr],
+ "istr (two)": [:istr, 'A', 'B'],
+ "not (empty)": [:not],
+ "not (two)": [:not, 'A', 'B'],
+ "opt (empty)": [:opt],
+ "plus (empty)": [:plus],
+ "plus (two)": [:plus, 'A', 'B'],
+ "rept (empty)": [:rept],
+ "rept (one)": [:rept, 1],
+ "rept (two)": [:rept, 1, 2],
+ "rept (four)": [:rept, 1, 2, 'A', 'B'],
+ "rept (float min)": [:rept, 1.1, 2, 'A'],
+ "rept (negative min)": [:rept, -1, 2, 'A'],
+ "rept (float max)": [:rept, 1, 2.1, 'A'],
+ "rept (negative max)": [:rept, 1, -1, 'A'],
+ "star (empty)": [:star],
+ "star (two)": [:star, 'A', 'B'],
+ "not op": [:bad]
+ }.each do |title, expr|
+ it title do
+ subject.expr = expr
+ expect {subject.validate!(gram.ast)}.to raise_error(SyntaxError)
+ end
+ end
+ end
+
+ describe "#valid?" do
+ subject {EBNF.parse("a ::= b")}
+ it "notes missing rule" do
+ expect(subject.ast.first.valid?(subject.ast)).to be_falsey
+ end
+
+ it "validates EBNF" do
+ ebnf = EBNF.parse(File.open(File.expand_path("../../etc/ebnf.ebnf", __FILE__)))
+ expect(ebnf.ast.first).to be_valid(ebnf.ast)
+ end
+ end
+
+ describe "#cclass" do
+ {
+ "passes normal stuff" => [
+ %{^<>'{}|^`},
+ %{[^<>'{}|^`]}
+ ],
+ "turns regular hex range into unicode range" => [
+ %{#x0300-#x036F},
+ %{[\\u0300-\\u036F]}
+ ],
+ "turns short hex range into unicode range" => [
+ %{#xC0-#xD6},
+ %{[\\u00C0-\\u00D6]}
+ ],
+ "turns 3 char hex range into unicode range" => [
+ %{#x370-#x37D},
+ %{[\\u0370-\\u037D]}
+ ],
+ "turns long hex range into unicode range" => [
+ %{#x000300-#x00036F},
+ %{[\\U00000300-\\U0000036F]}
+ ],
+ "turns 5 char hex range into unicode range" => [
+ %{#x00370-#x0037D},
+ %{[\\U00000370-\\U0000037D]}
+ ],
+ }.each do |title, (input, expected)|
+ it title do
+ expect(subject.send(:cclass, input)).to produce(expected, debug)
+ end
+ end
+ end
end
\ No newline at end of file
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index 2a2b309..10837a5 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -24,8 +24,18 @@
::RSpec.configure do |c|
c.filter_run focus: true
c.run_all_when_everything_filtered = true
- c.exclusion_filter = {
- ruby: lambda { |version| !(RUBY_VERSION.to_s =~ /^#{version.to_s}/) },
- not_jruby: lambda { RUBY_PLATFORM.to_s != 'jruby'}
- }
+ c.filter_run_excluding ruby: ->(version) do
+ case version.to_s
+ when "!jruby"
+ RUBY_ENGINE == "jruby"
+ when /^> (.*)/
+ !(RUBY_VERSION.to_s > $1)
+ else
+ !(RUBY_VERSION.to_s =~ /^#{version.to_s}/)
+ end
+ end
end
+
+require 'ebnf'
+
+PARSED_EBNF_GRAMMAR = EBNF.parse(File.open(File.expand_path("../../etc/ebnf.ebnf", __FILE__))).freeze
\ No newline at end of file
diff --git a/spec/writer_spec.rb b/spec/writer_spec.rb
index 9b6e82f..c14a230 100644
--- a/spec/writer_spec.rb
+++ b/spec/writer_spec.rb
@@ -3,9 +3,43 @@
require 'spec_helper'
require 'ebnf'
require 'sxp'
+require 'nokogiri'
describe EBNF::Writer do
- describe "#initialize" do
+ RSpec::Matchers.define :have_xpath do |path, value|
+ match do |actual|
+ doc = Nokogiri::HTML.parse(actual)
+ return false unless doc
+ @result = doc.at_xpath(path.to_s) rescue false
+ case value
+ when false
+ @result.nil?
+ when true
+ !@result.nil?
+ when Array
+ @result.to_s.split(" ").include?(*value)
+ when Regexp
+ @result.to_s =~ value
+ else
+ @result.to_s == value
+ end
+ end
+
+ failure_message do |actual|
+ msg = "expected that #{path.inspect}\nwould be: #{value.inspect}"
+ msg += "\n was: #{@result}"
+ msg += "\nsource:" + actual
+ msg
+ end
+
+ failure_message_when_negated do |actual|
+ msg = "expected that #{path.inspect}\nwould not be #{value.inspect}"
+ msg += "\nsource:" + actual
+ msg
+ end
+ end
+
+ describe ".string" do
{
prolog: [
%{[2] Prolog ::= BaseDecl? PrefixDecl*},
@@ -22,17 +56,522 @@
end
end
- context "Existing grammars" do
+ describe ".print" do
{
- "EBNF Grammar" => File.expand_path("../../etc/ebnf.ebnf", __FILE__),
- "Turtle Grammar" => File.expand_path("../../etc/turtle.ebnf", __FILE__)
- }.each do |name, file|
- context name do
- it "outputs grammar as text" do
- expect {EBNF.parse(File.read(file)).to_s}.to_not raise_error
- end
- it "outputs grammar as html" do
- expect {EBNF.parse(File.read(file)).to_html}.to_not raise_error
+ prolog: [
+ %{[2] Prolog ::= BaseDecl? PrefixDecl*},
+ %{[2] Prolog ::= BaseDecl? PrefixDecl*\n}
+ ],
+ }.each do |title, (grammar, plain)|
+ context title do
+ subject {EBNF::Base.new(grammar).ast}
+
+ it "generates plain" do
+ expect {EBNF::Writer.print(*subject)}.to write(plain).to(:output)
+ end
+ end
+ end
+ end
+
+ describe ".html" do
+ {
+ prolog: [
+ %{[2] Prolog ::= BaseDecl? PrefixDecl*},
+ {
+ '//table/@class': "grammar",
+ '//table/tbody/@id': "grammar-productions",
+ '//tbody/tr/@id': "grammar-production-Prolog",
+ '//tbody/tr/td[1]/text()': "[2]",
+ '//tbody/tr/td[2]/code/text()': "Prolog",
+ '//tbody/tr/td[3]/text()': "::=",
+ #'//tbody/tr/td[4]/*/text()': /BaseDecl\? PrefixDecl\*/,
+ }
+ ],
+ }.each do |title, (grammar, xpaths)|
+ context title do
+ subject {EBNF::Writer.html(*EBNF::Base.new(grammar).ast)}
+ xpaths.each do |path, value|
+ specify {is_expected.to have_xpath(path, value)}
+ end
+ end
+ end
+ end
+
+ context "EBNF" do
+ describe "#initialize" do
+ {
+ prolog: [
+ %{[2] Prolog ::= BaseDecl? PrefixDecl*},
+ %{[2] Prolog ::= BaseDecl? PrefixDecl*\n}
+ ],
+ }.each do |title, (grammar, plain)|
+ context title do
+ subject {EBNF::Base.new(grammar).ast}
+
+ it "generates plain" do
+ expect {EBNF::Writer.new(subject)}.to write(plain).to(:output)
+ end
+ end
+ end
+ end
+
+ describe "#format_ebnf" do
+ subject {EBNF::Writer.new([])}
+
+ context "legal expressions" do
+ {
+ "alt": [
+ [:alt, :A, :B],
+ "A | B"
+ ],
+ "diff": [
+ [:diff, :A, :B],
+ "A - B"
+ ],
+ "hex": [
+ [:hex, "#x20"],
+ "#x20"
+ ],
+ "istr": [
+ [:istr, "foo"],
+ %("foo")
+ ],
+ "opt": [
+ [:opt, :A],
+ "A?"
+ ],
+ "plus": [
+ [:plus, :A],
+ "A+"
+ ],
+ "range": [
+ [:range, "a-zA-Z"],
+ "[a-zA-Z]"
+ ],
+ "rept 0 1": [
+ [:rept, 0, 1, :A],
+ "A?"
+ ],
+ "rept 0 *": [
+ [:rept, 0, '*', :A],
+ "A*"
+ ],
+ "rept 1 1": [
+ [:rept, 1, 1, :A],
+ "A"
+ ],
+ "rept 1 *": [
+ [:rept, 1, '*', :A],
+ "A+"
+ ],
+ "rept 1 2": [
+ [:rept, 1, 2, :A],
+ "A A?"
+ ],
+ "rept 1 3": [
+ [:rept, 1, 3, :A],
+ "A (A A?)?"
+ ],
+ "rept 2 *": [
+ [:rept, 2, "*", :A],
+ "A A A*"
+ ],
+ "rept 1 3 (A B)": [
+ [:rept, 1, 3, [:seq, :A, :B]],
+ "(A B) ((A B) (A B)?)?"
+ ],
+ "rept 1 3 (A | B)": [
+ [:rept, 1, 3, [:alt, :A, :B]],
+ "(A | B) ((A | B) (A | B)?)?"
+ ],
+ "star": [
+ [:star, :A],
+ "A*"
+ ],
+ "string '\\r'": [
+ [:seq, "\r"],
+ %{#x0D}
+ ],
+ "string ' '": [
+ [:seq, " "],
+ %{#x20}
+ ],
+ "string 'a'": [
+ [:seq, "a"],
+ %{"a"}
+ ],
+ "string '\"'": [
+ [:seq, '"'],
+ %{'"'}
+ ],
+ "string \"'\"": [
+ [:seq, '\''],
+ %{"'"}
+ ],
+ "string \"\€\"": [
+ [:seq, '€'],
+ %{"€"}
+ ],
+ "n3 path": [
+ [:seq, :pathItem, [:alt, [:seq, "!", :path], [:seq, "^", :path]]],
+ %{pathItem (("!" path) | ("^" path))}
+ ],
+ }.each do |title, (expr, result)|
+ it title do
+ expect(subject.send(:format_ebnf, expr)).to eql result
+ end
+ end
+ end
+
+ context "illegal expressions" do
+ {
+ "string 'a\nb": [:seq, "a\nb"],
+ }.each do |title, expr|
+ it title do
+ expect {subject.send(:format_ebnf, expr)}.to raise_error RangeError
+ end
+ end
+ end
+ end
+
+ context "Existing grammars" do
+ {
+ "ABNF Grammar" => File.expand_path("../../etc/abnf.ebnf", __FILE__),
+ "EBNF Grammar" => File.expand_path("../../etc/ebnf.ebnf", __FILE__),
+ "ISO EBNF Grammar" => File.expand_path("../../etc/iso-ebnf.ebnf", __FILE__),
+ "Turtle Grammar" => File.expand_path("../../etc/turtle.ebnf", __FILE__),
+ "SPARQL Grammar" => File.expand_path("../../etc/sparql.ebnf", __FILE__),
+ }.each do |name, file|
+ context name do
+ it "outputs grammar as text" do
+ expect {EBNF.parse(File.read(file)).to_s}.to_not raise_error
+ end
+ it "parses to equivalent rules" do
+ expect(EBNF.parse(File.read(file)).to_sxp).to produce(File.read(file.sub('.ebnf', '.sxp')))
+ end
+ it "outputs grammar as html" do
+ expect {EBNF.parse(File.read(file)).to_html}.to_not raise_error
+ end
+ end
+ end
+ end
+ end
+
+ context "ABNF" do
+ describe "#initialize" do
+ {
+ prolog: [
+ %{rulelist = 1*( rule / (*c-wsp c-nl) )\n},
+ %{rulelist = 1*(rule / (*c-wsp c-nl))\n}
+ ],
+ }.each do |title, (grammar, plain)|
+ context title do
+ subject {EBNF::Base.new(grammar, format: :abnf).ast}
+
+ it "generates plain" do
+ expect {EBNF::Writer.new(subject, format: :abnf)}.to write(plain).to(:output)
+ end
+ end
+ end
+ end
+
+ describe "#format_abnf" do
+ subject {EBNF::Writer.new([])}
+
+ context "legal expressions" do
+ {
+ "alt": [
+ [:alt, :A, :B],
+ "A / B"
+ ],
+ "enum": [
+ [:range, "abc-"],
+ "%d97.98.99.45"
+ ],
+ "hex": [
+ [:hex, "#x20"],
+ "%x20"
+ ],
+ "istr": [
+ [:istr, "foo"],
+ %("foo")
+ ],
+ "opt": [
+ [:opt, :A],
+ "[A]"
+ ],
+ "plus": [
+ [:plus, :A],
+ "1*A"
+ ],
+ "range": [
+ [:range, "a-z"],
+ "%d97-122"
+ ],
+ "range 2": [
+ [:range, "a-zA-Z"],
+ %{(%d97-122 / %d65-90)}
+ ],
+ "rept 0 1": [
+ [:rept, 0, 1, :A],
+ "0*1A"
+ ],
+ "rept 0 *": [
+ [:rept, 0, '*', :A],
+ "*A"
+ ],
+ "rept 1 1": [
+ [:rept, 1, 1, :A],
+ "1A"
+ ],
+ "rept 1 *": [
+ [:rept, 1, '*', :A],
+ "1*A"
+ ],
+ "rept 1 2": [
+ [:rept, 1, 2, :A],
+ "1*2A"
+ ],
+ "rept 1 3": [
+ [:rept, 1, 3, :A],
+ "1*3A"
+ ],
+ "rept 2 *": [
+ [:rept, 2, "*", :A],
+ "2*A"
+ ],
+ "rept 1 3 (A B)": [
+ [:rept, 1, 3, [:seq, :A, :B]],
+ "1*3(A B)"
+ ],
+ "rept 1 3 (A | B)": [
+ [:rept, 1, 3, [:alt, :A, :B]],
+ "1*3(A / B)"
+ ],
+ "star": [
+ [:star, :A],
+ "*A"
+ ],
+ "string '\\r'": [
+ [:seq, "\r"],
+ %{%x0D}
+ ],
+ "string ' '": [
+ [:seq, " "],
+ %{" "}
+ ],
+ "string 'a'": [
+ [:seq, "a"],
+ %{"a"}
+ ],
+ "string '\"'": [
+ [:seq, '"'],
+ %{%x22}
+ ],
+ "string \"'\"": [
+ [:seq, '\''],
+ %{"'"}
+ ],
+ "string \"\€\"": [
+ [:seq, '€'],
+ %{%x20AC}
+ ],
+ "n3 path": [
+ [:seq, :pathItem, [:alt, [:seq, "!", :path], [:seq, "^", :path]]],
+ %{pathItem (("!" path) / ("^" path))}
+ ],
+ }.each do |title, (expr, result)|
+ it title do
+ expect(subject.send(:format_abnf, expr)).to eql result
+ end
+ end
+ end
+
+ context "illegal expressions" do
+ {
+ "[^abc]": [:range, "^abc"],
+ "A - B": [:diff, :A, :B],
+ }.each do |title, expr|
+ it title do
+ expect {subject.send(:format_abnf, expr)}.to raise_error RangeError
+ end
+ end
+ end
+ end
+
+ context "Existing grammars" do
+ {
+ "ABNF Grammar" => File.expand_path("../../etc/abnf.abnf", __FILE__),
+ "HTTP Grammar" => File.expand_path("../../examples/abnf/examples/http.abnf", __FILE__),
+ "JSON Grammar" => File.expand_path("../../examples/abnf/examples/json.abnf", __FILE__),
+ "Postal Address" => File.expand_path("../../examples/abnf/examples/postal-address.abnf", __FILE__),
+ "URI Grammar" => File.expand_path("../../examples/abnf/examples/uri.abnf", __FILE__),
+ }.each do |name, file|
+ context name do
+ it "outputs grammar as text" do
+ expect {EBNF.parse(File.read(file), format: :abnf).to_s(format: :abnf)}.to_not raise_error
+ end
+ it "outputs grammar as html" do
+ expect {EBNF.parse(File.read(file), format: :abnf).to_html(format: :abnf)}.to_not raise_error
+ end
+ end
+ end
+ end
+ end
+
+ context "ISOEBNF" do
+ describe "#initialize" do
+ {
+ prolog: [
+ %{syntax = syntax_rule, {syntax_rule} ;},
+ %{syntax = syntax_rule, {syntax_rule} ;\n}
+ ],
+ }.each do |title, (grammar, plain)|
+ context title do
+ subject {EBNF::Base.new(grammar, format: :isoebnf).ast}
+
+ it "generates plain" do
+ expect {EBNF::Writer.new(subject, format: :isoebnf)}.to write(plain).to(:output)
+ end
+ end
+ end
+ end
+
+ describe "#format_isoebnf" do
+ subject {EBNF::Writer.new([])}
+
+ context "legal expressions" do
+ {
+ "alt": [
+ [:alt, :A, :B],
+ "A | B"
+ ],
+ "diff": [
+ [:diff, :A, :B],
+ "A - B"
+ ],
+ "enum": [
+ [:range, "abc-"],
+ %{("a" | "b" | "c" | "-")}
+ ],
+ "hex": [
+ [:hex, "#x20"],
+ %(" ")
+ ],
+ "istr": [
+ [:istr, "foo"],
+ %("foo")
+ ],
+ "opt": [
+ [:opt, :A],
+ "[A]"
+ ],
+ "plus": [
+ [:plus, :A],
+ "A, {A}"
+ ],
+ "range": [
+ [:range, "a-z"],
+ %{("a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z")}
+ ],
+ "range 2": [
+ [:range, "a-zA-Z"],
+ %{("a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" | "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z")}],
+ "rept 0 1": [
+ [:rept, 0, 1, :A],
+ "[A]"
+ ],
+ "rept 0 *": [
+ [:rept, 0, '*', :A],
+ "{A}"
+ ],
+ "rept 1 1": [
+ [:rept, 1, 1, :A],
+ "A"
+ ],
+ "rept 1 *": [
+ [:rept, 1, '*', :A],
+ "A, {A}"
+ ],
+ "rept 1 2": [
+ [:rept, 1, 2, :A],
+ "A, [A]"
+ ],
+ "rept 1 3": [
+ [:rept, 1, 3, :A],
+ "A, [(A, [A])]"
+ ],
+ "rept 2 *": [
+ [:rept, 2, "*", :A],
+ "A, A, {A}"
+ ],
+ "rept 1 3 (A B)": [
+ [:rept, 1, 3, [:seq, :A, :B]],
+ "(A, B), [((A, B), [(A, B)])]"
+ ],
+ "rept 1 3 (A | B)": [
+ [:rept, 1, 3, [:alt, :A, :B]],
+ "(A | B), [((A | B), [(A | B)])]"
+ ],
+ "star": [
+ [:star, :A],
+ "{A}"
+ ],
+ "string ' '": [
+ [:seq, " "],
+ %{" "}
+ ],
+ "string 'a'": [
+ [:seq, "a"],
+ %{"a"}
+ ],
+ "string '\"'": [
+ [:seq, '"'],
+ %{'"'}
+ ],
+ "string \"'\"": [
+ [:seq, '\''],
+ %{"'"}
+ ],
+ "n3 path": [
+ [:seq, :pathItem, [:alt, [:seq, "!", :path], [:seq, "^", :path]]],
+ %{pathItem, (("!", path) | ("^", path))}
+ ],
+ }.each do |title, (expr, result)|
+ it title do
+ expect(subject.send(:format_isoebnf, expr)).to eql result
+ end
+ end
+ end
+
+ context "illegal expressions" do
+ {
+ "[^abc]": [:range, "^abc"],
+ "string '\\r'": [:seq, "\r"],
+ "string \"\€\"": [:seq, '€'],
+ }.each do |title, expr|
+ it title do
+ expect {subject.send(:format_isoebnf, expr)}.to raise_error RangeError
+ end
+ end
+ end
+ end
+
+ context "Existing grammars" do
+ {
+ "ISO EBNF Grammar" => File.expand_path("../../etc/iso-ebnf.isoebnf", __FILE__),
+ "Simiple EBNF Grammar" => File.expand_path("../../examples/isoebnf/examples/ebnf.isoebnf", __FILE__),
+ "HTML Grammar" => File.expand_path("../../examples/isoebnf/examples/html.isoebnf", __FILE__),
+ "Pascal Grammar" => File.expand_path("../../examples/isoebnf/examples/pascal.isoebnf", __FILE__),
+ "Postal Address" => File.expand_path("../../examples/isoebnf/examples/postal-address.isoebnf", __FILE__),
+ }.each do |name, file|
+ context name do
+ it "outputs grammar as text" do
+ expect {EBNF.parse(File.read(file), format: :isoebnf).to_s(format: :isoebnf)}.to_not raise_error
+ end
+ it "outputs grammar as html" do
+ expect {EBNF.parse(File.read(file), format: :isoebnf).to_html(format: :isoebnf)}.to_not raise_error
+ end
end
end
end
|