Spectre 0.0.1

data/lib/spectre/base/parser.rb

@@ -0,0 +1,110 @@
+# This is Spectre, a parser framework inspired by Boost.Spirit,
+# which can be found at http://spirit.sourceforge.net/.
+#
+# If you want to find out more or need a tutorial, go to
+# http://spectre.rubyforge.org/
+# You'll find a nice wiki there!
+#
+# Author::      Fabian Streitel (karottenreibe)
+# Copyright::   Copyright (c) 2009 Fabian Streitel
+# License::     Boost Software License 1.0
+#               For further information regarding this license, you can go to
+#               http://www.boost.org/LICENSE_1_0.txt
+#               or read the file LICENSE distributed with this software.
+# Homepage::    http://spectre.rubyforge.org/
+# Git repo::    http://rubyforge.org/scm/?group_id=7618
+#
+# Keeps the Parser class.
+#
+
+module Spectre
+
+    ##
+    # Keeps the match a Parser made.
+    #
+    class Match
+        ##
+        # The size of the consumed input - Integer.
+        attr_accessor :length
+
+        ##
+        # The value extracted by the parsing process.
+        attr_accessor :value
+
+        ##
+        # Initializes a new Match object with the +length+ of the consumed input and the
+        # +value+ returned by the parsing process.
+        #
+        def initialize length = 0, value = nil
+            @length, @value = length, value
+        end
+    end
+
+    ##
+    # Does the actual work of parsing the input.
+    # Needs to be refined by a class that +include+s it by implementing the +#scan+ method.
+    # If your Parser needs to be presented with arguments on instantiation, you also have
+    # to supply an +#initialize+ method.
+    #
+    module Parser
+
+        ##
+        # The Node this Parser belongs to.
+        attr_accessor :node
+
+        ##
+        # Whether or not the Node of this Parser should call +InputIterator#skip!+.
+        # Operators should reimplement that method to return +false+.
+        #
+        def pre_skip?; true; end
+
+        def inspect
+            '[]'
+        end
+
+        ##
+        # Redirect to Node#backtrack.
+        #
+        def backtrack iter
+            @node.backtrack iter
+        end
+
+        ##
+        # Creates a Match object from the given InputIterator +iter+ and the matched +value+.
+        # Alternatively, value can be a Match object, which will be modified (i.e. it's length
+        # will be corrected) and returned.
+        # If +value+ is +nil+, +nil+ will be returned.
+        #
+        # NOTE: You should always use this method to create a valid Match!
+        #
+        def create_match iter, value
+            if value.nil?
+                nil
+            elsif value.is_a? Match
+                value.length = iter - @node.backtrace
+                value
+            else
+                Match.new iter - @node.backtrace, value
+            end
+        end
+
+        ##
+        # Converts this Parser into a Node.
+        #
+        def to_p
+            Node.new self
+        end
+
+        ##
+        # Does the actual parsing by advancing the InputIterator +iter+.
+        # Required to return a Match object on success, nil otherwise.
+        # 
+        # Must be implemented by a subclass.
+        #
+        def scan iter
+            nil
+        end
+
+    end
+end
+

data/lib/spectre/generic.rb

@@ -0,0 +1,115 @@
+# This is Spectre, a parser framework inspired by Boost.Spirit,
+# which can be found at http://spirit.sourceforge.net/.
+#
+# If you want to find out more or need a tutorial, go to
+# http://spectre.rubyforge.org/
+# You'll find a nice wiki there!
+#
+# Author::      Fabian Streitel (karottenreibe)
+# Copyright::   Copyright (c) 2009 Fabian Streitel
+# License::     Boost Software License 1.0
+#               For further information regarding this license, you can go to
+#               http://www.boost.org/LICENSE_1_0.txt
+#               or read the file LICENSE distributed with this software.
+# Homepage::    http://spectre.rubyforge.org/
+# Git repo::    http://rubyforge.org/scm/?group_id=7618
+#
+# Keeps the generic Parsers, Directives etc.
+# More specific standard Classes can be found in the various other files located in
+# _spectre/*/_.
+#
+
+require 'spectre/base'
+
+module Spectre
+
+    ##
+    # For use with +::register_POD+.
+    #
+    module Parser
+        class << self
+
+            ##
+            # The registered PODs.
+            attr_accessor :PODs
+
+            ##
+            # Converts any Object +obj+ into a Parser, if one is registered to handle
+            # the object's class.
+            # This can be done with +Spectre::register_POD+.
+            #
+            def from_POD obj
+                block = @PODs[obj.class]
+                block ? block.call(obj) : nil
+            end
+        end
+    end
+
+    ##
+    # Init Parser::PODs to Hash.
+    Parser.PODs = {}
+
+    class << self
+        ##
+        # Registers a +klass+ as a POD with the Parser.
+        # The class will gain the method +#to_p+ to convert it to a Parser/Node. Also it will react
+        # to the standard Operators if appropriate.
+        # The Parser for this POD is constructed by passing it to the given +block+, which
+        # must return the correctly instantiated Parser object.
+        #
+        # For examples look in _spectre/std/*.rb_.
+        #
+        def register_POD klass, &block
+            klass.class_eval do
+                def to_p
+                    Spectre::Parser.from_POD(self).to_p
+                end
+
+                old = {}
+                single_methods = [:+, :*]
+                dual_methods = [:>>, :**, :|, :&, :%, :^, :-]
+
+                (single_methods + dual_methods).each do |sym|
+                    old[sym] = self.instance_method sym if self.instance_methods.include? sym.to_s
+                end
+
+                single_methods.each do |sym|
+                    define_method sym do |*args|
+                        if args.empty?
+                            self.to_p.send sym
+                        else
+                            if old[sym] then old[sym].bind(self).call *args
+                            else raise NoMethodError.new "undefined method '#{sym.to_s}' for #{self.inspect}:#{self.class}"
+                            end
+                        end
+                    end
+                end
+
+                dual_methods.each do |sym|
+                    define_method sym do |*args|
+                        if args[0].is_a? Spectre::Node or args[0].is_a? Spectre::Parser
+                            self.to_p.send sym, args[0].to_p
+                        else
+                            if old[sym] then old[sym].bind(self).call *args
+                            else raise NoMethodError.new "undefined method '#{sym.to_s}' for #{self.inspect}:#{self.class}"
+                            end
+                        end
+                    end
+                end
+            end
+
+            Parser.PODs[klass] = block
+        end
+    end
+
+end
+
+##
+# Register Symbol as a POD with the SymParser.
+Spectre::register_POD(Symbol) { |sym| Spectre::SymParser.new sym }
+
+require 'spectre/generic/primitives'
+require 'spectre/generic/negations'
+require 'spectre/generic/directives'
+require 'spectre/generic/semanticaction'
+

data/lib/spectre/generic/directives.rb

@@ -0,0 +1,246 @@
+# This is Spectre, a parser framework inspired by Boost.Spirit,
+# which can be found at http://spirit.sourceforge.net/.
+#
+# If you want to find out more or need a tutorial, go to
+# http://spectre.rubyforge.org/
+# You'll find a nice wiki there!
+#
+# Author::      Fabian Streitel (karottenreibe)
+# Copyright::   Copyright (c) 2009 Fabian Streitel
+# License::     Boost Software License 1.0
+#               For further information regarding this license, you can go to
+#               http://www.boost.org/LICENSE_1_0.txt
+#               or read the file LICENSE distributed with this software.
+# Homepage::    http://spectre.rubyforge.org/
+# Git repo::    http://rubyforge.org/scm/?group_id=7618
+#
+# Keeps the generic Directive classes.
+#
+
+require 'spectre/base/directive'
+require 'spectre/base/grammar'
+
+module Spectre
+
+    ##
+    # Stores the generic directives that can be applied regardless of the input type.
+    #
+    module Directives
+
+        ##
+        # Causes semantic actions not to be triggered regardless of wheter a match
+        # was successful.
+        #
+        # Shortcut: +noaction_d+
+        #
+        class NoActionDirective < Directive
+            policy! :actions => false
+
+            def inspect
+                "[noaction_d:#{@left.inspect}]"
+            end
+        end
+
+        ShortcutsMixin.register_shortcut :noaction_d => NoActionDirective
+
+        ##
+        # Causes every parser wrapped in it to fail unless the specified minimum and
+        # maximum requirements for the matched values are met. Both values may be nil,
+        # indicating a don't-care condition.
+        # Also, +min+ can be set to a range, in which case +max+ will be ignored and the
+        # range will be taken as the indication.
+        #
+        # The comparison is performed via
+        #   _min_ > _value_
+        #   _max_ < _value_
+        # That allows you to supply your own classes for min and max that implement those
+        # methods, which allows for more complex comparisons.
+        #
+        # NOTE: The values set are Parser specific and may thus not be applicable to
+        # all Parsers.
+        #
+        # Shortcut: +limit_d+.
+        #
+        class MinMaxDirective < Directive
+            def initialize min = nil, max = nil
+                super()
+
+                if min.is_a? Range then hsh = { :min => min.first, :max => min.last }
+                else hsh = { :min => min, :max => max }
+                end
+
+                @policy ? @policy.merge!(hsh) : @policy = hsh
+            end
+
+            def inspect
+                "[limit_d:#{@left.inspect}]"
+            end
+        end
+
+        ShortcutsMixin.register_shortcut :limit_d => MinMaxDirective
+
+        ##
+        # Resets all previously applied directives.
+        # Resets the skipper and the transformation to their respective default values.
+        #
+        # Shortcut: reset_d
+        #
+        class ResetDirective < Directive
+            transformation! :default
+            skipper! :default
+            policy! :union => :normal,
+                    :actions => true,
+                    :min => nil,
+                    :max => nil
+
+            def inspect
+                "[reset_d:#{@left.inspect}]"
+            end
+        end
+
+        ShortcutsMixin.register_shortcut :reset_d => ResetDirective
+
+        ##
+        # Forces the parser to ignore pre-skipping via +InputIterator#skip!+.
+        #
+        # Shortcut: +nopreskip_d+.
+        #
+        class NoPreSkipDirective < Directive
+            def parse iter, *args
+                super(iter, false)
+            end
+
+            def inspect
+                "[nopreskip_d:#{@left.inspect}]"
+            end
+        end
+
+        ShortcutsMixin.register_shortcut :nopreskip_d => NoPreSkipDirective
+
+        ##
+        # Sets a skip Parser or block to use.
+        # If a Parser is given, it will be passed the input stream. If it matches,
+        # the input stream will be advanced as much as the Match's length, so all the
+        # matched tokens are skipped.
+        # Any skip Parser will be explicitly wrapped inside a +noaction_d+ and
+        # +InputIterator#ignore_skipper+.
+        # If a block is given instead of a Parser, the block will be given each
+        # input token and must return true if the token should be skipped, and
+        # false otherwise.
+        #
+        # Shortcut: +skip_d+
+        #
+        class SkipDirective < NoPreSkipDirective
+            def initialize skipper
+                if skipper.respond_to? :call
+                    @iter_skipper = lambda { |token,iter|
+                        skipper.call(token) ? 1 : nil
+                    }
+                elsif skipper.respond_to? :parse
+                    skipper = NoActionDirective.new[skipper]
+
+                    @iter_skipper = lambda { |token,iter|
+                        match = nil
+                        iter.ignore_skipper { |i| match = skipper.parse i }
+
+                        if match then match.length
+                        else nil
+                        end
+                    }
+                else
+                    raise "SkipDirective expects either lambda block or parser Node"
+                end
+
+                super()
+            end
+
+            def inspect
+                "[skip_d:#{@left.inspect}]"
+            end
+        end
+
+        ShortcutsMixin.register_shortcut :skip_d => SkipDirective
+
+        ##
+        # Forces Unions to take the alternative that successfully matches the shortest
+        # input. All alternatives will be tried.
+        #
+        # Shortcut: +shortest_d+
+        #
+        class ShortestDirective < Directive
+            policy! :union => :shortest
+
+            def inspect
+                "[shortest_d:#{@left.inspect}]"
+            end
+        end
+
+        ShortcutsMixin.register_shortcut :shortest_d => ShortestDirective
+
+        ##
+        # Forces Unions to take the alternative that successfully matches the longest
+        # input. All alternatives will be tried.
+        #
+        # Shortcut: +longest_d+
+        #
+        class LongestDirective < Directive
+            policy! :union => :longest
+
+            def inspect
+                "[longest_d:#{@left.inspect}]"
+            end
+        end
+
+        ShortcutsMixin.register_shortcut :longest_d => LongestDirective
+
+        ##
+        # Removes any set skipper from the InputIterator, including the default one.
+        #
+        # Shortcut: +noskip_d+ or +lexeme_d+
+        #
+        class NoSkipDirective < Directive
+            skipper! lambda { nil }
+
+            def inspect
+                "[noskip_d:#{@left.inspect}]"
+            end
+        end
+
+        ShortcutsMixin.register_shortcut :noskip_d => NoSkipDirective, :lexeme_d => NoSkipDirective
+
+        ##
+        # Like +nopreskip_d[lexeme_d[...]]+.
+        #
+        # Shortcut: +noskip_d!+ or +lexeme_d!+
+        #
+        class NoSkipNoPreSkipDirective < Directive
+            def [] parser
+                NoPreSkipDirective.new[NoSkipDirective.new[parser]]
+            end
+        end
+
+        ShortcutsMixin.register_shortcut :noskip_d! => NoSkipNoPreSkipDirective, :lexeme_d! => NoSkipNoPreSkipDirective
+
+        ##
+        # Matches, if the Parser it wraps around matches, but reduces that Match to 0 length,
+        # i.e. will never consume any input.
+        # Shortcut: +epsilon+ or +e+.
+        #
+        class EpsilonDirective < Directive
+            def parse iter, *args
+                ret = super(iter, *args)
+                backtrack iter
+                ret.length = 0 if ret
+                ret
+            end
+
+            def inspect
+                "[e:#{@node.left.inspect}]"
+            end
+        end
+
+        ShortcutsMixin.register_shortcut :e => EpsilonDirective, :epsilon => EpsilonDirective
+
+    end
+end
+