abnf-parser 0.8.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 290cf1be0e24f0bc64e51280c1cff38a11520bfc
-  data.tar.gz: 61f5f4ae1bae589af2a80839dc8be01ad642f3e8
+  metadata.gz: 50f2cf7354e434cc4b8be13b68b87676723d44b8
+  data.tar.gz: 9226accdfda9dc4b4df0d2097bd30c863a070d0a
 SHA512:
-  metadata.gz: 0c06a722202c3e87b6a895b0206ee6a2674a88f90875405319de1ae4f61a33c995a7f096af29311333833aa2efa14d893987ad1f29532aa436ef05fdc5adc5c4
-  data.tar.gz: 4b51e5881e2cafe761e6db107894ae5af457e6308f95ec7deaabc4fd06ba849670e964899da3e77f0235068c082c90288da613395fd23460e46da218f6e79521
+  metadata.gz: fa1836ab811e4fe3c6b2c5ea3d5cd5acaf270a08cd57c25b85b5971a9ee77410c5911bed4ab893a431bd40775039a1bcf5e1fed57ed42f135215df5a4f6e667e
+  data.tar.gz: 90a53156e26123c08dd5d232231403d2061789b49cc848e1681034350ab56192b0c5cdc477901266028b3f9dc4aca6ac0a356c92c218ad1b68f39d5241062899

data/lib/abnf/parser.rb

@@ -1,28 +1,26 @@
-require 'abnf/parser/ast'
-require 'abnf/parser/compiler'
-require 'abnf/parser/errors'
-require 'abnf/parser/text_stream'
+require 'stringio'
 
-require 'abnf/parser/grammar'
-require 'abnf/parser/grammar/alternative'
-require 'abnf/parser/grammar/char_val'
-require 'abnf/parser/grammar/concatenation'
-require 'abnf/parser/grammar/element'
-require 'abnf/parser/grammar/num_val'
-require 'abnf/parser/grammar/prose_val'
-require 'abnf/parser/grammar/repetition'
-require 'abnf/parser/grammar/rule'
-require 'abnf/parser/grammar/rulename'
+require 'abnf/parser/common'
+require 'abnf/parser/error'
+require 'abnf/parser/node'
+require 'abnf/parser/rule_list'
 
-require 'abnf/parser/rule'
-require 'abnf/parser/rule/alternative'
-require 'abnf/parser/rule/concatenation'
-require 'abnf/parser/rule/none'
-require 'abnf/parser/rule/optional'
-require 'abnf/parser/rule/reference'
-require 'abnf/parser/rule/repetition'
-require 'abnf/parser/rule/terminal_value'
-require 'abnf/parser/rule/value_range'
+require 'abnf/parser/compiler'
+require 'abnf/parser/compiler/rule_builder'
+require 'abnf/parser/compiler/alternation'
+require 'abnf/parser/compiler/concatenation'
+require 'abnf/parser/compiler/element'
+require 'abnf/parser/compiler/group'
+require 'abnf/parser/compiler/option'
+require 'abnf/parser/compiler/repetition'
+require 'abnf/parser/compiler/rule_list'
+require 'abnf/parser/compiler/token'
+require 'abnf/parser/compiler/tokenizer'
 
-require 'abnf/parser/rule_list'
-require 'abnf/parser/rule_list/entry'
+require 'abnf/parser/rules/alternation'
+require 'abnf/parser/rules/concatenation'
+require 'abnf/parser/rules/prose_val'
+require 'abnf/parser/rules/reference'
+require 'abnf/parser/rules/regexp_pattern'
+require 'abnf/parser/rules/repetition'
+require 'abnf/parser/rules/terminal'

data/lib/abnf/parser/common.rb

@@ -0,0 +1,63 @@
+module ABNF
+  module Parser
+    module Common
+      def self.to_s
+        <<-ABNF
+ALPHA          =  %x41-5A / %x61-7A   ; A-Z / a-z\r
+\r
+BIT            =  "0" / "1"\r
+\r
+CHAR           =  %x01-7F\r
+                       ; any 7-bit US-ASCII character,\r
+                       ;  excluding NUL\r
+\r
+CR             =  %x0D\r
+                       ; carriage return\r
+\r
+CRLF           =  CR LF\r
+                       ; Internet standard newline\r
+\r
+CTL            =  %x00-1F / %x7F\r
+                       ; controls\r
+\r
+DIGIT          =  %x30-39\r
+                       ; 0-9\r
+\r
+DQUOTE         =  %x22\r
+                       ; " (Double Quote)\r
+\r
+HEXDIG         =  DIGIT / "A" / "B" / "C" / "D" / "E" / "F"\r
+\r
+HTAB           =  %x09\r
+                       ; horizontal tab\r
+\r
+LF             =  %x0A\r
+                       ; linefeed\r
+\r
+LWSP           =  *(WSP / CRLF WSP)\r
+                       ; Use of this linear-white-space rule\r
+                       ;  permits lines containing only white\r
+                       ;  space that are no longer legal in\r
+                       ;  mail headers and have caused\r
+                       ;  interoperability problems in other\r
+                       ;  contexts.\r
+                       ; Do not use when defining mail\r
+                       ;  headers and use with caution in\r
+                       ;  other contexts.\r
+\r
+OCTET          =  %x00-FF\r
+                       ; 8 bits of data\r
+\r
+SP             =  %x20\r
+\r
+VCHAR          =  %x21-7E\r
+                       ; visible (printing) characters\r
+\r
+WSP            =  SP / HTAB\r
+                       ; white space\r
+\r
+        ABNF
+      end
+    end
+  end
+end

data/lib/abnf/parser/compiler.rb

@@ -1,52 +1,92 @@
 module ABNF
   module Parser
-    module Compiler
-      def self.included cls
-        cls.extend BuildMethod
-        cls.extend CompileMethod
-        cls.extend PatternMethod
+    class Compiler
+      attr_accessor :output
+      attr_reader :tokens
+
+      def initialize tokens, rule_list=nil
+        @tokens = tokens
+        @rule_list = rule_list
       end
 
-      module CompileMethod
-        def compile? stream
-          if compile stream then true else false end
+      def self.build abnf, include_common: nil
+        include_common ||= false
+
+        if include_common
+          common_rule_list = Parser::RuleList.common
         end
 
-        def compile stream
-          stream = ABNF::Parser::TextStream(stream)
-          pattern = self.pattern
-          match_data = stream.match pattern
+        tokenizer = Tokenizer.build abnf
+        instance = new tokenizer, common_rule_list
+        instance.push RuleList
+        instance
+      end
 
-          return unless match_data
+      def self.call *arguments
+        instance = build *arguments
+        instance.()
+        instance.rule_list
+      end
 
-          instance = build stream, match_data
-          instance.()
+      def call
+        tokens.each do |token|
+          handle token
         end
+
+        output
       end
 
-      module BuildMethod
-        def build stream, match_data
-          instance = new stream, match_data
-          instance
-        end
+      def current_frame
+        stack.last
       end
 
-      module PatternMethod
-        def pattern
-          if const_defined? :PATTERN
-            const_get :PATTERN
-          else
-            @null_pattern ||= %r{}
-          end
-        end
+      def handle token
+        return unless current_frame
+        current_frame.(token)
+      end
+
+      def pop rule
+        frame = stack.pop
+
+        self.output = rule if stack.empty?
+
+        frame.exited rule
+      end
+
+      def push rule_builder_cls, &block
+        rule_builder = rule_builder_cls.new self
+        frame = Frame.new rule_builder, block
+        stack.push frame
+      end
+
+      def root
+        stack.first
+      end
+
+      def rule_list
+        @rule_list ||= Parser::RuleList.new
+      end
+
+      def stack
+        @stack ||= []
       end
 
-      attr_reader :match_data
-      attr_reader :stream
+      class Frame
+        attr_reader :block
+        attr_reader :rule_builder
+
+        def initialize rule_builder, block
+          @block = block
+          @rule_builder = rule_builder
+        end
+
+        def call token
+          rule_builder.(token)
+        end
 
-      def initialize stream, match_data = nil
-        @match_data = match_data
-        @stream = stream
+        def exited rule
+          block.(rule) if block
+        end
       end
     end
   end

data/lib/abnf/parser/compiler/alternation.rb

@@ -0,0 +1,54 @@
+module ABNF
+  module Parser
+    class Compiler
+      class Alternation < RuleBuilder
+        def alternation_slash _
+        end
+
+        def alternative rule
+          alternatives << rule
+        end
+
+        def alternatives
+          @alternatives ||= []
+        end
+
+        def c_nl token
+          finished
+          compiler.handle token
+        end
+
+        def c_wsp _
+        end
+
+        def group_stop token
+          finished
+          compiler.handle token
+        end
+
+        def finished
+          if alternatives.size == 1
+            rule = alternatives[0]
+          else
+            abnf = alternatives.map &:abnf
+            abnf *= ' / '
+            rule = Rules::Alternation.new alternatives, abnf
+          end
+
+          compiler.pop rule
+        end
+
+        def option_stop token
+          finished
+          compiler.handle token
+        end
+
+        def start_rule token
+          compiler.push Concatenation do |rule|
+            alternative rule
+          end
+        end
+      end
+    end
+  end
+end

data/lib/abnf/parser/compiler/concatenation.rb

@@ -0,0 +1,55 @@
+module ABNF
+  module Parser
+    class Compiler
+      class Concatenation < RuleBuilder
+        def alternation_slash _
+          finished
+        end
+
+        def c_nl token
+          finished
+          compiler.handle token
+        end
+
+        def c_wsp _
+        end
+
+        def group_stop token
+          finished
+          compiler.handle token
+        end
+
+        def finished
+          if repetitions.size == 1
+            rule = repetitions.first
+          else
+            abnf = repetitions.map &:abnf
+            abnf *= ' '
+            rule = Rules::Concatenation.new repetitions, abnf
+          end
+
+          compiler.pop rule
+        end
+
+        def option_stop token
+          finished
+          compiler.handle token
+        end
+
+        def repetition repetition
+          repetitions << repetition
+        end
+
+        def repetitions
+          @repetitions ||= []
+        end
+
+        def start_rule token
+          compiler.push Repetition do |element|
+            repetition element
+          end
+        end
+      end
+    end
+  end
+end

data/lib/abnf/parser/compiler/element.rb

@@ -0,0 +1,87 @@
+module ABNF
+  module Parser
+    class Compiler
+      class Element < RuleBuilder
+        attr_accessor :rule
+
+        def bin_val_range token
+          num_val_range token, 2
+        end
+
+        def bin_val_sequence token
+          num_val_sequence token, 2
+        end
+
+        def char_val token
+          string = token.lexeme[1...-1]
+          rule = Rules::Terminal.string string, token.abnf
+          compiler.pop rule
+        end
+
+        def dec_val_range token
+          num_val_range token, 10
+        end
+
+        def dec_val_sequence token
+          num_val_sequence token, 10
+        end
+
+        def group_start _
+          compiler.push Group do |rule|
+            compiler.pop rule
+          end
+        end
+
+        def hex_val_range token
+          num_val_range token, 16
+        end
+
+        def hex_val_sequence token
+          num_val_sequence token, 16
+        end
+
+        def num_val_range token, base
+          first, last = token.lexeme[2..-1].split '-'
+
+          first = first.to_i base
+          last = last.to_i base
+
+          range = (first.chr..last.chr)
+
+          rule = Rules::Terminal.character_range range, token.abnf
+          compiler.pop rule
+        end
+
+        def num_val_sequence token, base
+          codes = token.lexeme[2..-1].split '.'
+
+          codes.map! do |code|
+            code.to_i base
+          end
+
+          string = codes.pack 'C*'
+          rule = Rules::Terminal.string string, token.abnf
+          compiler.pop rule
+        end
+
+        def option_start _
+          compiler.push Option do |rule|
+            abnf = "[#{rule.abnf}]"
+            rule = Rules::Repetition.new rule, (0..1), abnf
+            compiler.pop rule
+          end
+        end
+
+        def prose_val token
+          rule = Rules::ProseVal.new token.abnf
+          compiler.pop rule
+        end
+
+        def rulename token
+          rule = Rules::Reference.new token.lexeme
+          compiler.pop rule
+        end
+      end
+    end
+  end
+end