walrus 0.2 → 0.3

data/lib/walrus/grammar/parslet.rb

@@ -1,34 +0,0 @@
-# Copyright 2007 Wincent Colaiuta
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-require 'walrus'
-
-module Walrus
-  class Grammar
-    class Parslet
-      
-      include Walrus::Grammar::ParsletCombining
-      include Walrus::Grammar::Memoizing
-      
-      def to_parseable
-        self
-      end
-      
-      def parse(string, options = {})
-        raise NotImplementedError # subclass responsibility
-      end
-      
-    end # class Parslet
-  end # class Grammar
-end # module Walrus

data/lib/walrus/grammar/parslet_choice.rb

@@ -1,128 +0,0 @@
-# Copyright 2007 Wincent Colaiuta
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-require 'walrus'
-
-module Walrus
-  class Grammar
-    
-    class ParsletChoice < ParsletCombination
-      
-      attr_reader :hash
-      
-      # Either parameter may be a Parslet or a ParsletCombination.
-      # Neither parmeter may be nil.
-      def initialize(left, right, *others)
-        raise ArgumentError if left.nil?
-        raise ArgumentError if right.nil?
-        @alternatives = [left, right] + others
-        update_hash
-      end
-      
-      # Override so that alternatives are appended to an existing sequence:
-      # Consider the following example:
-      #     A | B
-      # This constitutes a single choice:
-      #     (A | B)
-      # If we then make this a three-element sequence:
-      #     A | B | C
-      # We are effectively creating an nested sequence containing the original sequence and an additional element:
-      #     ((A | B) | C)
-      # Although such a nested sequence is correctly parsed it is not as architecturally clean as a single sequence without nesting:
-      #     (A | B | C)
-      # This method allows us to use the architecturally cleaner format.
-      #
-      def |(next_parslet)
-        append(next_parslet)
-      end
-      
-      # First tries to parse the left option, falling back and trying the right option and then the any subsequent options in the others instance variable on failure. If no options successfully complete parsing then an ParseError is raised. Any zero-width parse successes thrown by alternative parsers will flow on to a higher level.
-      def parse(string, options = {})
-        raise ArgumentError if string.nil?
-        error           = nil # for error reporting purposes will track which parseable gets farthest to the right before failing
-        left_recursion  = nil # will also track any left recursion that we detect
-        @alternatives.each do |parseable|
-          begin
-            result = parseable.memoizing_parse(string, options) # successful parse
-            if left_recursion and left_recursion.continuation   # and we have a continuation
-              continuation = left_recursion.continuation        # continuations are once-only, one-way tickets
-              left_recursion = nil                              # set this to nil so as not to call it again without meaning to
-              continuation.call(result)                         # so jump back to where we were before
-            end
-            return result
-          rescue LeftRecursionException => e
-            left_recursion = e
-            
-            # TODO:
-            # it's not enough to just catch this kind of exception and remember the last one
-            # may need to accumulate these in an array
-            # consider the example rule:
-            #   :a, :a & :b | :a & :c | :a & :d | :b
-            # the first option will raise a LeftRecursionException
-            # the next option will raise for the same reason
-            # the third likewise
-            # finally we get to the fourth option, the first which might succeed
-            # at that point we should have three continuations
-            # we should try the first, falling back to the second and third if necessary
-            # on successfully retrying, need to start all over again and try all the options again, just in case further recursion is possible
-            # so it is quite complicated
-            # the question is, is it more complicated than the other ways of getting right-associativity into Walrus-generated parsers?
-            
-          rescue ParseError => e
-            if error.nil?
-              error = e
-            else
-              error = e unless error.rightmost?(e)
-            end
-          end
-        end
-        raise ParseError.new('no valid alternatives while parsing "%s" (%s)' % [string, error.to_s],
-                             :line_end => error.line_end, :column_end => error.column_end)                  # should generally report the rightmost error
-      end
-      
-      def eql?(other)
-        return false if not other.instance_of? ParsletChoice
-        other_alternatives = other.alternatives
-        return false if @alternatives.length != other_alternatives.length
-        for i in 0..(@alternatives.length - 1)
-          return false unless @alternatives[i].eql? other_alternatives[i]
-        end
-        true
-      end
-      
-    protected
-      
-      # For determining equality.
-      attr_reader :alternatives
-      
-    private
-      
-      def update_hash
-        @hash = 30 # fixed offset to avoid unwanted collisions with similar classes
-        @alternatives.each { |parseable| @hash += parseable.hash }
-      end
-      
-      # Appends another Parslet (or ParsletCombination) to the receiver and returns the receiver.
-      # Raises if parslet is nil.
-      # Cannot use << as a method name because Ruby cannot parse it without the self, and self is not allowed as en explicit receiver for private messages.
-      def append(next_parslet)
-        raise ArgumentError if next_parslet.nil?
-        @alternatives << next_parslet.to_parseable
-        update_hash
-        self
-      end
-      
-    end # class ParsletChoice
-  end # class Grammar
-end # module Walrus

data/lib/walrus/grammar/parslet_combination.rb

@@ -1,32 +0,0 @@
-# Copyright 2007 Wincent Colaiuta
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-require 'walrus'
-
-module Walrus
-  class Grammar
-    
-    class ParsletCombination
-      
-      include Walrus::Grammar::ParsletCombining
-      include Walrus::Grammar::Memoizing
-      
-      def to_parseable
-        self
-      end
-      
-    end # module ParsletCombination
-    
-  end # class Grammar
-end # module Walrus

data/lib/walrus/grammar/parslet_combining.rb

@@ -1,160 +0,0 @@
-# Copyright 2007 Wincent Colaiuta
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-require 'walrus'
-
-module Walrus
-  class Grammar
-    
-    # The ParsletCombining module, together with the ParsletCombination class and its subclasses, provides simple container classes for encapsulating relationships among Parslets. By storing this information outside of the Parslet objects themselves their design is kept clean and they can become immutable objects which are much more easily copied and shared among multiple rules in a Grammar.
-    module ParsletCombining
-      
-      # Convenience method.
-      def memoizing_parse(string, options = {})
-        self.to_parseable.memoizing_parse(string, options)
-      end
-      
-      # Convenience method.
-      def parse(string, options = {})
-        self.to_parseable.parse(string, options)
-      end
-      
-      # Defines a sequence of Parslets (or ParsletCombinations).
-      # Returns a ParsletSequence instance.
-      def sequence(first, second, *others)
-        Walrus::Grammar::ParsletSequence.new(first.to_parseable, second.to_parseable, *others)
-      end
-      
-      # Shorthand for ParsletCombining.sequence(first, second).
-      def &(next_parslet)
-        self.sequence(self, next_parslet)
-      end
-      
-      # Defines a sequence of Parslets similar to the sequence method but with the difference that the contents of array results from the component parslets will be merged into a single array rather than being added as arrays. To illustrate:
-      #
-      #   'foo' & 'bar'.one_or_more   # returns results like ['foo', ['bar', 'bar', 'bar']]
-      #   'foo' >> 'bar'.one_or_more  # returns results like ['foo', 'bar', 'bar', 'bar']
-      #
-      def merge(first, second, *others)
-        Walrus::Grammar::ParsletMerge.new(first.to_parseable, second.to_parseable, *others)
-      end
-      
-      # Shorthand for ParsletCombining.sequence(first, second)
-      def >>(next_parslet)
-        self.merge(self, next_parslet)
-      end
-      
-      # Defines a choice of Parslets (or ParsletCombinations).
-      # Returns a ParsletChoice instance.
-      def choice(left, right, *others)
-        Walrus::Grammar::ParsletChoice.new(left.to_parseable, right.to_parseable, *others)
-      end
-      
-      # Shorthand for ParsletCombining.choice(left, right)
-      def |(alternative_parslet)
-        self.choice(self, alternative_parslet)
-      end
-      
-      # Defines a repetition of the supplied Parslet (or ParsletCombination).
-      # Returns a ParsletRepetition instance.
-      def repetition(parslet, min, max)
-        Walrus::Grammar::ParsletRepetition.new(parslet.to_parseable, min, max)
-      end
-      
-      # Shorthand for ParsletCombining.repetition.
-      def repeat(min = nil, max = nil)
-        self.repetition(self, min, max)
-      end
-      
-      def repetition_with_default(parslet, min, max, default)
-        Walrus::Grammar::ParsletRepetitionDefault.new(parslet.to_parseable, min, max, default)
-      end
-      
-      def repeat_with_default(min = nil, max = nil, default = nil)
-        self.repetition_with_default(self, min, max, default)
-      end
-      
-      # Shorthand for ParsletCombining.repetition(0, 1).
-      # This method optionally takes a single parameter specifying what object should be returned as a placeholder when there are no matches; this is useful for packing into ASTs where it may be better to parse an empty Array rather than nil. The specified object is cloned and returned in the event that there are no matches. As a convenience, the specified object is automatically extended using the LocationTracking module (this is a convenience so that you can specify empty Arrays, "[]", rather than explicitly passing an "ArrayResult.new")
-      def optional(default_return_value = NoParameterMarker.instance)
-        if default_return_value == NoParameterMarker.instance
-          self.repeat(0, 1) # default behaviour
-        else
-          self.repeat_with_default(0, 1, default_return_value)
-        end
-      end
-      
-      # Alternative to optional.
-      def zero_or_one
-        self.optional
-      end
-      
-      # possible synonym "star"
-      def zero_or_more(default_return_value = NoParameterMarker.instance)
-        if default_return_value == NoParameterMarker.instance
-          self.repeat(0) # default behaviour
-        else
-          self.repeat_with_default(0, nil, default_return_value)
-        end
-      end
-      
-      # possible synonym "plus"
-      def one_or_more
-        self.repeat(1)
-      end
-      
-      # Parsing Expression Grammar support.
-      # Succeeds if parslet succeeds but consumes no input (throws an :AndPredicateSuccess symbol).
-      def and_predicate(parslet)
-        Walrus::Grammar::AndPredicate.new(parslet.to_parseable)
-      end
-      
-      # Shorthand for and_predicate
-      # Strictly speaking, this shorthand breaks with established Ruby practice that "?" at the end of a method name should indicate a method that returns true or false.
-      def and?
-        self.and_predicate(self)
-      end
-      
-      # Parsing Expression Grammar support.
-      # Succeeds if parslet fails (throws a :NotPredicateSuccess symbol).
-      # Fails if parslet succeeds (raise a ParseError).
-      # Consumes no output.
-      # This method will almost invariably be used in conjuntion with the & operator, like this:
-      #       rule :foo, :p1 & :p2.not_predicate
-      #       rule :foo, :p1 & :p2.not!
-      def not_predicate(parslet)
-        Walrus::Grammar::NotPredicate.new(parslet.to_parseable)
-      end
-      
-      # Shorthand for not_predicate.
-      # Strictly speaking, this shorthand breaks with established Ruby practice that "!" at the end of a method name should indicate a destructive behaviour on (mutation of) the receiver.
-      def not!
-        self.not_predicate(self)
-      end
-      
-      # Succeeds if parsing succeeds, consuming the output, but doesn't actually return anything.
-      # This is for elements which are required but which shouldn't appear in the final AST.
-      def omission(parslet)
-        Walrus::Grammar::ParsletOmission.new(parslet.to_parseable)
-      end
-      
-      # Shorthand for ParsletCombining.omission
-      def skip
-        self.omission(self)
-      end
-      
-    end # module ParsletCombining
-    
-  end # class Grammar
-end # module Walrus

data/lib/walrus/grammar/parslet_merge.rb

@@ -1,94 +0,0 @@
-# Copyright 2007 Wincent Colaiuta
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-require 'walrus'
-
-module Walrus
-  class Grammar
-    
-    class ParsletMerge < ParsletSequence
-      
-      def parse(string, options = {})
-        raise ArgumentError if string.nil?
-        state                         = ParserState.new(string, options)
-        last_caught                   = nil # keep track of the last kind of throw to be caught
-        @components.each do |parseable|
-          catch :ProcessNextComponent do
-            catch :NotPredicateSuccess do
-              catch :AndPredicateSuccess do
-                catch :ZeroWidthParseSuccess do
-                  begin
-                    parsed = parseable.memoizing_parse(state.remainder, state.options)
-                    if parsed.respond_to? :each
-                      parsed.each { |element| state.parsed(element) }
-                    else
-                      state.parsed(parsed)
-                    end
-                  rescue SkippedSubstringException => e
-                    state.skipped(e)
-                  # rescue ParseError => e # failed, will try to skip; save original error in case skipping fails                                        
-                  #   if options.has_key?(:skipping_override) : skipping_parslet = options[:skipping_override]
-                  #   elsif options.has_key?(:skipping)       : skipping_parslet = options[:skipping]
-                  #   else                                      skipping_parslet = nil
-                  #   end
-                  #   raise e if skipping_parslet.nil?        # no skipper defined, raise original error
-                  #   begin
-                  #     parsed = skipping_parslet.memoizing_parse(state.remainder, state.options) # guard against self references (possible infinite recursion) here?
-                  #     state.skipped(parsed)
-                  #     redo              # skipping succeeded, try to redo
-                  #   rescue ParseError
-                  #     raise e           # skipping didn't help either, raise original error
-                  #   end
-                  end
-                  last_caught = nil
-                  throw :ProcessNextComponent # can't use "next" here because it will only break out of innermost "do"
-                end
-                last_caught = :ZeroWidthParseSuccess
-                throw :ProcessNextComponent
-              end
-              last_caught = :AndPredicateSuccess
-              throw :ProcessNextComponent
-            end
-            last_caught = :NotPredicateSuccess
-          end
-        end
-        
-        if state.results.respond_to? :empty? and state.results.empty? and
-         throw last_caught
-        else
-          state.results
-        end
-        
-      end
-      
-      def eql?(other)
-        return false if not other.instance_of? ParsletMerge
-        other_components = other.components
-        return false if @components.length != other_components.length
-        for i in 0..(@components.length - 1)
-          return false unless @components[i].eql? other_components[i]
-        end
-        true
-      end
-      
-    private
-      
-      def hash_offset
-        53
-      end
-      
-    end # class ParsletMerge
-  end # class Grammar
-end # module Walrus
-