abnf-parser 0.8.1 → 0.9.0

metadata

@@ -1,53 +1,52 @@
 --- !ruby/object:Gem::Specification
 name: abnf-parser
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.9.0
 platform: ruby
 authors:
 - Nathan Ladd
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-13 00:00:00.000000000 Z
+date: 2015-12-19 00:00:00.000000000 Z
 dependencies: []
-description: abnf-parser allows you to compile ABNF into rule lists that can be used
-  to parse text.
+description: abnf-parser allows you to compile ABNF (Augmented Backus-Naur Form) into
+  rule lists that can be used to efficiently parse text conforming to ABNF grammar.
 email: nathanladd+github@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/abnf/parser.rb
-- lib/abnf/parser/ast.rb
+- lib/abnf/parser/common.rb
 - lib/abnf/parser/compiler.rb
+- lib/abnf/parser/compiler/alternation.rb
+- lib/abnf/parser/compiler/concatenation.rb
+- lib/abnf/parser/compiler/element.rb
+- lib/abnf/parser/compiler/group.rb
+- lib/abnf/parser/compiler/option.rb
+- lib/abnf/parser/compiler/repetition.rb
+- lib/abnf/parser/compiler/rule_builder.rb
+- lib/abnf/parser/compiler/rule_list.rb
+- lib/abnf/parser/compiler/token.rb
+- lib/abnf/parser/compiler/tokenizer.rb
 - lib/abnf/parser/controls.rb
-- lib/abnf/parser/controls/ast.rb
-- lib/abnf/parser/controls/grammar.rb
+- lib/abnf/parser/controls/abnf.rb
+- lib/abnf/parser/controls/compiler/tokens.rb
+- lib/abnf/parser/controls/nodes.rb
+- lib/abnf/parser/controls/rule_lists.rb
+- lib/abnf/parser/controls/rule_lists/multiples_of_three.rb
 - lib/abnf/parser/controls/rules.rb
-- lib/abnf/parser/controls/text_stream.rb
-- lib/abnf/parser/errors.rb
-- lib/abnf/parser/grammar.rb
-- lib/abnf/parser/grammar/alternative.rb
-- lib/abnf/parser/grammar/char_val.rb
-- lib/abnf/parser/grammar/concatenation.rb
-- lib/abnf/parser/grammar/element.rb
-- lib/abnf/parser/grammar/num_val.rb
-- lib/abnf/parser/grammar/prose_val.rb
-- lib/abnf/parser/grammar/repetition.rb
-- lib/abnf/parser/grammar/rule.rb
-- lib/abnf/parser/grammar/rulename.rb
-- lib/abnf/parser/rule.rb
-- lib/abnf/parser/rule/alternative.rb
-- lib/abnf/parser/rule/concatenation.rb
-- lib/abnf/parser/rule/none.rb
-- lib/abnf/parser/rule/optional.rb
-- lib/abnf/parser/rule/reference.rb
-- lib/abnf/parser/rule/repetition.rb
-- lib/abnf/parser/rule/terminal_value.rb
-- lib/abnf/parser/rule/value_range.rb
+- lib/abnf/parser/error.rb
+- lib/abnf/parser/node.rb
 - lib/abnf/parser/rule_list.rb
-- lib/abnf/parser/rule_list/entry.rb
-- lib/abnf/parser/text_stream.rb
+- lib/abnf/parser/rules/alternation.rb
+- lib/abnf/parser/rules/concatenation.rb
+- lib/abnf/parser/rules/prose_val.rb
+- lib/abnf/parser/rules/reference.rb
+- lib/abnf/parser/rules/regexp_pattern.rb
+- lib/abnf/parser/rules/repetition.rb
+- lib/abnf/parser/rules/terminal.rb
 homepage: https://github.com/ntl/abnf-parser
 licenses:
 - MIT
@@ -71,5 +70,6 @@ rubyforge_project:
 rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
-summary: ABNF Compiler & Parsing Library
+summary: ABNF (Augmented Backus-Naur Form) Parsing Library
 test_files: []
+has_rdoc: 

data/lib/abnf/parser/ast.rb

@@ -1,67 +0,0 @@
-module ABNF
-  module Parser
-    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/parser/controls/ast.rb

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

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

@@ -1,32 +0,0 @@
-module ABNF
-  module Parser
-    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', Parser::Grammar::Alternative
-        CharVal = Example.new '"some-string"', Parser::Grammar::CharVal
-        Concatenation = Example.new '"some-string" " " "some-string"', Parser::Grammar::Concatenation
-        Group = Example.new '( "foo" / "bar" )', Parser::Grammar::Element
-        NumVal = Example.new '%x41.42.43', Parser::Grammar::NumVal
-        Option = Example.new '[ "some-string" ]', Parser::Grammar::Element
-        Repetition = Example.new '1*2"some-element"', Parser::Grammar::Repetition
-        Rulename = Example.new 'some-rule', Parser::Grammar::Rulename
-        Rule = Example.new "some-rule = \"some-string\"\r\n", Parser::Grammar::Rule
-        ProseVal = Example.new '<Some Prose>', Parser::Grammar::ProseVal
-      end
-    end
-  end
-end

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

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

data/lib/abnf/parser/grammar.rb

@@ -1,17 +0,0 @@
-module ABNF
-  module Parser
-    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/parser/grammar/alternative.rb

@@ -1,27 +0,0 @@
-module ABNF
-  module Parser
-    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
-
-          Parser::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/parser/grammar/char_val.rb

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

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

@@ -1,21 +0,0 @@
-module ABNF
-  module Parser
-    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
-
-          Parser::Rule::Concatenation.new *repetitions
-        end
-      end
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-module ABNF
-  module Parser
-    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 = Parser::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/parser/grammar/num_val.rb

@@ -1,72 +0,0 @@
-module ABNF
-  module Parser
-    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 Parser::Rule::ValueRange.new first_octet, last_octet
-          end
-
-          Parser::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