rattler 0.5.0 → 0.6.0

data/features/grammar/character_class.feature

@@ -1,20 +0,0 @@
-Feature: Character Classes
-
-  Character classes are sets of characters between "[" and "]" and mean match
-  any single character in the set. They are identical to character classes in
-  Ruby's regular expressions.
-  
-  Scenario Outline: Parsing
-    Given a grammar with:
-      """
-      word_char <- [A-Za-z_]
-      """
-    When I parse <input>
-    Then the parse result should be <result>
-  
-  Examples:
-    | input | result |
-    | "foo" | "f"    |
-    | "BAR" | "B"    |
-    | "_ba" | "_"    |
-    | "42"  | FAIL   |

data/features/grammar/nonterminal.feature

@@ -1,24 +0,0 @@
-Feature: Nonterminals
-  
-  A nonterminal is an identifier that refers to a parse rule and means to parse
-  according to the rule. Nonterminals can be used to define recursive rules.
-  
-  Scenario: Simple example
-    Given a grammar with:
-      """
-      expr  <-  a* "b"
-      a     <-  "a"
-      """
-    When I parse "aaab"
-    Then the parse result should be [["a", "a", "a"], "b"]
-  
-  Scenario: Recursive definition
-    Given a grammar with:
-      """
-      expr  <-  as "b"
-      as    <-  "a" as
-              / "a"
-      """
-    When I parse "aaab"
-    Then the parse result should be [["a", ["a", "a"]], "b"]
-    

data/features/grammar/one_or_more.feature

@@ -1,34 +0,0 @@
-Feature: One-Or-More
-  
-  The "+" operator following an expression means to match one or more times,
-  i.e. match repeatedly and succeed if input was matched at least once.
-  
-  Scenario Outline: Capturing Expression
-    Given a grammar with:
-      """
-      digits <- DIGIT+
-      """
-    When I parse <input>
-    Then the parse result should be <result>
-      And the parse position should be <pos>
-  
-  Examples:
-    | input | result          | pos |
-    | "5"   | ["5"]           | 1   |
-    | "234" | ["2", "3", "4"] | 3   |
-    | "foo" | FAIL            | 0   |
-  
-  Scenario Outline: Non-Capturing Expression
-    Given a grammar with:
-      """
-      dashes <- ~"-"+
-      """
-    When I parse <input>
-    Then the parse result should be <result>
-      And the parse position should be <pos>
-  
-  Examples:
-    | input | result | pos |
-    | "-"   | true   | 1   |
-    | "---" | true   | 3   |
-    | "foo" | false  | 0   |

data/features/grammar/ordered_choice.feature

@@ -1,21 +0,0 @@
-Feature: Ordered Choice Expressions
-  
-  An ordered choice expression is a series of sub-expressions separated by "/"
-  and it means to try each sub-expression in order until one matches, and fail
-  if none of the sub-expressions match.
-  
-  Scenario Outline: Parsing
-    Given a grammar with:
-      """
-      expr <- "A" / "B"
-      """
-    When I parse <input>
-    Then the parse result should be <result>
-  
-  Examples:
-    | input | result |
-    | "A"   | "A"    |
-    | "AB"  | "A"    |
-    | "B"   | "B"    |
-    | "BA"  | "B"    |
-    | "C"   | FAIL   |

data/features/grammar/posix_class.feature

@@ -1,70 +0,0 @@
-Feature: POSIX Character Classes
-  
-  The uppercase names of POSIX character classes can be used as a shortcut to
-  using them in character class expressions, e.g. "DIGIT" and "[[:digit:]]" are
-  equivalent.
-  
-  The POSIX character classes are:
-    ALNUM - Alphanumeric characters
-    ALPHA - Alphabetic characters
-    ASCII - ASCII characters
-    BLANK - Space and tab
-    CNTRL - Control characters
-    DIGIT - Digits
-    GRAPH - Visible characters
-    LOWER - Lowercase characters
-    PRINT - Visible characters and spaces
-    PUNCT - Punctuation characters
-    SPACE - Whitespace characters
-    UPPER - Uppercase characters
-    XDIGIT - Hexadecimal digits
-    WORD - Alphanumeric characters plus "_"
-  
-  Scenario: ALNUM
-    Given a grammar with:
-      """
-      expr <- ALNUM+
-      """
-    When I parse "abc123"
-    Then the parse result should be ["a", "b", "c", "1", "2", "3"]
-  
-  Scenario: ALPHA
-    Given a grammar with:
-      """
-      expr <- ALPHA+
-      """
-    When I parse "abc123"
-    Then the parse result should be ["a", "b", "c"]
-  
-  Scenario: BLANK
-    Given a grammar with:
-      """
-      expr <- BLANK+
-      """
-    When I parse "   abc"
-    Then the parse result should be [" ", " ", " "]
-  
-  Scenario: DIGIT
-    Given a grammar with:
-      """
-      expr <- DIGIT+
-      """
-    When I parse "123abc"
-    Then the parse result should be ["1", "2", "3"]
-  
-  Scenario: LOWER
-    Given a grammar with:
-      """
-      expr <- LOWER+
-      """
-    When I parse "abcDEF"
-    Then the parse result should be ["a", "b", "c"]
-  
-  Scenario: UPPER
-    Given a grammar with:
-      """
-      expr <- UPPER+
-      """
-    When I parse "ABCdef"
-    Then the parse result should be ["A", "B", "C"]
-    

data/features/grammar/sequence.feature

@@ -1,20 +0,0 @@
-Feature: Sequence Expressions
-  
-  A sequence expression is a series of sub-expressions and it means to match
-  all of the sub-expressions in sequence, otherwise fail and consume no input.
-  
-  Scenario Outline: Parsing
-    Given a grammar with:
-      """
-      expr <- "A" "B"
-      """
-    When I parse <input>
-    Then the parse result should be <result>
-  
-  Examples:
-    | input | result     |
-    | "AB"  | ["A", "B"] |
-    | "ABC" | ["A", "B"] |
-    | "ACB" | FAIL       |
-    | "A"   | FAIL       |
-    | "C"   | FAIL       |

data/features/grammar/zero_or_more.feature

@@ -1,34 +0,0 @@
-Feature: Zero-Or-More
-  
-  The "*" operator following an expression means to match zero or more times,
-  i.e. match repeatedly and succeed even if no input was matched.
-  
-  Scenario Outline: Capturing Expression
-    Given a grammar with:
-      """
-      letters <- ALPHA*
-      """
-    When I parse <input>
-    Then the parse result should be <result>
-      And the parse position should be <pos>
-  
-  Examples:
-    | input | result          | pos |
-    | "A"   | ["A"]           | 1   |
-    | "foo" | ["f", "o", "o"] | 3   |
-    | "234" | []              | 0   |
-  
-  Scenario Outline: Non-Capturing Expression
-    Given a grammar with:
-      """
-      dashes <- ~"-"*
-      """
-    When I parse <input>
-    Then the parse result should be <result>
-      And the parse position should be <pos>
-  
-  Examples:
-    | input | result | pos |
-    | "-"   | true   | 1   |
-    | "---" | true   | 3   |
-    | "foo" | true   | 0   |

data/lib/rattler/back_end.rb

@@ -1,22 +0,0 @@
-#
-# = rattler/back_end.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-require 'rattler'
-
-module Rattler
-  #
-  # The +BackEnd+ module contains the classes used to turn abstract parser
-  # models into concrete ruby code.
-  #
-  # @author Jason Arhart
-  #
-  module BackEnd
-    autoload :Compiler, 'rattler/back_end/compiler'
-    autoload :ParserGenerator, 'rattler/back_end/parser_generator'
-    autoload :RubyGenerator, 'rattler/back_end/ruby_generator'
-    autoload :Optimizer, 'rattler/back_end/optimizer'
-  end
-end

data/lib/rattler/back_end/compiler.rb

@@ -1,128 +0,0 @@
-#
-# = rattler/back_end/compiler.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-require 'rattler/back_end'
-
-module Rattler::BackEnd
-  #
-  # The +Compiler+ compiles parser models into parser classes and methods.
-  #
-  # @author Jason Arhart
-  #
-  class Compiler
-
-    include Rattler::Grammar
-    include Rattler::Parsers
-
-    # Compile rules or grammar source into a new parser subclass of +base+.
-    #
-    # @overload compile_parser(base, rules)
-    #   Compile +rules+ into a new parser subclass of +base+.
-    #   @param [Class] base the base class for the new parser class
-    #   @param [Rattler::Parser::RuleSet] rules the rules to compile
-    #   @return [Class] a new parser class
-    #
-    # @overload compile_parser(base, rule)
-    #   Compile +rule+ into a new parser subclass of +base+.
-    #   @param [Class] base the base class for the new parser class
-    #   @param [Rattler::Parser::Rule] rule the rule to compile
-    #   @return [Class] a new parser class
-    #
-    # @overload compile_parser(base, grammar)
-    #   Compile +grammar+ into a new parser subclass of +base+.
-    #   @param [Class] base the base class for the new parser class
-    #   @param [String] grammar the grammar source to compile
-    #   @return [Class] a new parser class
-    #
-    def self.compile_parser(base, rules_or_grammar)
-      parser_class = Class.new(base)
-      compile(parser_class, rules_or_grammar)
-    end
-
-    # Compile rules or grammar source into match methods in the module +mod+.
-    def self.compile(mod, rules_or_grammar)
-      self.new(mod).compile(rules_or_grammar)
-    end
-
-    # Compile +rules+ into match methods in the module +mod+.
-    def self.compile_rules(mod, rules)
-      self.new(mod).compile_rules(rules)
-    end
-
-    # Compile grammar +source+ into a match method in the module +mod+.
-    def compile_grammar(mod, source)
-      self.new(mod).compiler_grammar(source)
-    end
-
-    # Create a new compiler that compiles rules into match methods in the
-    # given module.
-    def initialize(mod)
-      @mod = mod
-    end
-
-    # Compile the rules or grammar source into match methods in the module.
-    #
-    # @overload compile(rules)
-    #   Compile +rules+ into match methods in the module.
-    #   @param [Rattler::Parser::RuleSet] rules the rules to compile
-    #   @return [Module] the module
-    #
-    # @overload compile(rule)
-    #   Compile +rule+ into match methods in the module.
-    #   @param [Rattler::Parser::Rule] rule the rule to compile
-    #   @return [Module] the module
-    #
-    # @overload compile(grammar)
-    #   Compile +grammar+ into match methods in the module.
-    #   @param [String] grammar the grammar source to compile
-    #   @return [Module] the module
-    #
-    def compile(_)
-      case _
-      when Grammar, RuleSet, Rule then compile_rules(_)
-      else compile_grammar(_.to_s)
-      end
-    end
-
-    # Compile +rules+ into match methods in the module.
-    #
-    # @overload compile_rules(rules)
-    #   Compile +rules+ into match methods in the module.
-    #   @param [Rattler::Parser::RuleSet] rules the rules to compile
-    #   @return [Module] the module
-    #
-    # @overload compile_rules(rule)
-    #   Compile +rule+ into match methods in the module.
-    #   @param [Rattler::Parser::Rule] rule the rule to compile
-    #   @return [Module] the module
-    #
-    def compile_rules(rules)
-      compile_model(rules)
-    end
-
-    # Compile +grammar+ into match methods in the module.
-    # @param [String] grammar the grammar source to compile
-    # @return [Module] the module
-    def compile_grammar(source)
-      result = Rattler::Grammar.parse!(source)
-      compile_model(result.rules)
-    end
-
-    private
-
-    def assert_kind_of(kinds, model) #:nodoc:
-      unless kinds.any? {|kind| model.kind_of?(kind) }
-        raise TypeError, "Expected #{model.inspect} to be a kind of #{klass}", caller
-      end
-    end
-
-    def compile_model(model) #:nodoc:
-      @mod.module_eval ParserGenerator.code_for(model)
-      @mod
-    end
-
-  end
-end

data/lib/rattler/back_end/optimizer.rb

@@ -1,101 +0,0 @@
-#
-# = rattler/back_end/optimizer.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-require 'rattler'
-
-module Rattler::BackEnd
-  #
-  # The +Optimizer+ transforms parser models into equivalent models that can
-  # result in more efficient parsing code. This is primarily achieved by
-  # converting regular expressions into equivalent Regexp patterns, thus
-  # reducing object instantiation and method dispatch and having StringScanner
-  # do as much of the parsing work as possible.
-  #
-  # @author Jason Arhart
-  #
-  module Optimizer
-
-    class << self
-      def optimizations
-        @optimizations ||=
-          OptimizeChildren >>
-          InlineRegularRules >>
-          SimplifyRedundantRepeat >>
-          RemoveMeaninglessWrapper >>
-          SimplifyTokenMatch >>
-          FlattenSequence >>
-          FlattenChoice >>
-          ReduceRepeatMatch >>
-          JoinPredicateMatch >>
-          JoinPredicateOrMatch >>
-          JoinMatchSequence >>
-          JoinMatchChoice
-      end
-
-      def optimize(model, opts={})
-        case model
-        when ::Rattler::Grammar::Grammar then optimize_grammar model, opts
-        when ::Rattler::Parsers::RuleSet then optimize_rule_set model, opts
-        when ::Rattler::Parsers::Rule then optimize_rule model, default_context(opts)
-        else optimize_expr model, default_context(opts)
-        end
-      end
-
-      private
-
-      def default_context(opts)
-        OptimizationContext[opts.merge :type => :capturing]
-      end
-
-      def optimize_grammar(grammar, opts)
-        grammar.with_rules optimize_rule_set(grammar.rules, opts)
-      end
-
-      def optimize_rule_set(rule_set, opts)
-        context = default_context(opts).with(:rules => rule_set)
-        rule_set = rule_set.map_rules {|_| optimize_rule _, context }
-        context = context.with(:rules => rule_set)
-        rule_set.select_rules {|_| context.relavent? _ }
-      end
-
-      def optimize_rule(rule, context)
-        rule.with_expr optimizations.apply(rule.expr, context)
-      end
-
-      def optimize_expr(expr, context)
-        optimizations.apply rule.expr, context
-      end
-
-    end
-
-    autoload :OptimizationContext, 'rattler/back_end/optimizer/optimization_context'
-    autoload :Optimization, 'rattler/back_end/optimizer/optimization'
-    autoload :OptimizationSequence, 'rattler/back_end/optimizer/optimization_sequence'
-    autoload :OptimizeChildren, 'rattler/back_end/optimizer/optimize_children'
-    autoload :InlineRegularRules, 'rattler/back_end/optimizer/inline_regular_rules'
-    autoload :SpecializeRepeat, 'rattler/back_end/optimizer/specialize_repeat'
-    autoload :SimplifyRedundantRepeat, 'rattler/back_end/optimizer/simplify_redundant_repeat'
-    autoload :RemoveMeaninglessWrapper, 'rattler/back_end/optimizer/remove_meaningless_wrapper'
-    autoload :SimplifyTokenMatch, 'rattler/back_end/optimizer/simplify_token_match'
-    autoload :FlattenSequence, 'rattler/back_end/optimizer/flatten_sequence'
-    autoload :FlattenChoice, 'rattler/back_end/optimizer/flatten_choice'
-    autoload :ReduceRepeatMatch, 'rattler/back_end/optimizer/reduce_repeat_match'
-    autoload :JoinPredicateMatch, 'rattler/back_end/optimizer/join_predicate_match'
-    autoload :JoinPredicateBareMatch, 'rattler/back_end/optimizer/join_predicate_bare_match'
-    autoload :JoinPredicateNestedMatch, 'rattler/back_end/optimizer/join_predicate_nested_match'
-    autoload :JoinPredicateOrMatch, 'rattler/back_end/optimizer/join_predicate_or_match'
-    autoload :JoinPredicateOrBareMatch, 'rattler/back_end/optimizer/join_predicate_or_bare_match'
-    autoload :JoinPredicateOrNestedMatch, 'rattler/back_end/optimizer/join_predicate_or_nested_match'
-    autoload :JoinMatchSequence, 'rattler/back_end/optimizer/join_match_sequence'
-    autoload :JoinMatchCapturingSequence, 'rattler/back_end/optimizer/join_match_capturing_sequence'
-    autoload :JoinMatchMatchingSequence, 'rattler/back_end/optimizer/join_match_matching_sequence'
-    autoload :JoinMatchChoice, 'rattler/back_end/optimizer/join_match_choice'
-    autoload :MatchJoining, 'rattler/back_end/optimizer/match_joining'
-    autoload :Flattening, 'rattler/back_end/optimizer/flattening'
-    autoload :CompositeReducing, 'rattler/back_end/optimizer/composite_reducing'
-
-  end
-end