walrus 0.2 → 0.3

data/lib/walrus/grammar/predicate.rb

@@ -1,63 +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
-    
-    # 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 Walrus::Grammar::ParsletCombining
-      include Walrus::Grammar::Memoizing
-      
-      attr_reader :hash
-      
-      # Raises if parseable is nil.
-      def initialize(parseable)
-        raise ArgumentError if parseable.nil?
-        @parseable = parseable
-        @hash = @parseable.hash + hash_offset # fixed offset to avoid collisions with @parseable objects
-      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 # class Grammar
-end # module Walrus

data/lib/walrus/grammar/proc_parslet.rb

@@ -1,58 +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 ProcParslet < Parslet
-      
-      attr_reader :hash
-      
-      def initialize(proc)
-        raise ArgumentError if proc.nil?
-        self.expected_proc = proc
-      end
-      
-      def parse(string, options = {})
-        raise ArgumentError 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
-        @hash = @expected_proc.hash + 105 # fixed offset to avoid collisions with @parseable objects
-      end
-      
-    end # class ProcParslet
-    
-  end # class Grammar
-end # module Walrus
-

data/lib/walrus/grammar/regexp_parslet.rb

@@ -1,79 +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 RegexpParslet < Parslet
-      
-      attr_reader :hash
-      
-      def initialize(regexp)
-        raise ArgumentError if regexp.nil?
-        self.expected_regexp = /\A#{regexp}/ # for efficiency, anchor all regexps to the start of the string
-      end
-      
-      def parse(string, options = {})
-        raise ArgumentError 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
-        @hash = @expected_regexp.hash + 15 # fixed offset to avoid collisions with @parseable objects
-      end
-      
-    end # class RegexpParslet
-    
-  end # class Grammar
-end # module Walrus
-

data/lib/walrus/grammar/skipped_substring_exception.rb

@@ -1,42 +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
-    
-    # I don't really like using Exceptions for non-error situations, but it seems that using throw/catch here would not be adequate (not possible to embed information in the thrown symbol).
-    class SkippedSubstringException < Exception
-      
-      include Walrus::Grammar::LocationTracking
-      
-      def initialize(substring, info = {})
-        super substring
-        
-        # TODO: this code is just like the code in ParseError. could save repeating it by setting up inheritance
-        # but would need to pay careful attention to the ordering of my rescue blocks
-        # and also change many instances of "kind_of" in my specs to "instance_of "
-        # alternatively, could look at using a mix-in
-        self.line_start     = info[:line_start]
-        self.column_start   = info[:column_start]
-        self.line_end       = info[:line_end]
-        self.column_end     = info[:column_end]
-      end
-      
-    end # class SkippedSubstringException
-    
-  end # class Grammar
-end # module Walrus
-

data/lib/walrus/grammar/string_enumerator.rb

@@ -1,53 +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 'strscan'
-require 'walrus'
-
-module Walrus
-  class Grammar
-    
-    # Unicode-aware (UTF-8) string enumerator.
-    # For Unicode support $KCODE must be set to 'U' (UTF-8).
-    class StringEnumerator
-      
-      # Returns the char most recently scanned before the last "next" call, or nil if nothing previously scanned.
-      attr_reader :last
-      
-      def initialize(string)
-        raise ArgumentError if string.nil?
-        @scanner  = StringScanner.new(string)
-        @current  = nil
-        @last     = nil
-      end
-      
-      # This method will only work as expected if $KCODE is set to 'U' (UTF-8).
-      def next
-        @last     = @current
-        @current  = @scanner.scan(/./m) # must use multiline mode or "." won't match newlines
-      end
-      
-      # Take a peek at the next character without actually consuming it. Returns nil if there is no next character.
-      # TODO: consider deleting this method as it's not currently used.
-      def peek
-        if char = self.next
-          @scanner.unscan
-        end
-        char
-      end
-      
-    end # class StringEnumerator
-    
-  end # class Grammar
-end # module Walrus

data/lib/walrus/grammar/string_parslet.rb

@@ -1,81 +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 StringParslet < Parslet
-      
-      attr_reader :hash
-      
-      def initialize(string)
-        raise ArgumentError if string.nil?
-        self.expected_string = string
-      end
-      
-      def parse(string, options = {})
-        raise ArgumentError if string.nil?
-        chars         = StringEnumerator.new(string)
-        parsed        = StringResult.new
-        parsed.start  = [options[:line_start], options[:column_start]]
-        parsed.end    = parsed.start
-        expected_string.each_char do |expected_char|
-          actual_char = chars.next
-          if actual_char.nil?
-            raise ParseError.new('unexpected end-of-string (expected "%s") while parsing "%s"' % [ expected_char, expected_string ],
-                                 :line_end    => parsed.line_end,   :column_end   => parsed.column_end)
-          elsif actual_char != expected_char
-            raise ParseError.new('unexpected character "%s" (expected "%s") while parsing "%s"' % [ actual_char, expected_char, expected_string],
-                                 :line_end    => parsed.line_end,   :column_end   => parsed.column_end)
-          else
-            if actual_char == "\r" or (actual_char == "\n" and chars.last != "\r")  # catches Mac, Windows and UNIX end-of-line markers
-              parsed.column_end = 0
-              parsed.line_end   = parsed.line_end + 1
-            elsif actual_char != "\n"                     # \n is ignored if it is preceded by an \r (already counted above)
-              parsed.column_end = parsed.column_end + 1   # everything else gets counted
-            end
-            parsed << actual_char
-          end
-        end
-        parsed.source_text = parsed.to_s.clone
-        parsed
-      end
-      
-      def eql?(other)
-        other.instance_of? StringParslet and other.expected_string == @expected_string
-      end
-      
-    protected
-      
-      # For equality comparisons.
-      attr_reader :expected_string
-      
-    private
-      
-      def expected_string=(string)
-        @expected_string = ( string.clone rescue string )
-        update_hash
-      end
-      
-      def update_hash
-        @hash = @expected_string.hash + 20 # fixed offset to avoid collisions with @parseable objects
-      end
-      
-    end # class StringParslet
-    
-  end # class Grammar
-end # module Walrus
-

data/lib/walrus/grammar/string_result.rb

@@ -1,30 +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 StringResult < String
-      
-      include Walrus::Grammar::LocationTracking
-      
-      def initialize(string = "")
-        self.source_text = string
-        super
-      end
-      
-    end # class StringResult
-  end # class Grammar
-end # module Walrus

data/lib/walrus/grammar/symbol_parslet.rb

@@ -1,69 +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
-    
-    # A SymbolParslet allows for evaluation of a parslet to be deferred until runtime (or parse time, to be more precise).
-    class SymbolParslet < Parslet
-      
-      attr_reader :hash
-      
-      def initialize(symbol)
-        raise ArgumentError if symbol.nil?
-        @symbol = symbol
-        @hash = @symbol.hash + 20 # fixed offset to avoid collisions with @parseable objects
-      end
-      
-      # SymbolParslets don't actually know what Grammar they are associated with at the time of their definition. They expect the Grammar to be passed in with the options hash under the ":grammar" key.
-      # Raises if string is nil, or if the options hash does not include a :grammar key.
-      def parse(string, options = {})
-        raise ArgumentError if string.nil?
-        raise ArgumentError unless options.has_key?(:grammar)
-        grammar = options[:grammar]
-        augmented_options = options.clone
-        augmented_options[:rule_name] = @symbol
-        augmented_options[:skipping_override] = grammar.skipping_overrides[@symbol] if grammar.skipping_overrides.has_key?(@symbol)
-        result = grammar.rules[@symbol].memoizing_parse(string, augmented_options)
-        grammar.wrap(result, @symbol)
-      end
-      
-      # We override the to_s method as it can make parsing error messages more readable. Instead of messages like this:
-      #   predicate not satisfied (expected "#<Walrus::Grammar::SymbolParslet:0x10cd504>") while parsing "hello world"
-      # We can print messages like this:
-      #   predicate not satisfied (expected "rule: end_of_input") while parsing "hello world"
-      def to_s
-        'rule: ' + @symbol.to_s
-      end
-      
-      def ==(other)
-        eql?(other)
-      end
-      
-      def eql?(other)
-        other.instance_of? SymbolParslet and other.symbol == @symbol
-      end
-      
-    protected
-      
-      # For equality comparisons.
-      attr_reader :symbol
-      
-    end # class SymbolParslet
-    
-  end # class Grammar
-end # module Walrus
-