abnf-parser 0.8.1 → 0.9.0

data/lib/abnf/parser/{errors.rb → error.rb}

@@ -1,7 +1,5 @@
 module ABNF
   module Parser
     Error = Class.new StandardError
-    ParsingError = Class.new Error
-    CompileError = Class.new Error
   end
 end

data/lib/abnf/parser/node.rb

@@ -0,0 +1,138 @@
+module ABNF
+  module Parser
+    module Node
+      def self.alternation node, abnf
+        Alternation.new node, abnf
+      end
+
+      def self.concatenation children=nil, abnf
+        children ||= Array(children)
+        Sequence.new children, abnf
+      end
+
+      def self.repetition children=nil, abnf
+        children ||= Array(children)
+        Sequence.new children, abnf
+      end
+
+      def self.pattern_match match_data, abnf
+        PatternMatch.new match_data, abnf
+      end
+
+      def self.terminal text, abnf
+        Single.new text, abnf
+      end
+
+      def == other_node
+        return false unless other_node.is_a? Node
+        self.text == other_node.text and self.abnf == other_node.abnf
+      end
+
+      def octets
+        text.bytesize
+      end
+
+      class Alternation
+        include Node
+
+        attr_reader :abnf
+        attr_reader :match
+
+        def initialize match, abnf
+          @abnf = abnf
+          @match = match
+        end
+
+        def text
+          match.text
+        end
+      end
+
+      class Sequence
+        include Enumerable
+        include Node
+
+        attr_reader :abnf
+        attr_reader :children
+
+        def initialize children, abnf
+          @abnf = abnf
+          @children = children
+        end
+
+        def [] index
+          children[index]
+        end
+
+        def add child
+          children << child
+        end
+        alias_method :<<, :add
+
+        def child_count
+          children.size
+        end
+
+        def each &block
+          children.each &block
+        end
+
+        def text
+          @text ||= to_a.join
+        end
+
+        def to_a
+          map do |child|
+            if child.respond_to? :to_a
+              child.to_a
+            else
+              child.text
+            end
+          end
+        end
+      end
+
+      class Single
+        include Node
+
+        attr_reader :abnf
+        attr_reader :text
+
+        def initialize text, abnf
+          @text = text
+          @abnf = abnf
+        end
+      end
+
+      class PatternMatch
+        include Node
+
+        attr_reader :abnf
+        attr_reader :match_data
+
+        def initialize match_data, abnf
+          @match_data = match_data
+          @abnf = abnf
+        end
+
+        def pattern
+          match_data.regexp
+        end
+
+        def text
+          match_data.to_s
+        end
+
+        def to_h
+          hash = {}
+
+          match_data.names.each do |name|
+            hash[name] = match_data[name]
+          end
+
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/abnf/parser/rule_list.rb

@@ -1,24 +1,63 @@
 module ABNF
   module Parser
     class RuleList
-      attr_reader :rules
+      def == other_rule_list
+        return false unless other_rule_list.is_a? self.class
 
-      def initialize
-        @rules = {}
+        rules == other_rule_list.rules
       end
 
-      def compile abnf
-        stream = Parser::TextStream(abnf)
+      def [] rule_name
+        rules[rule_name]
+      end
+
+      def []= rule_name, rule
+        rules[rule_name] = rule
+      end
+
+      def apply rule_name, io
+        rule = fetch rule_name
+
+        call_method = rule.method :call
 
-        until stream.eof?
-          stream.match Grammar::C_WSP
-          stream.match Grammar::C_NL
+        io = StringIO.new io if io.is_a? String
 
-          rule = Grammar::Rule.compile stream
-          next unless rule
+        rules[rule_name].(io, self)
+      end
+
+      def fetch rule_name
+        rule = rules[rule_name]
 
-          rules[rule.name] = rule
+        unless rule
+          raise Error.new "Rule not found: #{rule_name.inspect}"
         end
+
+        rule
+      end
+
+      def names
+        rules.keys
+      end
+
+      def replace rule_name, regexp, max_octets
+        existing_rule = fetch rule_name
+        abnf = existing_rule
+
+        rule = Rules::RegexpPattern.new regexp, abnf, max_octets
+        rules[rule_name] = rule
+      end
+
+      def rules
+        @rules ||= {}
+      end
+
+      def update additional_rules
+        rules.update additional_rules
+      end
+
+      def self.common
+        abnf = Common.to_s
+        Compiler.(abnf)
       end
     end
   end

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

@@ -0,0 +1,38 @@
+module ABNF
+  module Parser
+    module Rules
+      class Alternation
+        attr_reader :abnf
+        attr_reader :alternatives
+
+        def initialize alternatives, abnf
+          @abnf = abnf
+          @alternatives = alternatives
+        end
+
+        def == other_rule
+          return unless other_rule.is_a? self.class
+          alternatives == other_rule.alternatives
+        end
+
+        def call io, rule_list=nil
+          best_match = nil
+
+          alternatives.each do |alternative|
+            node = alternative.(io, rule_list) or next
+
+            io.seek -node.octets, IO::SEEK_CUR
+
+            best_match ||= node
+            best_match = node if node.octets > best_match.octets
+          end
+
+          return unless best_match
+
+          io.seek best_match.octets, IO::SEEK_CUR
+          best_match
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module ABNF
+  module Parser
+    module Rules
+      class Concatenation
+        attr_reader :abnf
+        attr_reader :rules
+
+        def initialize rules, abnf
+          @abnf = abnf
+          @rules = rules
+        end
+
+        def == other_rule
+          return false unless other_rule.is_a? self.class
+          self.rules == other_rule.rules
+        end
+
+        def call io, rule_list=nil
+          node = Node.concatenation abnf
+
+          match = rules.all? do |rule|
+            child = rule.(io, rule_list) or break
+            node << child
+          end
+
+          if match
+            node
+          else
+            io.seek -node.octets, IO::SEEK_CUR
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module ABNF
+  module Parser
+    module Rules
+      class ProseVal
+        attr_reader :abnf
+
+        def initialize abnf
+          @abnf = abnf
+        end
+
+        def call io, _=nil
+          error = ABNF::Parser::Error.new "Cannot parse prose #{abnf.inspect}"
+          raise error
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module ABNF
+  module Parser
+    module Rules
+      class Reference
+        attr_reader :rule_name
+
+        def initialize rule_name
+          @rule_name = rule_name
+        end
+
+        def abnf
+          rule_name
+        end
+
+        def call io, rule_list
+          rule = rule_list.fetch rule_name
+          rule.(io, rule_list)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module ABNF
+  module Parser
+    module Rules
+      class RegexpPattern
+        attr_reader :abnf
+        attr_reader :max_octets
+        attr_reader :regexp
+
+        def initialize regexp, abnf, max_octets
+          @abnf = abnf
+          @max_octets = max_octets
+          @regexp = regexp
+        end
+
+        def bounded_regexp
+          @bounded_regexp ||= %r{\A#{regexp}}
+        end
+
+        def call io, _=nil
+          string = io.read max_octets
+          return unless string
+          io.seek -string.bytesize, IO::SEEK_CUR
+
+          match_data = bounded_regexp.match string
+
+          if match_data
+            node = Node.pattern_match match_data, abnf
+            io.seek node.octets, IO::SEEK_CUR
+            node
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module ABNF
+  module Parser
+    module Rules
+      class Repetition
+        attr_reader :abnf
+        attr_reader :rule
+        attr_reader :range
+
+        def initialize rule, range, abnf
+          @abnf = abnf
+          @rule = rule
+          @range = range
+        end
+
+        def == other_rule
+          return false unless other_rule.is_a? self.class
+          rule == other_rule.rule and range == other_rule.range
+        end
+
+        def call io, rule_list=nil
+          node = Node.repetition abnf
+
+          (0...maximum).each do
+            child = rule.(io, rule_list) or break
+            node << child
+          end
+
+          if node.child_count >= minimum
+            node
+          else
+            io.seek -node.octets, IO::SEEK_CUR
+            nil
+          end
+        end
+
+        def maximum
+          range.last
+        end
+
+        def minimum
+          range.first
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module ABNF
+  module Parser
+    module Rules
+      class Terminal
+        attr_reader :abnf
+        attr_reader :pattern
+
+        def initialize pattern, abnf
+          @abnf = abnf
+          @pattern = pattern
+          fail if self.class == Terminal
+        end
+
+        def == other_rule
+          return false unless other_rule.is_a? self.class
+          pattern == other_rule.pattern
+        end
+
+        def call io, _=nil
+          potential_match = io.read octets
+          return unless potential_match
+
+          matches = match? potential_match
+
+          if matches
+            Node.terminal potential_match, abnf
+          else
+            io.seek -potential_match.bytesize, IO::SEEK_CUR
+            nil
+          end
+        end
+
+        class String < Terminal
+          def match? potential_match
+            pattern == potential_match
+          end
+
+          def octets
+            pattern.bytesize
+          end
+        end
+
+        def self.string *arguments
+          String.new *arguments
+        end
+
+        class CharacterRange < Terminal
+          def match? potential_match
+            pattern.include? potential_match
+          end
+
+          def octets
+            1
+          end
+        end
+
+        def self.character_range *arguments
+          CharacterRange.new *arguments
+        end
+      end
+    end
+  end
+end