Spectre 0.0.1

data/lib/spectre/generic/negations.rb

@@ -0,0 +1,68 @@
+# 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 Negation classes.
+#
+
+require 'spectre/base/parser'
+require 'spectre/base/operators'
+
+module Spectre
+
+    ##
+    # Keeps all the generic Negation classes.
+    #
+    module Negations
+
+        ##
+        # Negates a Parser that will consume a single token only.
+        #
+        class NegatedSingleTokenParser < Operators::Negation
+            include Parser
+
+            def scan iter
+                token = iter.get
+                ret = @node.left.parse iter
+                backtrack iter
+
+                if ret
+                    nil
+                else
+                    +iter
+                    create_match iter, token
+                end
+            end
+        end
+
+        ##
+        # Negates a Paser that returns only 0 length matches.
+        #
+        class NegatedZeroTokenParser < Operators::Negation
+            include Parser
+
+            def scan iter
+                ret = @node.left.parse iter
+                backtrack iter
+
+                if ret then nil
+                else Match.new 0, iter.empty
+                end
+            end
+        end
+
+    end
+end
+

data/lib/spectre/generic/primitives.rb

@@ -0,0 +1,172 @@
+# 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 Primitives.
+#
+# Registered shortcuts for generic primitive Parsers:
+#
+# 
+#     RangeParser       :range
+#     SequenceParser    :seq
+#     NothingParser     :nothing
+#     EOLParser         :eol
+#     EOIParser         :eoi
+# 
+#
+# See also ShortcutsMixin.
+#
+
+require 'spectre/base/parser'
+require 'spectre/base/grammar'
+
+module Spectre
+
+    ##
+    # Matches a range of tokens.
+    # Can be supplied with anything that implements the methods +#include?+,
+    # +#first+ and +#last+.
+    #
+    # Shortcut: +range+.
+    #
+    class RangeParser
+        include Parser
+
+        def initialize range
+            [:include?, :first, :last].each { |meth|
+                raise "#{range.inspect} does not respond to ##{meth}, which is required for RangeParser" unless
+                    range.respond_to? meth
+            }
+
+            super()
+            @range = range
+        end
+
+        def negation; Negations::NegatedSingleTokenParser.new; end
+
+        def scan iter
+            return nil unless iter.valid?
+            token = +iter
+
+            if @range.include? token
+                create_match iter, token
+            else
+                nil
+            end
+        end
+
+        def inspect
+            "[range:#{@range.first}..#{@range.last}]"
+        end
+    end
+
+    ##
+    # Matches a sequence of tokens.
+    #
+    # Can be used on anything that is convertible to an array of tokens, i.e. the given
+    # object must either respond to +#split(Regexp)+ or +#to_a+.
+    #
+    # NOTE: It's negation is a zero token parser, i.e. +~seq([1,2,3])+ will only
+    # test if the input at that location contains the sequence and return a failure if so
+    # and a successful match of length 0 if not.
+    #
+    # Shortcut: +seq+.
+    #
+    class SequenceParser
+        include Parser
+
+        def initialize seq
+            raise "given object neither responds to #to_a nor #split, one of which is required for SequenceParser" unless
+                seq.respond_to? :to_a or seq.respond_to? :split
+
+            super()
+            @seq = seq
+            @seq = seq.respond_to?(:split) ? seq.split(//) : seq.to_a
+        end
+
+        def negation; Negations::NegatedZeroTokenParser.new; end
+
+        def scan iter
+            return nil unless iter.valid?
+            buf = iter.empty
+
+            @seq.each { |s|
+                token = iter.get
+                return nil if not iter.valid? or token != s
+                +iter
+                buf = iter.concat buf, token
+            }
+
+            create_match iter, buf
+        end
+
+        def inspect
+            "[seq:#{@seq.inject(''){ |memo,i| memo + i + ', ' }[0..-3] }]"
+        end
+    end
+
+    ##
+    # Matches nothing, i.e. it always fails.
+    # Shortcut: +nothing+.
+    #
+    class NothingParser
+        include Parser
+
+        def negation; Negations::NegatedZeroTokenParser.new; end
+
+        def scan iter
+            nil
+        end
+
+        def inspect
+            "[nothing]"
+        end
+    end
+
+    ##
+    # Matches the end of the input.
+    # Shortcut: +eoi+.
+    #
+    class EOIParser
+        include Parser
+
+        def negation; Negations::NegatedZeroTokenParser.new; end
+
+        def scan iter
+            iter.valid? ? nil : Match.new(0, iter.empty)
+        end
+
+        def inspect
+            "[EOI]"
+        end
+    end
+
+    ShortcutsMixin.register_shortcut( {
+        :range => RangeParser,
+        :seq => SequenceParser,
+        :nothing => NothingParser,
+        :eoi => EOIParser,
+    } )
+
+end
+
+##
+# Register Array as a POD with the RangeParser.
+Spectre::register_POD(Array) { |arr| Spectre::RangeParser.new arr }
+
+##
+# Register Range as a POD with the RangeParser.
+Spectre::register_POD(Range) { |arr| Spectre::RangeParser.new arr }
+

data/lib/spectre/generic/semanticaction.rb

@@ -0,0 +1,43 @@
+# 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 pre-defined semantic action classes.
+#
+
+module Spectre
+
+    ##
+    # This semantic action will be instantiated everytime a symbol is given to
+    # +Parser#[]+.
+    # It stores the value it receives inside the closure.
+    #
+    class ClosureAction
+
+        ##
+        # +sym+ is the Symbol under which the parsed value will be stored in the Closure.
+        #
+        def initialize sym
+            @sym = sym
+        end
+
+        def call match, closure
+            raise "no closure set for ClosureAction" unless closure
+            closure[@sym] = match.value
+        end
+    end
+
+end
+

data/lib/spectre/string.rb

@@ -0,0 +1,57 @@
+# 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 Standard Parsers and InputIterators for String parsing.
+# See Spectre::StringParsing.
+#
+
+require 'spectre/base'
+require 'spectre/generic'
+require 'spectre/string/inputiterator'
+require 'spectre/string/primitives'
+require 'spectre/string/additionals'
+require 'spectre/string/directives'
+
+module Spectre
+
+    module StringParsing
+
+        include Spectre
+
+        ##
+        # Shortcut that parses the +string+ using the +parser+ and a StringInputIterator.
+        # +pre_skip+ will be passed on to +Node#parse+.
+        # If you mix the StringParsing module into your class, it will gain this method.
+        #
+        def parse string, parser, pre_skip = true
+            parser.to_p.parse StringInputIterator.new(string), pre_skip
+        end
+
+        class << self
+            ##
+            # Shortcut that parses the +string+ using the +parser+ and a StringInputIterator.
+            # +pre_skip+ will be passed on to +Node#parse+.
+            # If you mix the StringParsing module into your class, it will gain this method.
+            #
+            def parse string, parser, pre_skip = true
+                parser.to_p.parse StringInputIterator.new(string), pre_skip
+            end
+        end
+
+    end
+
+end
+

data/lib/spectre/string/additionals.rb

@@ -0,0 +1,80 @@
+# 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 Parsers for StringParsing that are used less commonly and are
+# more complex than the primitives.
+# Registered shortcuts for additional String Parsers:
+# 
+#     RegExpParser      :rex
+# 
+# See also ShortcutsMixin.
+#
+
+require 'spectre/base/parser'
+require 'spectre/base/grammar'
+
+module Spectre
+
+    module StringParsing
+
+        ##
+        # Matches a regular expression.
+        # Naturally this Parser is an implicit lexeme, i.e. it will ignore any skippers set
+        # on the InputIterator.
+        #
+        # NOTE: In order to calculate the Match, the regular expression will be applied to
+        # the whole rest of the InputIterator.
+        #
+        # Shortcut: +rex+.
+        #
+        class RegExpParser
+            include Parser
+
+            def initialize rex
+                super()
+                @rex = rex
+            end
+
+            def scan iter
+                m = @rex.match iter.rest
+
+                if m and m.pre_match.empty?
+                    backtrack iter
+                    data = nil
+                    iter.ignore_skipper { |i| data = i + m[0].length }
+                    create_match iter, data
+                else
+                    nil
+                end
+            end
+
+            def inspect
+                "[regexp:#{@rex.inspect}]"
+            end
+        end
+
+        ShortcutsMixin.register_shortcut :rex => RegExpParser
+
+    end
+
+end
+
+##
+# Register regular expressions as a POD with the RegExpParser.
+Spectre::register_POD(Regexp) do |rex|
+    Spectre::StringParsing::RegExpParser.new rex
+end
+

data/lib/spectre/string/directives.rb

@@ -0,0 +1,51 @@
+# 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 Standard Directives for String parsing.
+# Registered shortcuts for standard String Directives:
+#
+#     CharParser        :char
+#
+# See also ShortcutsMixin.
+#
+
+require 'spectre/base/directive'
+require 'spectre/base/grammar'
+require 'spectre/generic/directives'
+
+module Spectre
+
+    module StringParsing
+
+        ##
+        # Converts the input to lower-case.
+        #
+        # Shortcut: +lower_d+
+        #
+        class LowerDirective < Directive
+            transformation! lambda { |token,is| token.downcase }
+
+            def inspect
+                "[lower_d:#{@left.inspect}]"
+            end
+        end
+
+        ShortcutsMixin.register_shortcut :lower_d => LowerDirective
+
+    end
+
+end
+