rbpl 0.1

data/Rakefile

@@ -0,0 +1,7 @@
+
+task :test do 
+    require 'rake/runtest'
+    $LOAD_PATH << "lib"
+    require 'perl'
+    Rake.run_tests 'tests/test_*.rb'
+end

data/lib/perl/engine.pl

@@ -0,0 +1,46 @@
+#!/usr/bin/perl
+
+use strict;
+use YAML::Syck;
+
+$| =1; # autoflush
+
+our $data;
+our $data_length;
+our %SESSION;
+our %_USER_METHODS;
+
+sub eval_and_respond {
+    my ($block) = @_;
+    my $result = &$block();
+
+    my $packed_result = Dump($@ ?
+                    { status => "error", error => $@ } :
+                    { status => "ok", result => $result });
+    print pack("L", length($packed_result)).$packed_result;
+    $result;
+}
+
+while(1) {
+
+    exit 0 if eof(STDIN); # Wait for data or exit if the parent closes the pipe
+
+    read(STDIN, $data_length, 4) == 4 or die "Can not read \$data_length from stdin";
+    $data_length = unpack("L", $data_length);
+
+    read(STDIN, $data, $data_length) == $data_length or die "Can not read \$data from stdin";
+    $data = Load($data);    
+
+    if($data->{request} eq "eval") {
+        eval_and_respond(sub { eval($data->{code}); });
+    } elsif($data->{request} eq "define_method") {
+        eval_and_respond(sub {
+            $_USER_METHODS{$data->{method_name}} = eval("sub { ".$data->{body}." }");
+        });
+    } elsif($data->{request} eq "invoke_method") {
+        eval_and_respond(sub {
+            my $arguments = $data->{arguments};
+            $_USER_METHODS{$data->{method_name}}(@$arguments);
+        });
+    }
+}

data/lib/perl/engine.rb

@@ -0,0 +1,129 @@
+
+require 'open3'
+require 'yaml'
+
+class Perl
+
+    # Base for every exception raised by Perl::Engine
+    class EngineError < Exception; end
+
+    # Raised when a request is to be sent but the engine is stopped
+    class EngineNotRunningError < EngineError; end
+
+    # Raised when a request has been sent but an error ocurred when the response is read
+    class EngineReadingError < EngineError; end
+
+    # Raised when an evaluated code has errors
+    class EngineCodeError < EngineError; end
+
+    # Manages an instance of the Perl interpreter. With #eval method you can execute Perl code and get the result in a Ruby object.
+    # Objects are serialized using YAML, both in the Ruby and Perl side.
+    class Engine
+
+        PerlFile = File.join(File.dirname(__FILE__), "engine.pl")
+
+        # Creates a new instance of the Perl interpreter.
+        def initialize
+            writer = IO.pipe
+            reader = IO.pipe
+
+            @pid = fork do
+                writer[1].close
+                STDIN.reopen(writer[0])
+                writer[0].close
+
+                reader[0].close
+                STDOUT.reopen(reader[1])
+                reader[1].close
+
+                exec "perl", PerlFile
+            end
+
+            reader[1].close
+            writer[0].close
+
+            @stdin = reader[0]
+            @stdout = writer[1]
+        end
+
+        # Check if the Perl interpreter is still alive
+        def running?
+            return false unless @stdin and @stdout
+
+            if IO.select [@stdin], [], [], 0
+                return false if @stdin.eof?
+            end
+
+            true
+        end
+
+        # Stop the Perl interpreter
+        def stop!
+            return false unless running?
+
+            @stdin.close
+            @stdout.close
+            @stdin = @stdout = nil
+
+            Process.kill "TERM", @pid
+            Process.wait @pid
+
+            true
+        end
+
+        def request(request, options = {}) # :nodoc:
+            raise EngineNotRunningError, "Engine is not running" unless @stdout and @stdin
+
+            generic_response = options.delete(:generic_response)
+
+            data = { "request" => request.to_s }.merge!(options).to_yaml
+            @stdout.print([data.length].pack("L") + data)
+
+            data_length = @stdin.read(4).to_s
+            raise EngineReadingError, "Can not read data" if data_length.length != 4
+
+            data_length = data_length.unpack("L").first
+            data = @stdin.read(data_length)
+            raise EngineReadingError, "Can not read data" if data.length != data_length
+
+            response = YAML.load data
+
+            if generic_response
+                case response["status"]
+                when "ok"
+                    response["result"]
+                when "error"
+                    raise EngineCodeError, response["error"].chomp
+                end
+            else
+                response
+            end
+        end
+
+        # Executes the given code in the Perl interpreter.
+        # EngineNotRunningError will be raised if the interpreter is stopped.
+        #
+        # The result will be returned in a Ruby object, using YAML to transport
+        # it. If an error is produced in the Perl interpreter the EngineCodeError
+        # exception will be raised, with the error message generated by Perl.
+        def eval(code)
+            request :eval, "code" => code, :generic_response => true
+        end
+
+        # Defines a method in the Perl interpreter.
+        #
+        # You can access to the arguments using the normal Perl syntax:
+        #  engine.define_method "add_two_values", "$_[0] + $_[1]"
+        def define_method(method_name, body)
+            request "define_method", "name" => method_name.to_s, "body" => body.to_s, :generic_response => true
+        end
+
+        # Invokes a method previously defined by #define_method
+        #
+        # Objects are passed to Perl using YAML. Everything that can be understood by YAML in both sides can be used as an argument.
+        def invoke_method(method_name, *arguments)
+            request "invoke_method", "name" => method_name.to_s, "arguments" => arguments, :generic_response => true
+        end
+    end
+end
+

data/lib/perl.rb

@@ -0,0 +1,2 @@
+
+require 'perl/engine'

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+name: rbpl
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Ayose Cazorla
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-13 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Loads a Perl interpreter and evaluates inside it code generated in the Ruby side
+email: setepo@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/perl/engine.pl
+- lib/perl/engine.rb
+- lib/perl.rb
+- Rakefile
+has_rdoc: true
+homepage: http://github.com/setepo/rbpl
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Execute Perl code from a Ruby script
+test_files: []
+