abnf-parser 0.8.1 → 0.9.0

data/lib/abnf/parser/controls/compiler/tokens.rb

@@ -0,0 +1,97 @@
+module ABNF
+  module Parser
+    module Controls
+      module Compiler
+        module Tokens
+          extend self
+
+          def alternation_slash
+            Parser::Compiler::Token.new 'alternation-SLASH', ' / '
+          end
+
+          def bin_val_range
+            Parser::Compiler::Token.new 'bin-val-RANGE', '%b100000-100001'
+          end
+
+          def bin_val_sequence
+            Parser::Compiler::Token.new 'bin-val-SEQUENCE', '%b1100110.1101111.1101111'
+          end
+
+          def c_nl comment=nil
+            abnf = "#{comment}\r\n"
+            Parser::Compiler::Token.new 'c-nl', abnf
+          end
+
+          def c_wsp abnf=nil
+            abnf ||= ' '
+            Parser::Compiler::Token.new 'c-wsp', abnf
+          end
+
+          def char_val string=nil
+            string ||= 'foo'
+            Parser::Compiler::Token.new 'char-val', string.inspect
+          end
+
+          def dec_val_range
+            Parser::Compiler::Token.new 'dec-val-RANGE', '%d32-33'
+          end
+
+          def dec_val_sequence
+            Parser::Compiler::Token.new 'dec-val-SEQUENCE', '%d102.111.111'
+          end
+
+          def defined_as operator=nil
+            operator ||= '='
+            Parser::Compiler::Token.new 'defined-as', operator
+          end
+
+          def group_start
+            Parser::Compiler::Token.new 'group-START', '( '
+          end
+
+          def group_stop
+            Parser::Compiler::Token.new 'group-STOP', ' )'
+          end
+
+          def hex_val_range
+            Parser::Compiler::Token.new 'hex-val-RANGE', '%x20-21'
+          end
+
+          def hex_val_sequence sequence=nil
+            sequence ||= ABNF.foo
+            Parser::Compiler::Token.new 'hex-val-SEQUENCE', sequence
+          end
+          alias_method :example, :hex_val_sequence
+          alias_method :foo, :hex_val_sequence
+          alias_method :num_val, :hex_val_sequence
+          alias_method :terminal, :hex_val_sequence
+
+          def option_start
+            Parser::Compiler::Token.new 'option-START', '[ '
+          end
+
+          def option_stop
+            Parser::Compiler::Token.new 'option-STOP', ' ]'
+          end
+
+          def prose_val
+            Parser::Compiler::Token.new 'prose-val', '<Some Prose>'
+          end
+
+          def repeat_exact
+            Parser::Compiler::Token.new 'repeat-EXACT', '1'
+          end
+
+          def repeat_range abnf=nil
+            abnf ||= '*'
+            Parser::Compiler::Token.new 'repeat-RANGE', abnf
+          end
+
+          def rulename
+            Parser::Compiler::Token.new 'rulename', 'some-rule'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/abnf/parser/controls/nodes.rb

@@ -0,0 +1,113 @@
+module ABNF
+  module Parser
+    module Controls
+      module Nodes
+        extend self
+
+        def alternation
+          Node.alternation(
+            Node.terminal('foo', ABNF.foo),
+            ABNF.alternation,
+          )
+        end
+
+        def concatenation
+          Node.concatenation(
+            [
+              Node.terminal('[', '"["'),
+              Node.terminal('foo', ABNF.foo),
+              Node.terminal(']', '"]"'),
+            ],
+            ABNF.concatenation,
+          )
+        end
+
+        def repetition
+          abnf = %{#{ABNF.foo} / #{ABNF.bar} / #{ABNF.baz}}
+          regexp = %r{foo|bar|baz}
+
+          Node.repetition(
+            [
+              Node.alternation(Node.terminal('foo', ABNF.foo), abnf),
+              Node.alternation(Node.terminal('bar', ABNF.foo), abnf),
+              Node.alternation(Node.terminal('baz', ABNF.foo), abnf),
+            ],
+            "1*( #{abnf} )",
+          )
+        end
+
+        def terminal
+          Node.terminal 'foo', ABNF.foo
+        end
+
+        def unfactored abnf: nil, text: nil
+          abnf ||= ABNF.example
+          text ||= 'some-text'
+
+          pattern = Rules.regexp_pattern.regexp
+          match_data = pattern.match text
+
+          Node.pattern_match match_data, abnf
+        end
+        alias_method :example, :unfactored
+        alias_method :string, :unfactored
+
+        def factored
+          Node.alternation(
+            Node.concatenation(
+              [
+                Node.repetition(
+                  [
+                    Node.alternation(
+                      Node.terminal('s', '%x61-7A'),
+                      'ALPHA',
+                    ),
+                    Node.alternation(
+                      Node.terminal('o', '%x61-7A'),
+                      'ALPHA',
+                    ),
+                    Node.alternation(
+                      Node.terminal('m', '%x61-7A'),
+                      'ALPHA',
+                    ),
+                    Node.alternation(
+                      Node.terminal('e', '%x61-7A'),
+                      'ALPHA',
+                    ),
+                  ],
+                  '1*ALPHA',
+                ),
+
+                Node.terminal('-', '"-"'),
+
+                Node.repetition(
+                  [
+                    Node.alternation(
+                      Node.terminal('t', '%x61-7A'),
+                      'ALPHA',
+                    ),
+                    Node.alternation(
+                      Node.terminal('e', '%x61-7A'),
+                      'ALPHA',
+                    ),
+                    Node.alternation(
+                      Node.terminal('x', '%x61-7A'),
+                      'ALPHA',
+                    ),
+                    Node.alternation(
+                      Node.terminal('t', '%x61-7A'),
+                      'ALPHA',
+                    ),
+                  ],
+                  '1*ALPHA',
+                ),
+              ],
+              '1*ALPHA "-" 1*ALPHA',
+            ),
+            '(1*ALPHA "-" 1*ALPHA) / "~"',
+          )
+        end
+      end
+    end
+  end
+end

data/lib/abnf/parser/controls/rule_lists.rb

@@ -0,0 +1,63 @@
+module ABNF
+  module Parser
+    module Controls
+      module RuleLists
+        extend self
+
+        def deep_reference
+          rule_list = reference Rules.regexp_pattern
+          referenced_rule = rule_list['references-some-rule']
+
+          alternation = Parser::Rules::Alternation.new(
+            [
+              referenced_rule,
+              Rules.concatenation,
+            ],
+            "( #{referenced_rule.abnf} / #{ABNF.concatenation} )",
+          )
+
+          repetition = Parser::Rules::Repetition.new(
+            alternation,
+            (1...Float::INFINITY),
+            "1*#{alternation.abnf}",
+          )
+
+          rule_list.update 'deep-reference' => repetition
+          rule_list
+        end
+
+        def example
+          rule = Rules.example
+
+          rule_list = RuleList.new
+          rule_list.update 'some-rule' => rule
+          rule_list
+        end
+
+				def recursive
+          MultiplesOfThree.rule_list
+				end
+
+        def reference referenced_rule=nil
+          referenced_rule ||= Rules.example
+
+          rule = Parser::Rules::Concatenation.new(
+            [
+              Parser::Rules::Terminal.string('[', '"["'),
+              Parser::Rules::Reference.new('some-rule'),
+              Parser::Rules::Terminal.string(']', '"]"'),
+            ],
+            %{"[" #{referenced_rule.abnf} "]"},
+          )
+
+          rule_list = RuleList.new
+          rule_list.update(
+            'references-some-rule' => rule,
+            'some-rule' => referenced_rule,
+          )
+          rule_list
+        end
+      end
+    end
+  end
+end

data/lib/abnf/parser/controls/rule_lists/multiples_of_three.rb

@@ -0,0 +1,146 @@
+module ABNF
+  module Parser
+    module Controls
+      module RuleLists
+        module MultiplesOfThree
+          extend self
+
+          def n0
+            Parser::Rules::Alternation.new(
+              [
+                Parser::Rules::Terminal.string('0', '"0"'),
+                Parser::Rules::Terminal.string('3', '"3"'),
+                Parser::Rules::Terminal.string('6', '"6"'),
+                Parser::Rules::Terminal.string('9', '"9"'),
+              ],
+              '"0" / "3" / "6" / "9"',
+            )
+          end
+
+          def n1
+            Parser::Rules::Alternation.new(
+              [
+                Parser::Rules::Terminal.string('1', '"1"'),
+                Parser::Rules::Terminal.string('4', '"4"'),
+                Parser::Rules::Terminal.string('7', '"7"'),
+              ],
+              '"1" / "4" / "7"',
+            )
+          end
+
+          def n2
+            Parser::Rules::Alternation.new(
+              [
+                Parser::Rules::Terminal.string('2', '"2"'),
+                Parser::Rules::Terminal.string('5', '"5"'),
+                Parser::Rules::Terminal.string('8', '"8"'),
+              ],
+              '"2" / "5" / "8"',
+            )
+          end
+
+          def s0
+            Parser::Rules::Alternation.new(
+              [
+                Parser::Rules::Concatenation.new(
+                  [
+                    Parser::Rules::Reference.new('n0'),
+                    Parser::Rules::Reference.new('s0'),
+                  ],
+                  'n0 s0',
+                ),
+                Parser::Rules::Concatenation.new(
+                  [
+                    Parser::Rules::Reference.new('n1'),
+                    Parser::Rules::Reference.new('s2'),
+                  ],
+                  'n1 s2',
+                ),
+                Parser::Rules::Concatenation.new(
+                  [
+                    Parser::Rules::Reference.new('n2'),
+                    Parser::Rules::Reference.new('s1'),
+                  ],
+                  'n2 s1',
+                ),
+                Parser::Rules::Terminal.string('', '""'),
+              ],
+              'n0 s0 / n1 n2 / n2 s1 / ""',
+            )
+          end
+
+          def s1
+            Parser::Rules::Alternation.new(
+              [
+                Parser::Rules::Concatenation.new(
+                  [
+                    Parser::Rules::Reference.new('n0'),
+                    Parser::Rules::Reference.new('s1'),
+                  ],
+                  'n0 s1',
+                ),
+                Parser::Rules::Concatenation.new(
+                  [
+                    Parser::Rules::Reference.new('n1'),
+                    Parser::Rules::Reference.new('s0'),
+                  ],
+                  'n1 s0',
+                ),
+                Parser::Rules::Concatenation.new(
+                  [
+                    Parser::Rules::Reference.new('n2'),
+                    Parser::Rules::Reference.new('s2'),
+                  ],
+                  'n2 s2',
+                ),
+              ],
+              'n0 s1 / n1 s0 / n2 s2',
+            )
+          end
+
+          def s2
+            Parser::Rules::Alternation.new(
+              [
+                Parser::Rules::Concatenation.new(
+                  [
+                    Parser::Rules::Reference.new('n0'),
+                    Parser::Rules::Reference.new('s2'),
+                  ],
+                  'n0 s2',
+                ),
+                Parser::Rules::Concatenation.new(
+                  [
+                    Parser::Rules::Reference.new('n1'),
+                    Parser::Rules::Reference.new('s1'),
+                  ],
+                  'n1 s1',
+                ),
+                Parser::Rules::Concatenation.new(
+                  [
+                    Parser::Rules::Reference.new('n2'),
+                    Parser::Rules::Reference.new('s0'),
+                  ],
+                  'n2 s0',
+                ),
+              ],
+              'n0 s2 / n1 s1 / n2 s0',
+            )
+          end
+
+          def rule_list
+            rule_list = RuleList.new
+            rule_list.update(
+              's0' => s0,
+              's1' => s1,
+              's2' => s2,
+              'n0' => n0,
+              'n1' => n1,
+              'n2' => n2,
+            )
+            rule_list
+          end
+        end
+      end
+    end
+  end
+end

data/lib/abnf/parser/controls/rules.rb

@@ -4,39 +4,62 @@ module ABNF
       module Rules
         extend self
 
-        def alternative
-          Parser::Rule::Alternative.new terminal_value, value_range
+        def alternation
+          Parser::Rules::Alternation.new(
+            [
+              Parser::Rules::Terminal.string('foo', ABNF.foo),
+              Parser::Rules::Terminal.string('bar', ABNF.bar),
+              Parser::Rules::Terminal.string('baz', ABNF.baz),
+            ],
+            ABNF.alternation,
+          )
         end
 
         def concatenation
-          Parser::Rule::Concatenation.new terminal_value, reference
+          Parser::Rules::Concatenation.new(
+            [
+              Parser::Rules::Terminal.string('[', '"["'),
+              Parser::Rules::Terminal.string('foo', ABNF.foo),
+              Parser::Rules::Terminal.string(']', '"]"'),
+            ],
+            ABNF.concatenation,
+          )
         end
 
-        def optional
-          Parser::Rule::Optional.new terminal_value
+        def option rule=nil
+          rule ||= example
+          abnf = "[#{rule.abnf}]"
+          Parser::Rules::Repetition.new rule, (0..1), abnf
         end
 
-        def reference
-          Parser::Rule::Reference.new 'some-rule'
+        def prose_val
+          Parser::Rules::ProseVal.new '<Some Prose>'
         end
 
-        def repetition range = nil
-          range ||= (1..2)
-          element = Rules.terminal_value
+        def reference
+          Parser::Rules::Reference.new 'some-rule'
+        end
 
-          Parser::Rule::Repetition.new range, element
+        def regexp_pattern
+          regexp = %r{(?<word1>[[:alpha:]]+)-(?<word2>[[:alpha:]]+)|~}
+          Parser::Rules::RegexpPattern.new regexp, ABNF.regexp_pattern, 9
         end
 
-        def space
-          Parser::Rule::TerminalValue.new ' '
+        def repetition abnf: nil, range: nil
+          range ||= (0..Float::INFINITY)
+          abnf ||= '*"foo"'
+
+          Parser::Rules::Repetition.new terminal, range, abnf
         end
 
-        def terminal_value case_sensitive = false
-          Parser::Rule::TerminalValue.new 'some-string', case_sensitive
+        def terminal
+          Parser::Rules::Terminal.string 'foo', ABNF.foo
         end
+        alias_method :example, :terminal
+        alias_method :foo, :terminal
 
-        def value_range
-          Parser::Rule::ValueRange.new 'A', 'Z'
+        def terminal_range
+          Parser::Rules::Terminal.character_range (' '..'!'), ABNF.foo
         end
       end
     end