abnf-parser 0.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f9345bd72e56a26df453cb85fe51c3dac095f90c
+  data.tar.gz: 9caae3be175e985e45e9be3fa75d7293e28d13fe
+SHA512:
+  metadata.gz: fce4984fcd8c8f28cbfa5b1cadb1721fcb43f08b9c5754c5d2aa42c1b2a335f33b1efd18c6d58ad785bccf4bb4fe3113929c09afa6c9ac04bd2dce5e59799f60
+  data.tar.gz: e8ddbfa79408449743b00d809006dd897544ee10bd966d26bc09d186cc55624f269f01bf28721d10b541644b08062cf53e4405242f951bed9748c77e6d34c721

data/lib/abnf/compiler.rb

@@ -0,0 +1,28 @@
+require 'abnf/compiler/ast'
+require 'abnf/compiler/errors'
+require 'abnf/compiler/text_stream'
+
+require 'abnf/compiler/grammar'
+require 'abnf/compiler/grammar/compiler'
+require 'abnf/compiler/grammar/alternative'
+require 'abnf/compiler/grammar/char_val'
+require 'abnf/compiler/grammar/concatenation'
+require 'abnf/compiler/grammar/element'
+require 'abnf/compiler/grammar/num_val'
+require 'abnf/compiler/grammar/prose_val'
+require 'abnf/compiler/grammar/repetition'
+require 'abnf/compiler/grammar/rule'
+require 'abnf/compiler/grammar/rulename'
+
+require 'abnf/compiler/rule'
+require 'abnf/compiler/rule/alternative'
+require 'abnf/compiler/rule/concatenation'
+require 'abnf/compiler/rule/none'
+require 'abnf/compiler/rule/optional'
+require 'abnf/compiler/rule/reference'
+require 'abnf/compiler/rule/repetition'
+require 'abnf/compiler/rule/terminal_value'
+require 'abnf/compiler/rule/value_range'
+
+require 'abnf/compiler/rule_list'
+require 'abnf/compiler/rule_list/entry'

data/lib/abnf/compiler/ast.rb

@@ -0,0 +1,67 @@
+module ABNF
+  module Compiler
+    module AST
+      def self.leaf *arguments
+        Leaf.new *arguments
+      end
+
+      class Leaf
+        attr_reader :text
+
+        def initialize text
+          @text = text
+        end
+
+        def == other_node
+          other_node.respond_to? :text and text == other_node.text
+        end
+
+        def inner_text
+          text
+        end
+      end
+
+      def self.repetition *arguments
+        Repetition.new *arguments
+      end
+
+      class Repetition
+        attr_reader :nodes
+
+        def initialize *nodes
+          @nodes = nodes
+        end
+
+        def == other_node
+          other_node.respond_to? :nodes and nodes == other_node.nodes
+        end
+
+        def inner_text
+          strings = nodes.map &:inner_text
+          strings.join
+        end
+      end
+
+      def self.sequence *arguments
+        Sequence.new *arguments
+      end
+
+      class Sequence
+        attr_reader :nodes
+
+        def initialize *nodes
+          @nodes = nodes
+        end
+
+        def == other_node
+          other_node.respond_to? :nodes and nodes == other_node.nodes
+        end
+
+        def inner_text
+          strings = nodes.map &:inner_text
+          strings.join
+        end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/controls.rb

@@ -0,0 +1,4 @@
+require 'abnf/compiler/controls/ast'
+require 'abnf/compiler/controls/grammar'
+require 'abnf/compiler/controls/rules'
+require 'abnf/compiler/controls/text_stream'

data/lib/abnf/compiler/controls/ast.rb

@@ -0,0 +1,28 @@
+module ABNF
+  module Compiler
+    module Controls
+      module AST
+        extend self
+
+        def leaf text = nil
+          text ||= 'some-string'
+          Compiler::AST.leaf text
+        end
+
+        def repetition
+          Compiler::AST.repetition(
+            leaf('some-string'),
+            leaf('other-string'),
+          )
+        end
+
+        def sequence
+          Compiler::AST.sequence(
+            leaf('some-string'),
+            leaf('other-string'),
+          )
+        end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/controls/grammar.rb

@@ -0,0 +1,32 @@
+module ABNF
+  module Compiler
+    module Controls
+      module Grammar
+        class Example
+          attr_reader :abnf
+          attr_reader :type
+
+          def initialize abnf, type
+            @abnf = abnf
+            @type = type
+          end
+
+          def rule
+            @rule ||= type.compile abnf
+          end
+        end
+
+        Alternative = Example.new '1*%x30-39 / *%x30-39 "*" *%x30-39', Compiler::Grammar::Alternative
+        CharVal = Example.new '"some-string"', Compiler::Grammar::CharVal
+        Concatenation = Example.new '"some-string" " " "some-string"', Compiler::Grammar::Concatenation
+        Group = Example.new '( "foo" / "bar" )', Compiler::Grammar::Element
+        NumVal = Example.new '%x41.42.43', Compiler::Grammar::NumVal
+        Option = Example.new '[ "some-string" ]', Compiler::Grammar::Element
+        Repetition = Example.new '1*2"some-element"', Compiler::Grammar::Repetition
+        Rulename = Example.new 'some-rule', Compiler::Grammar::Rulename
+        Rule = Example.new "some-rule = \"some-string\"\r\n", Compiler::Grammar::Rule
+        ProseVal = Example.new '<Some Prose>', Compiler::Grammar::ProseVal
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module ABNF
+  module Compiler
+    module Controls
+      module Rules
+        extend self
+
+        def alternative
+          Compiler::Rule::Alternative.new terminal_value, value_range
+        end
+
+        def concatenation
+          Compiler::Rule::Concatenation.new terminal_value, reference
+        end
+
+        def optional
+          Compiler::Rule::Optional.new terminal_value
+        end
+
+        def reference
+          Compiler::Rule::Reference.new 'some-rule'
+        end
+
+        def repetition range = nil
+          range ||= (1..2)
+          element = Rules.terminal_value
+
+          Compiler::Rule::Repetition.new range, element
+        end
+
+        def space
+          Compiler::Rule::TerminalValue.new ' '
+        end
+
+        def terminal_value case_sensitive = false
+          Compiler::Rule::TerminalValue.new 'some-string', case_sensitive
+        end
+
+        def value_range
+          Compiler::Rule::ValueRange.new 'A', 'Z'
+        end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/controls/text_stream.rb

@@ -0,0 +1,15 @@
+module ABNF
+  module Compiler
+    module Controls
+      module TextStream
+        def self.example
+          Compiler::TextStream.new 'some-text'
+        end
+
+        def self.rule
+          Compiler::TextStream.new 'some-rule = "some-string"'
+        end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/errors.rb

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

data/lib/abnf/compiler/grammar.rb

@@ -0,0 +1,17 @@
+module ABNF
+  module Compiler
+    module Grammar
+      C_NL = %r{;[\t -~]*\r\n|\r\n}n
+
+      C_WSP = %r{\A
+        (?:
+          [[:blank:]]
+        |
+          #{C_NL}[[:blank:]]
+        )*
+      }xn
+
+      CRLF = %r{\r\n}
+    end
+  end
+end

data/lib/abnf/compiler/grammar/alternative.rb

@@ -0,0 +1,27 @@
+module ABNF
+  module Compiler
+    module Grammar
+      class Alternative
+        include Compiler
+
+        DELIMITER = %r{/}
+
+        def call
+          concatenations = []
+
+          begin
+            concatenation = Concatenation.compile stream
+            break unless concatenation
+            concatenations << concatenation
+          end while match? stream
+
+          ABNF::Compiler::Rule::Alternative.new *concatenations
+        end
+
+        def match? stream
+          stream.match C_WSP and stream.match DELIMITER and stream.match C_WSP
+        end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/grammar/char_val.rb

@@ -0,0 +1,15 @@
+module ABNF
+  module Compiler
+    module Grammar
+      class CharVal
+        include Compiler
+
+        PATTERN = %r{\A"(?<string>[\x20-\x21\x23-\x7E]*)"}
+
+        def call
+          ABNF::Compiler::Rule::TerminalValue.new match_data['string']
+        end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/grammar/compiler.rb

@@ -0,0 +1,55 @@
+module ABNF
+  module Compiler
+    module Grammar
+      module Compiler
+        def self.included cls
+          cls.extend BuildMethod
+          cls.extend CompileMethod
+          cls.extend PatternMethod
+        end
+
+        module CompileMethod
+          def compile? stream
+            if compile stream then true else false end
+          end
+
+          def compile stream
+            stream = ABNF::Compiler::TextStream(stream)
+            pattern = self.pattern
+            match_data = stream.match pattern
+
+            return unless match_data
+
+            instance = build stream, match_data
+            instance.()
+          end
+        end
+
+        module BuildMethod
+          def build stream, match_data
+            instance = new stream, match_data
+            instance
+          end
+        end
+
+        module PatternMethod
+          def pattern
+            if const_defined? :PATTERN
+              const_get :PATTERN
+            else
+              @null_pattern ||= %r{}
+            end
+          end
+        end
+
+        attr_reader :match_data
+        attr_reader :stream
+
+        def initialize stream, match_data = nil
+          @match_data = match_data
+          @stream = stream
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module ABNF
+  module Compiler
+    module Grammar
+      class Concatenation
+        include Compiler
+
+        def call
+          repetitions = []
+
+          begin
+            repetition = Repetition.compile stream
+            break unless repetition
+            repetitions << repetition
+          end while stream.match C_WSP
+
+          ABNF::Compiler::Rule::Concatenation.new *repetitions
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module ABNF
+  module Compiler
+    module Grammar
+      class Element
+        include Compiler
+
+        GROUP_START = %r{\(}
+        GROUP_STOP = %r{\)}
+        OPTION_START = %r{\[}
+        OPTION_STOP = %r{\]}
+
+        def call
+          if stream.next_character == '['.freeze
+            option
+          elsif stream.next_character == '('.freeze
+            group
+          else
+            terminal
+          end
+        end
+
+        def group
+          stream.match GROUP_START
+          stream.match C_WSP
+
+          alternative = Alternative.compile stream
+
+          stream.match C_WSP
+          stream.match GROUP_STOP
+
+          alternative
+        end
+
+        def option
+          stream.match OPTION_START
+          stream.match C_WSP
+
+          alternative = Alternative.compile stream
+          option = ABNF::Compiler::Rule::Optional.new alternative
+
+          stream.match C_WSP
+          stream.match OPTION_STOP
+
+          option
+        end
+
+        def terminal
+          [Rulename, CharVal, NumVal, ProseVal].each do |type|
+            output = type.compile stream
+            return output if output
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/grammar/num_val.rb

@@ -0,0 +1,72 @@
+module ABNF
+  module Compiler
+    module Grammar
+      class NumVal
+        include Compiler
+
+        PATTERN = %r{\A%
+          (?:
+            (?<base_code>x)(?<first_character>[[:xdigit:]]+)
+            (?:(?:-(?<range_end>[[:xdigit:]]+))|(?<sequence>(?:\.[[:xdigit:]]+)+))?
+          |
+            (?<base_code>d)(?<first_character>[[:digit:]]+)
+            (?:(?:-(?<range_end>[[:digit:]]+))|(?<sequence>(?:\.[[:digit:]]+)+))?
+          |
+            (?<base_code>b)(?<first_character>[01]+)
+            (?:(?:-(?<range_end>[01]+))|(?<sequence>(?:\.[01]+)+))?
+          )
+        }nx
+
+        def base
+          base_code = match_data['base_code'.freeze]
+
+          {
+            'b'.freeze => 2,
+            'd'.freeze => 10,
+            'x'.freeze => 16,
+          }[base_code]
+        end
+
+        def build_string
+          *characters = sequence.to_s.split '.'
+
+          [first_character, *characters].reduce String.new do |string, character|
+            octet = convert_hex_character character
+            string << octet
+            string
+          end
+        end
+
+        def call
+          if range_end
+            first_octet = convert_hex_character first_character
+            last_octet = convert_hex_character range_end
+            return ABNF::Compiler::Rule::ValueRange.new first_octet, last_octet
+          end
+
+          ABNF::Compiler::Rule::TerminalValue.new build_string, true
+        end
+
+        def convert_hex_character hex
+          character = hex.to_i base
+          octet = character.chr
+          octet
+        end
+
+        def first_character
+          match_data['first_character'.freeze]
+        end
+
+        def range_end
+          match_data['range_end'.freeze]
+        end
+
+        def sequence
+          sequence = match_data['sequence'.freeze]
+          sequence.slice! 0, 1 if sequence
+          sequence
+        end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/grammar/prose_val.rb

@@ -0,0 +1,15 @@
+module ABNF
+  module Compiler
+    module Grammar
+      class ProseVal
+        include Compiler
+
+        PATTERN = %r{\A<[\x20-\x3D\x3F-\x7E]*>\z}n
+
+        def call
+          ABNF::Compiler::Rule::None.instance
+        end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/grammar/repetition.rb

@@ -0,0 +1,58 @@
+module ABNF
+  module Compiler
+    module Grammar
+      class Repetition
+        include Compiler
+
+        PATTERN = %r{\A
+          (?:
+            (?<range>(?<minimum>[[:digit:]]*)\*(?<maximum>[[:digit:]]*))
+          |
+            (?<fixed_number>[[:digit:]]+)
+          )?
+        }nx
+
+        def call
+          element = Element.compile stream
+          return unless element
+
+          if no_repeat?
+            min = 1
+            max = 1
+          elsif fixed_number
+            min = fixed_number.to_i
+            max = min
+          else
+            min = minimum.to_i
+            max = if maximum.empty? then Float::INFINITY else maximum.to_i end
+          end
+
+          return element if min == 1 and max == 1
+          return if min > max
+
+          ABNF::Compiler::Rule::Repetition.new min..max, element
+        end
+
+        def fixed_number
+          match_data['fixed_number'.freeze]
+        end
+
+        def maximum
+          match_data['maximum'.freeze]
+        end
+
+        def minimum
+          match_data['minimum'.freeze]
+        end
+
+        def no_repeat?
+          not fixed_number and not range?
+        end
+
+        def range?
+          match_data['range'.freeze]
+        end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/grammar/rule.rb

@@ -0,0 +1,31 @@
+module ABNF
+  module Compiler
+    module Grammar
+      class Rule
+        include Compiler
+
+        DELIMITER = %r{=/?}n
+
+        def call
+          reference = Rulename.compile stream
+          return unless reference
+
+          rulename = reference.rulename
+          stream.match C_WSP
+          alternative_form = extract_delimiter
+          stream.match C_WSP
+          alternative = Alternative.compile stream
+          stream.match C_NL
+
+          RuleList::Entry.new rulename, alternative, alternative_form
+        end
+
+        def extract_delimiter
+          match_data = stream.match DELIMITER
+          return unless match_data
+          match_data.to_s == '=/'.freeze
+        end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/grammar/rulename.rb

@@ -0,0 +1,15 @@
+module ABNF
+  module Compiler
+    module Grammar
+      class Rulename
+        include Compiler
+
+        PATTERN = %r{\A(?<string>[[:alpha:]][-[:alpha:][:digit:]]*)}n
+
+        def call
+          ABNF::Compiler::Rule::Reference.new match_data['string']
+        end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/rule.rb

@@ -0,0 +1,10 @@
+module ABNF
+  module Compiler
+    module Rule
+      def parse? text
+        stream = Compiler::TextStream(text)
+        if parse stream then true else false end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/rule/alternative.rb

@@ -0,0 +1,43 @@
+module ABNF
+  module Compiler
+    module Rule
+      class Alternative
+        include Rule
+
+        attr_reader :rules
+
+        def initialize *rules
+          @rules = rules
+        end
+
+        def find_match stream
+          matches = []
+
+          rules.each do |rule|
+            stream.branch do
+              node = rule.parse stream
+              matches.<< Match.new node, stream.position if node
+              false
+            end
+          end
+
+          matches.sort!
+          matches.pop
+        end
+
+        def parse stream
+          match = find_match stream
+          return unless match
+          stream.seek match.stream_position
+          match.node
+        end
+
+        Match = Struct.new :node, :stream_position do
+          def <=> match
+            stream_position <=> match.stream_position
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module ABNF
+  module Compiler
+    module Rule
+      class Concatenation
+        include Rule
+
+        attr_reader :rules
+
+        def initialize *rules
+          @rules = rules
+        end
+
+        def parse stream
+          nodes = []
+
+          stream.branch do
+            rules.all? do |rule|
+              node = rule.parse stream
+              nodes << node if node
+            end
+          end
+
+          return unless nodes.size == rules.size
+          AST.sequence *nodes
+        end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/rule/none.rb

@@ -0,0 +1,17 @@
+module ABNF
+  module Compiler
+    module Rule
+      class None
+        include Rule
+
+        def self.instance
+          @instance ||= new
+        end
+
+        def parse *;
+          raise ParsingError, 'Prose in ABNF source material must be overridden'
+        end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/rule/optional.rb

@@ -0,0 +1,24 @@
+module ABNF
+  module Compiler
+    module Rule
+      class Optional
+        include Rule
+
+        attr_reader :rule
+
+        def initialize rule
+          @rule = rule
+        end
+
+        def parse stream
+          node = nil
+          stream.branch do
+            node = rule.parse stream
+          end
+          node ||= AST.leaf ''
+          node
+        end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/rule/reference.rb

@@ -0,0 +1,19 @@
+module ABNF
+  module Compiler
+    module Rule
+      class Reference
+        include Rule
+
+        attr_reader :rulename
+
+        def initialize rulename
+          @rulename = rulename
+        end
+
+        def parse *;
+          raise ParsingError, "Rule not found: #{rulename.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/rule/repetition.rb

@@ -0,0 +1,41 @@
+module ABNF
+  module Compiler
+    module Rule
+      class Repetition
+        include Rule
+
+        attr_reader :element
+        attr_reader :range
+
+        def initialize range, element
+          @element = element
+          @range = range
+        end
+
+        def maximum
+          range.last
+        end
+
+        def minimum
+          range.first
+        end
+
+        def parse stream
+          matches = false
+          nodes = []
+
+          stream.branch do
+            until nodes.size == maximum
+              node = element.parse stream
+              break unless node
+              nodes << node
+            end
+            matches = true if nodes.size >= minimum
+          end
+
+          AST.repetition *nodes if matches
+        end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/rule/terminal_value.rb

@@ -0,0 +1,32 @@
+module ABNF
+  module Compiler
+    module Rule
+      class TerminalValue
+        include Rule
+
+        attr_reader :case_sensitive
+        attr_reader :string
+
+        def initialize string, case_sensitive = false
+          @string = string
+          @case_sensitive = case_sensitive
+        end
+
+        def parse stream
+          match_data = stream.match regexp
+          return unless match_data
+          AST.leaf match_data.to_s
+        end
+
+        def regexp
+          @regexp ||=
+            begin
+              escaped_string = Regexp.escape string
+              case_insensitive = !case_sensitive
+              Regexp.new escaped_string, case_insensitive, 'n'.freeze
+            end
+        end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/rule/value_range.rb

@@ -0,0 +1,33 @@
+module ABNF
+  module Compiler
+    module Rule
+      class ValueRange
+        include Rule
+
+        attr_reader :start_character
+        attr_reader :end_character
+
+        def initialize start_character, end_character
+          @start_character = start_character
+          @end_character = end_character
+        end
+
+        def parse stream
+          match_data = stream.match regexp
+          return unless match_data
+          AST.leaf match_data.to_s
+        end
+
+        def regexp
+          @regexp ||=
+            begin
+              start_char = Regexp.escape start_character
+              end_char = Regexp.escape end_character
+
+              Regexp.new "[#{start_char}-#{end_char}]", false, 'n'.freeze
+            end
+        end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/rule_list.rb

@@ -0,0 +1,25 @@
+module ABNF
+  module Compiler
+    class RuleList
+      attr_reader :rules
+
+      def initialize
+        @rules = {}
+      end
+
+      def compile abnf
+        stream = Compiler::TextStream(abnf)
+
+        until stream.eof?
+          stream.match Grammar::C_WSP
+          stream.match Grammar::C_NL
+
+          rule = Grammar::Rule.compile stream
+          next unless rule
+
+          rules[rule.name] = rule
+        end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/rule_list/entry.rb

@@ -0,0 +1,21 @@
+module ABNF
+  module Compiler
+    class RuleList
+      class Entry
+        attr_reader :alternative_form
+        attr_reader :name
+        attr_reader :rule
+
+        def initialize name, rule, alternative_form
+          @alternative_form = alternative_form
+          @name = name
+          @rule = rule
+        end
+
+        def alternative_form?
+          alternative_form
+        end
+      end
+    end
+  end
+end

data/lib/abnf/compiler/text_stream.rb

@@ -0,0 +1,67 @@
+module ABNF
+  module Compiler
+    class TextStream
+      attr_reader :stack
+      attr_reader :text
+
+      def initialize text
+        @text = text
+        @stack = [0]
+      end
+
+      def == other_stream
+        return unless other_stream.is_a? self.class
+        text == other_stream.text and stack == other_stream.stack
+      end
+
+      def branch &block
+        next_position = position
+
+        stack << position
+        if block.()
+          next_position = position
+        end
+        stack.pop
+
+        self.position = next_position
+      end
+
+      def eof?
+        position == text.size
+      end
+
+      def match regexp
+        match_data = regexp.match rest
+        return unless match_data
+        return unless match_data.pre_match.empty?
+        self.position += match_data.to_s.size
+        match_data
+      end
+
+      def next_character
+        text[position]
+      end
+
+      def position= new_position
+        stack[-1] = new_position
+      end
+      alias_method :seek, :position=
+
+      def position
+        stack[-1]
+      end
+
+      def rest
+        text[position..-1]
+      end
+    end
+
+    def self.TextStream string_or_stream
+      case string_or_stream
+      when String then TextStream.new string_or_stream
+      when TextStream then string_or_stream
+      else raise TypeError, "Invalid value for TextStream(): #{string_or_stream.inspect}"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: abnf-parser
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+platform: ruby
+authors:
+- Nathan Ladd
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-13 00:00:00.000000000 Z
+dependencies: []
+description: abnf-parser allows you to compile ABNF into rule lists that can be used
+  to parse text.
+email: nathanladd+github@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/abnf/compiler.rb
+- lib/abnf/compiler/ast.rb
+- lib/abnf/compiler/controls.rb
+- lib/abnf/compiler/controls/ast.rb
+- lib/abnf/compiler/controls/grammar.rb
+- lib/abnf/compiler/controls/rules.rb
+- lib/abnf/compiler/controls/text_stream.rb
+- lib/abnf/compiler/errors.rb
+- lib/abnf/compiler/grammar.rb
+- lib/abnf/compiler/grammar/alternative.rb
+- lib/abnf/compiler/grammar/char_val.rb
+- lib/abnf/compiler/grammar/compiler.rb
+- lib/abnf/compiler/grammar/concatenation.rb
+- lib/abnf/compiler/grammar/element.rb
+- lib/abnf/compiler/grammar/num_val.rb
+- lib/abnf/compiler/grammar/prose_val.rb
+- lib/abnf/compiler/grammar/repetition.rb
+- lib/abnf/compiler/grammar/rule.rb
+- lib/abnf/compiler/grammar/rulename.rb
+- lib/abnf/compiler/rule.rb
+- lib/abnf/compiler/rule/alternative.rb
+- lib/abnf/compiler/rule/concatenation.rb
+- lib/abnf/compiler/rule/none.rb
+- lib/abnf/compiler/rule/optional.rb
+- lib/abnf/compiler/rule/reference.rb
+- lib/abnf/compiler/rule/repetition.rb
+- lib/abnf/compiler/rule/terminal_value.rb
+- lib/abnf/compiler/rule/value_range.rb
+- lib/abnf/compiler/rule_list.rb
+- lib/abnf/compiler/rule_list/entry.rb
+- lib/abnf/compiler/text_stream.rb
+homepage: https://github.com/ntl/abnf-parser
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: ABNF Compiler & Parsing Library
+test_files: []