walrat 0.1

data/lib/walrat/parslet_repetition_default.rb

@@ -0,0 +1,77 @@
+# Copyright 2007-2010 Wincent Colaiuta. All rights reserved.
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+require 'walrat'
+
+module Walrat
+  # ParsletRepetitionDefault is a subclass that modifies the behaviour of its
+  # parent, ParsletRepetition, in a very small way. Namely, if the outcome of
+  # parsing is a ZeroWidthParse success then it is caught and the default value
+  # (defined at initialization time) is returned instead.
+  class ParsletRepetitionDefault < ParsletRepetition
+    # Possible re-factoring to consider for the future: roll the functionality
+    # of this class in to ParsletRepetition itself.
+    # Benefit of keeping it separate is that the ParsletRepetition itself is
+    # kept simple.
+    def initialize parseable, min, max = nil, default = nil
+      super parseable, min, max
+      self.default  = default
+    end
+
+    def parse string, options = {}
+      catch :ZeroWidthParseSuccess do
+        return super string, options
+      end
+      @default.clone rescue @default
+    end
+
+    def eql?(other)
+      other.instance_of? ParsletRepetitionDefault and
+        @min == other.min and
+        @max == other.max and
+        @parseable.eql? other.parseable and
+        @default == other.default
+    end
+
+  protected
+
+    # For determining equality.
+    attr_reader :default
+
+  private
+
+    def hash_offset
+      69
+    end
+
+    def update_hash
+      # let super calculate its share of the hash first
+      @hash = super + @default.hash
+    end
+
+    def default=(default)
+      @default = (default.clone rescue default)
+      @default.extend LocationTracking
+      update_hash
+    end
+  end # class ParsletRepetitionDefault
+end # module Walrat

data/lib/walrat/parslet_sequence.rb

@@ -0,0 +1,241 @@
+# Copyright 2007-2010 Wincent Colaiuta. All rights reserved.
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+require 'walrat'
+
+module Walrat
+  class ParsletSequence < ParsletCombination
+    attr_reader :hash
+
+    # first and second may not be nil.
+    def initialize first, second, *others
+      raise ArgumentError if first.nil?
+      raise ArgumentError if second.nil?
+      @components = [first, second] + others
+      update_hash
+    end
+
+    # Override so that sequences are appended to an existing sequence:
+    # Consider the following example:
+    #
+    #     A & B
+    #
+    # This constitutes a single sequence:
+    #
+    #     (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 produces unwanted
+    # nesting in the results because instead of returning a one-dimensional
+    # array of results:
+    #
+    #     [a, b, c]
+    #
+    # It returns a nested array:
+    #
+    #     [[a, b], c]
+    #
+    # The solution to this unwanted nesting is to allowing appending to an
+    # existing sequence by using the private "append" method.
+    #
+    # This ensures that:
+    #
+    #     A & B & C
+    #
+    # Translates to a single sequence:
+    #
+    #     (A & B & C)
+    #
+    # And a single, uni-dimensional results array:
+    #
+    #     [a, b, c]
+    def &(next_parslet)
+      append next_parslet
+    end
+
+    SKIP_FIRST  = true
+    NO_SKIP     = false
+
+    def parse string, options = {}
+      parse_common NO_SKIP, string, options
+    end
+
+    def parse_remainder string, options = {}
+      parse_common SKIP_FIRST, string, options
+    end
+
+    def parse_common skip_first, 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
+      left_recursion  = false # keep track of whether left recursion was detected
+
+      @components.each_with_index do |parseable, index|
+        if index == 0 # for first component only
+          if skip_first
+            next
+          end
+          begin
+            check_left_recursion(parseable, options)
+          rescue LeftRecursionException => e
+            left_recursion  = true
+            continuation    = nil
+            value           = callcc { |c| continuation = c }
+            if value == continuation        # first time that we're here
+              e.continuation = continuation # pack continuation into exception
+              raise e                       # and propagate
+            else
+              grammar   = state.options[:grammar]
+              rule_name = state.options[:rule_name]
+              state.parsed grammar.wrap(value, rule_name)
+              next
+            end
+          end
+        end
+
+        catch :ProcessNextComponent do
+          catch :NotPredicateSuccess do
+            catch :AndPredicateSuccess do
+              catch :ZeroWidthParseSuccess do
+                begin
+                  parsed = parseable.memoizing_parse state.remainder, state.options
+                  state.parsed parsed
+                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
+                    # guard against self references (possible infinite recursion) here?
+                    parsed = skipping_parslet.memoizing_parse state.remainder, state.options
+                    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
+
+                # can't use "next" here because it would only break out of
+                # innermost "do" rather than continuing the iteration
+                throw :ProcessNextComponent
+              end
+              last_caught = :ZeroWidthParseSuccess
+              throw :ProcessNextComponent
+            end
+            last_caught = :AndPredicateSuccess
+            throw :ProcessNextComponent
+          end
+          last_caught = :NotPredicateSuccess
+        end
+      end
+
+      if left_recursion
+        results = recurse(state)
+      else
+        results = state.results
+      end
+
+      return results if skip_first
+
+      if results.respond_to? :empty? and results.empty? and last_caught
+        throw last_caught
+      else
+        results
+      end
+    end
+
+    # Left-recursion helper
+    def recurse state
+      return state.results if state.remainder == '' # further recursion is not possible
+      new_state = ParserState.new state.remainder, state.options
+      last_successful_result = nil
+      while state.remainder != ''
+        begin
+          new_results = parse_remainder new_state.remainder, new_state.options
+          new_state.parsed new_results
+          last_successful_result = ArrayResult[last_successful_result || state.results, new_results]
+        rescue ParseError
+          break
+        end
+      end
+      last_successful_result || state.results
+    end
+
+    def eql?(other)
+      return false if not other.instance_of? ParsletSequence
+      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
+
+  protected
+
+    # For determining equality.
+    attr_reader :components
+
+  private
+
+    def hash_offset
+      40
+    end
+
+    def update_hash
+      # fixed offset to avoid unwanted collisions with similar classes
+      @hash = hash_offset
+      @components.each { |parseable| @hash += parseable.hash }
+    end
+
+    # Appends another Parslet, ParsletCombination or Predicate to the receiver
+    # and returns the receiver.
+    #
+    # Raises if next_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?
+      @components << next_parslet.to_parseable
+      update_hash
+      self
+    end
+  end # class ParsletSequence
+end # module Walrat

data/lib/walrat/predicate.rb

@@ -0,0 +1,68 @@
+# Copyright 2007-2010 Wincent Colaiuta. All rights reserved.
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+require 'walrat'
+
+module Walrat
+  # Predicates parse input without consuming it.
+  # On success they throw a subclass-specific symbol (see the AndPredicate and
+  # NotPredicate classes).
+  # On failure they raise a ParseError.
+  class Predicate
+    include Walrat::ParsletCombining
+    include Walrat::Memoizing
+
+    attr_reader :hash
+
+    # Raises if parseable is nil.
+    def initialize parseable
+      raise ArgumentError, 'nil parseable' if parseable.nil?
+      @parseable = parseable
+
+      # fixed offset to avoid collisions with @parseable objects
+      @hash = @parseable.hash + hash_offset
+    end
+
+    def to_parseable
+      self
+    end
+
+    def parse string, options = {}
+      raise NotImplementedError # subclass responsibility
+    end
+
+    def eql? other
+      other.instance_of? self.class and other.parseable.eql? @parseable
+    end
+
+  protected
+
+    # for equality comparisons
+    attr_reader :parseable
+
+  private
+
+    def hash_offset
+      10
+    end
+  end
+end # module Walrat

data/lib/walrat/proc_parslet.rb

@@ -0,0 +1,60 @@
+# Copyright 2007-2010 Wincent Colaiuta. All rights reserved.
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+require 'walrat'
+
+module Walrat
+  class ProcParslet < Parslet
+    attr_reader :hash
+
+    def initialize proc
+      raise ArgumentError, 'nil proc' if proc.nil?
+      self.expected_proc = proc
+    end
+
+    def parse string, options = {}
+      raise ArgumentError, 'nil string' if string.nil?
+      @expected_proc.call string, options
+    end
+
+    def eql?(other)
+      other.instance_of? ProcParslet and other.expected_proc == @expected_proc
+    end
+
+  protected
+
+    # For equality comparisons.
+    attr_reader :expected_proc
+
+  private
+
+    def expected_proc=(proc)
+      @expected_proc = (proc.clone rescue proc)
+      update_hash
+    end
+
+    def update_hash
+      # fixed offset to avoid collisions with @parseable objects
+      @hash = @expected_proc.hash + 105
+    end
+  end # class ProcParslet
+end # module Walrat

data/lib/walrat/regexp_parslet.rb

@@ -0,0 +1,84 @@
+# Copyright 2007-2010 Wincent Colaiuta. All rights reserved.
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+require 'walrat'
+
+module Walrat
+  class RegexpParslet < Parslet
+    attr_reader :hash
+
+    def initialize regexp
+      raise ArgumentError, 'nil regexp' if regexp.nil?
+      self.expected_regexp = /\A#{regexp}/ # for efficiency, anchor all regexps
+    end
+
+    def parse string, options = {}
+      raise ArgumentError, 'nil string' if string.nil?
+      if string =~ @expected_regexp
+        wrapper = MatchDataWrapper.new $~
+        match   = $~[0]
+
+        if (line_count = match.scan(/\r\n|\r|\n/).length) != 0        # count number of newlines in match
+          column_end    = match.jlength - match.jrindex(/\r|\n/) - 1  # calculate characters on last line
+        else                                                          # no newlines in match
+          column_end    = match.jlength + (options[:column_start] || 0)
+        end
+
+        wrapper.start       = [options[:line_start], options[:column_start]]
+        wrapper.end         = [wrapper.line_start + line_count, column_end]
+        wrapper.source_text = match.to_s.clone
+        wrapper
+      else
+        raise ParseError.new('non-matching characters "%s" while parsing regular expression "%s"' % [string, @expected_regexp.inspect],
+                             :line_end    => (options[:line_start] || 0),
+                             :column_end  => (options[:column_start] || 0))
+      end
+    end
+
+    def eql?(other)
+      other.instance_of? RegexpParslet and
+        other.expected_regexp == @expected_regexp
+    end
+
+    def inspect
+      '#<%s:0x%x @expected_regexp=%s>' %
+        [self.class.to_s, self.object_id, @expected_regexp.inspect]
+    end
+
+  protected
+
+    # For equality comparisons.
+    attr_reader :expected_regexp
+
+  private
+
+    def expected_regexp=(regexp)
+      @expected_regexp = (regexp.clone rescue regexp)
+      update_hash
+    end
+
+    def update_hash
+      # fixed offset to avoid collisions with @parseable objects
+      @hash = @expected_regexp.hash + 15
+    end
+  end # class RegexpParslet
+end # module Walrat