ppr 0.0.2

data/lib/ppr/safer_generator.rb

@@ -0,0 +1,130 @@
+# require 'yaml'
+
+######################################################################
+#                        Safer string generator.                     #
+######################################################################
+
+
+## Class which allows to safely execute a proc which generate safely
+#  a string into a stream.
+class SaferGenerator
+
+    ## The exception raised when the safer processed failed.
+    class SaferException < RuntimeError
+    end
+
+    ## The list of dangerous constants of Object.
+    DANGER_CONSTANTS = [ :File, :IO, :Dir ]
+
+    ## The list of dangerous methods of Kernel
+    DANGER_METHODS  = [ :system, :`, :open ]
+
+
+    ## Creates a new safe context with while removing Kernel methods and
+    #  constants from +black_list+ in addition to the default dangerous
+    #  ones.
+    def initialize(*black_list)
+        # Set the black list of methods.
+        @black_methods = black_list.select do |symbol|
+            symbol.to_s[0].match(/[a-z_]/)
+        end
+        # Set the black list of constants.
+        @black_constants = black_list.select do |symbol|
+            symbol.to_s[0].match(/[A-Z]/)
+        end
+    end
+
+    ## Strips all the Kernel methods and constants appart from the
+    #  elements of the white list.
+    #  Also strip Object from dangerous methods and constants apart
+    #  from the elements of the white list.
+    def secure
+        # Gather the methods to strip.
+        methods = DANGER_METHODS + @black_methods
+        # Gather the constants to strip.
+        constants = DANGER_CONSTANTS + @black_constants
+        # Strip the dangerous methods.
+        methods.each do |meth|
+            Kernel.send(:undef_method,meth)
+        end
+        # Strip the dangerous constants from Object.
+        constants.each do |cst|
+            Object.send(:remove_const,cst)
+        end
+    end
+
+
+    ## Executes +block+ in a safe context for  generating text into a +stream+.
+    #
+    #  If no stream is given, returns the result as a string instead.
+    def run(stream = nil, &block)
+        unless stream
+            # No stream given
+            to_return = true
+            stream = StringIO.new("")
+        end
+        # Creates the pipe for communicating with the block.
+        rd,wr = IO.pipe
+        # Creates a process for executing the block.
+        pid = fork
+        if pid then
+            # This is the parent: waits for the block execution result.
+            # No need to write on the pipe. close it.
+            wr.close
+            # Read the result of the process and send it to stream
+            until rd.eof?
+                stream << rd.read
+            end
+            # No more need of rd.
+            rd.close
+            # Wait the end of the child process
+            Process.wait(pid)
+            # Where there a trouble?
+            unless $?.exited? then
+                # pid did not exit, internal error.
+                raise "*Internal error*: safer process #{pid} did not exit."
+            end
+            if $?.exitstatus !=0 then
+                # Reconstruct the exception from the stream, the exit
+                # status is the number of line to use.
+                e0 = Marshal.load( stream.string.each_line.
+                                   to_a[-$?.exitstatus..-1].join )
+                # Then resend the eception encapsulated into another one
+                # telling the safer process failed.
+                begin
+                    raise e0
+                rescue Exception => e1
+                    raise SaferException.new("*Error*: exception occured in safer process #{pid}.")
+                end
+            end
+        else
+            # This is the child: enter in safe mode and execute the block.
+            # No need to write on the pipe. close it.
+            rd.close
+            # Secure.
+            secure
+            # Execute the block.
+            begin
+                block.call(wr)
+            rescue Exception => e
+                # The exception is serialized and passed to the main process
+                # through the pipe.
+                e = Marshal.dump(e)
+                wr << "\n" << e 
+                # The exit status is the number of line of the serialized
+                # exception.
+                exit!(e.each_line.count)
+            end
+            # No more need of wr.
+            wr.close
+            # End the process without any error.
+            exit!(0)
+        end
+        # Is there a string to return?
+        if to_return then
+            return stream.string
+        else
+            return nil
+        end
+    end
+end

data/lib/ppr/test_keyword_searcher.rb

@@ -0,0 +1,57 @@
+######################################################################
+##                   Program testing KeywordSearcher                ##
+######################################################################
+
+require "ppr.rb"
+
+# Create the keyword searcher
+puts "Creating the keyword searcher..."
+$searcher = KeywordSearcher.new
+
+# Prepare the input
+puts "Creating the input text..."
+$input = "Histoire de rationalisation : Le Renard et les Raisins\n" +
+         "Certain Renard Gascon, d'autres disent Normand,\n" + 
+         "Mourant presque de faim, vit au haut d'une treille\n" +
+         "Des Raisins mûrs apparemment,\n" +
+         "Et couverts d'une peau vermeille.\n" +
+         "Le galand en eût fait volontiers un repas ;\n" +
+         "Mais comme il n'y pouvait atteindre :\n" +
+         "\"Ils sont trop verts, dit-il, et bons pour des goujats. \"\n" +
+         "Fit-il pas mieux que de se plaindre ?"
+
+# Prepare the keywords to search
+$keywords = [ "Renard", "Normand", "an" ]
+$keywords.each.with_index do |keyword,i| 
+    puts "Adding keyword #{keyword} associated with #{i}..."
+    $searcher[keyword] = i
+end
+
+# Prepare the expected result.
+$expected = [ [0,33..38], [0,63..68], [1,94..100], [2,107..108],[2,224..225] ]
+
+
+# Interate over the keywords founds in the text.
+ok = true
+$searcher.each_in($input).with_index do |entry_range, i|
+    entry, range = *entry_range
+    print "Got entry=#{entry} (#{$keywords[entry]}) at range=#{range}..."
+    unless $input[range] == $keywords[entry] then
+        puts "\nError: at range=#{range} there is #{$input[range]}"
+        ok = false
+    end
+    unless [entry,range] == $expected[i] then
+        puts "\nError: invalid result."
+        puts "Got #{[entry,range]} but expecting #{$expected[i]}."
+        ok = false
+    end
+    puts " ok."
+end
+
+
+
+if ok then
+    puts "Success." 
+else
+    puts "Failure." 
+end

data/lib/ppr/test_ppr.inc

@@ -0,0 +1,7 @@
+.defR repr(word,num)
+   :< word
+   num = num.to_i - 1
+   if num > 0 then
+      :< "repr(#{word},#{num})"
+   end
+.end

data/lib/ppr/test_ppr.rb

@@ -0,0 +1,291 @@
+######################################################################
+##                          Program testing Ppr                     ##
+######################################################################
+
+require "ppr.rb"
+
+# Function for testing a preprocessor
+def test_preprocessor(preprocessor,input,expected)
+    # Prepare the output and the input streams
+    puts "Preparing the input and ouput streams..."
+    output = StringIO.new("")
+    # Process the input and exepected arguments.
+    if !input.respond_to?(:each_line) or input.is_a?(String) then
+        # input is actually a file name, open it.
+        input = File.open(input.to_s,"r")
+    end
+    if !expected.respond_to?(:each_line) or expected.is_a?(String) then
+        # expected is actually a file name, open it.
+        expected = StringIO.new(File.read(expected.to_s))
+    end
+
+    # Apply the preprocessor
+    puts "Applying the preprocessor..."
+    preprocessor.preprocess(input,output)
+
+    # Check the result
+    puts "Checking the result..."
+    output.rewind
+    check = output.string == expected.read
+
+    unless check
+        puts "*Error*: invalid expansion result."
+        iline = output.string.each_line
+        expected.rewind
+        expected.each_line.with_index do |exp_line,i|
+            line = iline.next
+            puts "exp_line=#{exp_line}"
+            puts "line=#{line}"
+            if exp_line != line then
+                puts "Expected line #{i+1}:\n#{exp_line}"
+                puts "got:\n#{line}"
+            end
+        end
+        return false
+    end
+    return true
+end
+
+# Function for testing a preprocessor on +string+ which should raise an 
+# +exception+ string.
+def test_preprocessor_exception(preprocessor,string,exception)
+    input = StringIO.new(string)
+    output = StringIO.new("")
+    begin
+        $ppr.preprocess(input,output)
+        puts "*Error*: preprocessed without exception."
+        return false
+    rescue Exception => e
+        if e.to_s.include?(exception.to_s) then
+            puts "Got exception: <#{e}> as expected."
+            return true
+        else
+            puts "*Error*: unexpected exception.", 
+                 "Got <#{e}> but expecting <#{exception}>."
+            return false
+        end
+    end
+end
+
+# Test the default preprocessor
+
+puts "Building the default preprocessor with one expansion parameter..."
+$ppr = Ppr::Preprocessor.new({"hello" => "Hello"})
+puts "Testing it..."
+$success = test_preprocessor($ppr,"#{File.dirname(__FILE__)}/test_ppr.txt",
+                                  "#{File.dirname(__FILE__)}/test_ppr_exp.txt")
+
+# if $success then
+#     puts "Success." 
+# else
+#     puts "Failure."
+# end
+# exit
+
+puts "\nBuilding a preprocessor with redefined keywords and one expansion parameter."
+$ppr1 = Ppr::Preprocessor.new({hello: "Hello"},
+                              apply: "RUBY", applyR: "RUBYR",
+                              define: "MACRO", defineR: "MACRO_R",
+                              assign: "ASSIGN",
+                              endm: "ENDM", 
+                              expand: "~>", separator: /^|[^\w]|$/, glue: "@@")
+puts "Testing it..."
+$success &= test_preprocessor($ppr1,"#{File.dirname(__FILE__)}/test_ppr2.txt",
+                                   "#{File.dirname(__FILE__)}/test_ppr_exp.txt")
+
+puts "Testing invalid proprocessor with identical strings for different keywords...."
+begin
+    ppr = Ppr::Preprocessor.new(apply: "APPLY", applyR: "APPY_R", 
+                                define:"APPLY")
+    # Should not be there.
+    puts "*Error*: preprocessor built with invalid arguments did not raise any expcetion."
+    $success = false
+rescue Exception => e
+    puts "Got exception as expected: #{e.to_s}."
+end
+
+
+puts  "\nTesting invalid macro definitions..."
+print "... Unfinished macro... "
+$success &= test_preprocessor_exception($ppr, ".def\n :< 'Hello' \n",
+                                        ":1) macro definition without name.")
+
+print "... Incomplete arguments... "
+$success &= test_preprocessor_exception($ppr, 
+                                     "\n.def HE(\n :< 'Hello' \n.end\n",
+                                     ":2) invalid arguments for macro definition.")
+
+puts  "\nTesting invalid macro call..."
+print "... Unfinished macro call case #0... "
+$success &= test_preprocessor_exception($ppr, 
+                        "\n\n.def HE(name)\n :< 'Hello ',name \n.end\nHE(",
+                        "HE:6) incomplete arguments in macro call.")
+print "... Unfinished macro call case #1... "
+$success &= test_preprocessor_exception($ppr, 
+                        "\n.def HE(name)\n :< 'Hello ',name \n.end\nHE(A",
+                        "HE:5) incomplete arguments in macro call.")
+print "... Unfinished macro call case #2... "
+$success &= test_preprocessor_exception($ppr, 
+                        ".def HE(name)\n :< 'Hello ',name \n.end\nHE(A,",
+                        "HE:4) incomplete arguments in macro call.")
+print "... Unfinished macro call case #3... "
+$success &= test_preprocessor_exception($ppr, 
+                        "\n.def HE(name)\n :< 'Hello ',name \n.end\nHE(A,B",
+                        "HE:5) incomplete arguments in macro call.")
+print "... macro call with too many arguments... "
+$success &= test_preprocessor_exception($ppr, 
+                        "\n.def HE(name)\n :< 'Hello ',name \n.end\nHE(A,B)",
+                        "HE:5):2: invalid number of argument: got 2, but expecting 1")
+
+puts  "\nTesting call of macro with invalid code..."
+print "... Syntax error in macro code... "
+$success &= test_preprocessor_exception($ppr, 
+                        "\n\n\n.def HE(name)\n :< 1,2 \n.end\nHE(Foo)",
+                        "HE:7):5: syntax error")
+print "... Division by zero in macro code... "
+$success &= test_preprocessor_exception($ppr, 
+                        "\n.def HE(name)\n :< 1/0 \n.end\nHE(Foo)",
+                        "HE:5):3: divided by 0")
+print "... Undefined symbol in macro code... "
+$success &= test_preprocessor_exception($ppr, 
+                        "\n.def HE(name)\n :< foobar \n.end\nHE(Foo)",
+                        "HE:5):2: undefined local variable or method")
+
+
+# puts "\nBuilding a preprocessor with an invalid escape character."
+# $raised = false
+# begin
+#     $ppr = Ppr::Preprocessor.new(escape: "HA")
+# rescue Exception => e
+#     puts "As expected an exception has been raised (#{e.inspect})."
+#     $raised = true
+# end
+# unless $raised then
+#     puts "Error: an exception should have been raised."
+#     $success = false
+# end
+
+
+puts "\n\nNow going to Test the examples of the documentation."
+puts "Testing example 1..."
+$success &= test_preprocessor($ppr,
+  StringIO.new(
+'Example 1:
+.do
+   :< "Hello world!"
+.end'
+), StringIO.new(
+'Example 1:
+Hello world!') )
+
+puts "\nTesting example 2..."
+$success &= test_preprocessor($ppr,
+  StringIO.new(
+'Example 2:
+.def hello(world)
+   :< "Hello #{world}!"
+.end
+hello(Foo)
+hello( Bar )'
+), StringIO.new(
+'Example 2:
+Hello Foo!
+Hello  Bar !') )
+
+puts "\nTesting example 3..."
+$success &= test_preprocessor($ppr,
+  StringIO.new(
+'Example 3:
+.def hello(world) :< "Hello #{world}!"
+.doR
+   :< "hello(WORLD)"
+.end'
+), StringIO.new(
+'Example 3:
+Hello WORLD!') )
+
+puts "\nTesting example 4..."
+$success &= test_preprocessor($ppr,
+  StringIO.new(
+'Example 4:
+.defR sum(num)
+   num = num.to_i
+   if num > 2 then
+      :< "(+ sum(#{num-1}) #{num} )"
+   else
+      :< "(+ 1 2 )"
+   end
+.end
+Some lisp: sum(5)'
+), StringIO.new(
+'Example 4:
+Some lisp: (+ (+ (+ (+ 1 2 ) 3 ) 4 ) 5 )') )
+
+puts "\nTesting example 5..."
+$success &= test_preprocessor($ppr,
+  StringIO.new(
+'Example 5:
+.assign he :< "Hello"
+.do :< @he + " world!\n"
+.def hehe :< @he+@he
+hehe'
+), StringIO.new(
+'Example 5:
+Hello world!
+HelloHello') )
+
+puts "\nTesting example 6..."
+$success &= test_preprocessor($ppr,
+  StringIO.new(
+'Example 6:
+.load :< "foo.inc"
+.def foo :< "FooO"
+.load :< "foo.inc"'
+), StringIO.new(
+'Example 6:
+foo and bar
+FooO and bar
+') )
+
+# Rebuild ppr to avoid conflict with example 6.
+$ppr = Ppr::Preprocessor.new
+puts "\nTesting example 7..."
+$success &= test_preprocessor($ppr,
+  StringIO.new(
+'Example 7:
+.require :< "foo.inc"
+.def foo :< "FooO"
+.require :< "foo.inc"'
+), StringIO.new(
+'Example 7:
+foo and bar
+') )
+
+puts "\nTesting example 8..."
+$success &= test_preprocessor($ppr,
+  StringIO.new(
+'Example 8:
+.if :< (1 == 1)
+.def is :< "IS"
+This is true.
+.else
+This is false.
+.endif
+.if :< (1 == 0)
+This is really true.
+.else
+This is really false.
+.endif'
+), StringIO.new(
+'Example 8:
+This IS true.
+This IS really false.
+') )
+
+
+
+if $success then
+    puts "Success." 
+else
+    puts "Failure."
+end