Spectre 0.0.1

data/lib/spectre/string/inputiterator.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 InputIterator for String parsing.
+#
+
+require 'spectre/base/inputiterator'
+
+module Spectre
+
+    module StringParsing
+
+        ##
+        # The standard input provider for Strings.
+        # The default transformation set will skip white-space (\s, \n, \t, \r, \f).
+        # This can be undone by wrapping the Parser(s) inside a +lexeme_d+.
+        #
+        class StringInputIterator < InputIterator
+
+            ##
+            # The default skipper for this InputIterator class.
+            # Skips white space.
+            #
+            def default_skipper
+                lambda { |token,is|
+                    case token
+                    when " ", "\n", "\r", "\t", "\f" then 1
+                    else nil
+                    end
+                }
+            end
+
+            def concat val1, val2
+                ( val1 || '' ) + ( val2 || '' )
+            end
+
+            def empty
+                ''
+            end
+        end
+
+    end
+end
+

data/lib/spectre/string/primitives.rb

@@ -0,0 +1,400 @@
+# 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 for String parsing.
+# Registered shortcuts for standard String Parsers:
+# 
+#     CharParser        :char
+#     StringParser      :string
+#     AnycharParser     :any_char
+#     AlnumParser       :alnum_char
+#     AlphaParser       :alpha_char
+#     BlankParser       :blank_char
+#     ControlParser     :control_char
+#     DigitParser       :digit
+#     GraphParser       :graph_char
+#     LowerParser       :lower_char
+#     PrintParser       :print_char
+#     PunctParser       :punct_char
+#     SpaceParser       :space_char
+#     UpperParser       :upper_char
+#     HexDigitParser    :hex_digit
+#     EOLParser         :eol
+# 
+# See also ShortcutsMixin.
+#
+
+require 'spectre/base/parser'
+require 'spectre/base/grammar'
+
+module Spectre
+
+    module StringParsing
+
+        ##
+        # Matches one single character.
+        # Shortcut: +char+.
+        #
+        class CharParser
+            include Parser
+
+            def initialize char
+                super()
+                @char = char
+            end
+
+            def negation; Negations::NegatedSingleTokenParser.new; end
+
+            def scan iter
+                if iter.valid? and +iter == @char
+                    create_match iter, @char
+                else
+                    nil
+                end
+            end
+
+            def inspect
+                "[char:'#{@char}']"
+            end
+        end
+
+        ##
+        # Matches a String.
+        # Is an implicit lexeme, i.e. works on character level only, i.e. it will ignore any skippers set on
+        # the InputIterator
+        #
+        # NOTE: It's negation is a zero token parser, i.e. +~string('foo')+ will only
+        # test if the input at that location contains the string and return a failure if so
+        # and a successful match of length 0 if not.
+        #
+        # Shortcut: +string+.
+        #
+        class StringParser
+            include Parser
+
+            def initialize string
+                super()
+                @string = string
+            end
+
+            def negation; Negations::NegatedZeroTokenParser.new; end
+
+            def scan iter
+                return Match.new 0, @string if @string.length == 0
+                return nil unless iter.valid?
+
+                iter.ignore_skipper do
+                    return create_match iter, @string if
+                        (iter + @string.length) == @string
+                end
+
+                nil
+            end
+
+            def inspect
+                "[string:\"#{@string}\"]"
+            end
+        end
+
+        ##
+        # Matches any character, like the Regexp +/./+.
+        # Shortcut: +any_char+.
+        #
+        class AnycharParser
+            include Parser
+
+            def negation; Negations::NegatedSingleTokenParser.new; end
+
+            def scan iter
+                unless iter.valid?
+                    nil
+                else
+                    char = +iter
+                    create_match iter, char
+                end
+            end
+
+            def inspect
+                "[any_char]"
+            end
+        end
+
+        ##
+        # Matches any alpha-numeric character.
+        # Shortcut: +alnum_char+.
+        #
+        class AlnumParser < RangeParser
+            def initialize
+                super( ('0'..'9').to_a + ('a'..'z').to_a + ('A'..'Z').to_a )
+            end
+
+            def inspect
+                "[alnum_char]"
+            end
+        end
+
+        ##
+        # Matches any alphabetic character.
+        # Shortcut: +alpha_char+.
+        #
+        class AlphaParser < RangeParser
+            def initialize
+                super( ('a'..'z').to_a + ('A'..'Z').to_a )
+            end
+
+            def inspect
+                "[alpha_char]"
+            end
+        end
+
+        ##
+        # Matches spaces and tabs.
+        # Shortcut: +blank_char+.
+        #
+        class BlankParser < RangeParser
+            def initialize
+                super([" ", "\t"])
+            end
+
+            def inspect
+                "[blank_char]"
+            end
+        end
+
+        ##
+        # Matches control characters.
+        # Shortcut: +control_char+.
+        #
+        class ControlParser < RangeParser
+            def initialize
+                super(["\0", "\a", "\b", "\t", "\n", "\f", "\r", "\e", "\s"])
+            end
+
+            def inspect
+                "[control_char]"
+            end
+        end
+
+        ##
+        # Matches numeric digits.
+        # Shortcut: +digit+.
+        #
+        class DigitParser < RangeParser
+            def initialize
+                super( ('0'..'9').to_a )
+            end
+
+            def inspect
+                "[digit]"
+            end
+        end
+
+        ##
+        # Matches non-space printing characters.
+        # Shortcut: +graph_char+.
+        #
+        class GraphParser
+            include Parser
+
+            def negation; Negations::NegatedSingleTokenParser.new; end
+
+            def scan iter
+                return nil unless iter.valid?
+                char = +iter
+
+                if char and char[0].between? 33, 126
+                    create_match iter, char
+                else
+                    nil
+                end
+            end
+
+            def inspect
+                "[graph_char]"
+            end
+        end
+
+        ##
+        # Matches lowercase letters.
+        # Shortcut: +lower_char+.
+        #
+        class LowerParser < RangeParser
+            def initialize
+                super( ('a'..'z').to_a )
+            end
+
+            def inspect
+                "[lower_char]"
+            end
+        end
+
+        ##
+        # Matches printable characters.
+        # Shortcut: +print_char+.
+        #
+        class PrintParser
+            include Parser
+
+            class << self
+                def negation; Negations::NegatedSingleTokenParser.new; end
+            end
+
+            def scan iter
+                return nil unless iter.valid?
+                char = +iter
+
+                if char and char[0].between? 32, 126
+                    create_match iter, char
+                else
+                    nil
+                end
+            end
+
+            def inspect
+                "[print_char]"
+            end
+        end
+
+        ##
+        # Matches punctuation symbols.
+        # Shortcut: +punct_char+.
+        #
+        class PunctParser
+            include Parser
+
+            class << self
+                def negation; Negations::NegatedSingleTokenParser.new; end
+            end
+
+            def scan iter
+                return nil unless iter.valid?
+                char = +iter
+
+                if char and ( char[0].between? 33, 126 ) and ( not ('a'..'z').include? char ) and
+                   ( not ('A'..'Z').include? char ) and ( not ('0'..'9').include? char )
+                    create_match iter, char
+                else
+                    nil
+                end
+            end
+
+            def inspect
+                "[punct_char]"
+            end
+        end
+
+        ##
+        # Matches spaces, tabs, returns and newlines.
+        # Shortcut: +space_char+.
+        #
+        class SpaceParser < RangeParser
+            def initialize
+                super([" ", "\t", "\n", "\r"])
+            end
+
+            def inspect
+                "[space_char]"
+            end
+        end
+
+        ##
+        # Matches uppercase letters.
+        # Shortcut: +upper_char+.
+        #
+        class UpperParser < RangeParser
+            def initialize
+                super( ('A'..'Z').to_a )
+            end
+
+            def inspect
+                "[upper_char]"
+            end
+        end
+
+        ##
+        # Matches hexadecimal digits.
+        # Shortcut: +hex_digit+.
+        #
+        class HexDigitParser < RangeParser
+            def initialize
+                super( ('0'..'9').to_a + ('a'..'f').to_a + ('A'..'F').to_a )
+            end
+
+            def inspect
+                "[hex_digit]"
+            end
+        end
+
+        ##
+        # Matches any end-of-line characters (CR/LF) and combinations thereof.
+        # Shortcut: +eol+.
+        #
+        class EOLParser
+            include Parser
+
+            class << self
+                def negation; Negations::NegatedZeroTokenParser.new; end
+            end
+
+            def scan iter
+                return nil unless iter.valid?
+                buf = nil
+
+                while iter.valid? and ["\n", "\r"].include? iter.get
+                    buf = iter.concat(buf, +iter)
+                end
+
+                if buf then create_match iter, buf
+                else nil
+                end
+            end
+
+            def inspect
+                "[EOL]"
+            end
+        end
+
+        ShortcutsMixin.register_shortcut( {
+            :char => CharParser,
+            :string => StringParser,
+            :any_char => AnycharParser,
+            :alnum_char => AlnumParser,
+            :alpha_char => AlphaParser,
+            :blank_char => BlankParser,
+            :control_char => ControlParser,
+            :digit => DigitParser,
+            :graph_char => GraphParser,
+            :lower_char => LowerParser,
+            :print_char => PrintParser,
+            :punct_char => PunctParser,
+            :space_char => SpaceParser,
+            :upper_char => UpperParser,
+            :hex_digit => HexDigitParser,
+            :eol => EOLParser,
+        } )
+
+    end
+
+end
+
+##
+# Register String as a POD with the CharParser and StringParser.
+Spectre::register_POD(String) do |str|
+    str.length == 1 ?
+        Spectre::StringParsing::CharParser.new(str) :
+        Spectre::StringParsing::StringParser.new(str)
+end
+