partialruby 0.1.0

data/README

@@ -0,0 +1,89 @@
+= partialruby - Ruby partial interpreter written in pure ruby
+
+What I trying to say with "partial" ? Well, the ruby interpreter is composed by a few main conceptual "components":  parser, api, VM and execution environment. A partial interpreter will be a library implementing only one or even only part of one of these basic components. 
+In this case, partialruby only implements part of the VM (e.g. partialruby DOESN'T implement a GC), use the excenllent ruby_parser gem (https://github.com/seattlerb/ruby_parser) to parse ruby code and use the real interpreter to the rest (api, environment, etc...).
+
+== Goals:
+
+=== Implement a alternative VM which export services that is not exported by the original VM without implementing a entire ruby interpreter or fork an existing ruby interpreter
+	- Control of execution flow via hooking for sandboxing (see evalhook and shikashi projects)
+	- Fast DSL (over ruby, and faster than ruby itself!)
+
+=== Proof of Concept of interpreter and partial interpreter development
+
+	- Hyper-portability: microruby
+	- Search for a faster ruby
+
+== Installation
+
+=== Gem Installation (pending)
+
+sudo gem install partialruby
+
+OR
+
+* Download the last version of the gem from http://github.com/tario/partialruby/downloads
+* Install the gem with the following;
+
+sudo gem install partialruby-X.X.X.gem.
+
+== Documentation (pending)
+
+Full API documentation can be found on:
+http://tario.github.com/partialruby/doc/
+
+== Usage (pending)
+
+Basically, partialruby export two APIs:
+
+* A alernative eval function with context. Example:
+
+  require "partialruby"
+  
+  context = PartialRuby::Context.new
+  context.eval('print "hello world\n"')
+
+Or
+
+  require "partialruby"
+  
+  PartialRuby.eval('print "hello world\n"')
+  
+* A flexible node handling. Example
+
+  require "partialruby"
+  
+  class MyPartialRubyContext < PartialRuby::Context
+  
+    def ruby_emul_call(tree)
+        object_tree = tree[1]
+        method_name = tree[2]
+
+        arglist = tree[3]
+
+        argsstr = arglist[1..-1].
+              map{|subtree| "(" +  emul(subtree, frame) + ")" }.
+              join(",")
+
+
+        if (object_tree)
+          "((#{emul(object_tree)}).#{method_name}(#{argsstr})"
+        else
+          if arglist.count == 0
+          "#{method_name}(#{argsstr})"
+          else
+          "#{method_name}"
+          end
+        end
+
+    end
+    
+  end
+  
+  context = MyPartialRubyContext.new
+  context.eval('print "hello world\n"')
+
+== Copying
+
+Copyright (c) 2010-2011 Dario Seminara, released under the GPL License (see LICENSE)
+	

data/Rakefile

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'partialruby'
+  s.version = '0.1.0'
+  s.author = 'Dario Seminara'
+  s.email = 'robertodarioseminara@gmail.com'
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'Ruby partial interpreter written in pure-ruby '
+  s.homepage = "http://github.com/tario/partialruby"
+  s.add_dependency "ruby_parser", ">= 2.0.6"
+  s.has_rdoc = true
+  s.extra_rdoc_files = [ 'README' ]
+  s.rdoc_options << '--main' << 'README'
+  s.files = Dir.glob("{examples,lib,spec}/**/*.rb") +  [ 'LICENSE', 'AUTHORS', 'CHANGELOG', 'README', 'Rakefile', 'TODO' ]
+end
+
+desc 'Run tests'
+task :default => [ :test ]
+
+Rake::TestTask.new('test') do |t|
+  t.libs << 'test'
+  t.pattern = '{test}/**/test_*.rb'
+  t.verbose = true
+end
+
+desc 'Generate RDoc'
+Rake::RDocTask.new :rdoc do |rd|
+  rd.rdoc_dir = 'doc'
+  rd.rdoc_files.add 'lib', 'ext', 'README'
+  rd.main = 'README'
+end
+
+desc 'Build Gem'
+Rake::GemPackageTask.new spec do |pkg|
+  pkg.need_tar = true
+end
+
+desc 'Clean up'
+task :clean => [ :clobber_rdoc, :clobber_package ]
+
+desc 'Clean up'
+task :clobber => [ :clean ]

data/TODO

@@ -0,0 +1,3 @@
+* change interface to eval only ASTs (remove unnecessary ruby_parser dependency)
+* remove obsolete code of node evaluation (only keep emulation code)
+* Ruby 1.9 compatibility

data/lib/partialruby.rb

@@ -0,0 +1,468 @@
+=begin
+
+This file is part of the partialruby project, http://github.com/tario/partialruby
+
+Copyright (c) 2010 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+partialruby is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+partialruby is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with partialruby.  if not, see <http://www.gnu.org/licenses/>.
+
+=end
+require "rubygems"
+require "ruby_parser"
+
+module PartialRuby
+
+  def self.eval(code, b_)
+    c = PureRubyContext.new
+
+    parser = RubyParser.new
+    c.run(parser.parse(code), Frame.new(b_, b_.eval("self")) )
+  end
+
+  class Frame
+    attr_reader :_binding
+    attr_reader :_self
+    attr_reader :locals
+
+    def initialize(b, _self)
+      @_binding = b
+      @_self = _self
+      @locals = Hash.new
+    end
+  end
+
+  class Context
+    def object_ref(obj)
+      "ObjectSpace._id2ref(#{obj.object_id})"
+    end
+
+    def ruby_emul(tree)
+      nodetype = tree.first
+      send("ruby_emul_"+nodetype.to_s, tree)
+    end
+
+    def emul(tree)
+      begin
+        # first, try to emul the node
+        return ruby_emul(tree)
+      rescue NoMethodError => e
+        if tree
+          "#{object_ref self}.run(#{object_ref tree}, PartialRuby::Frame.new(binding,self) )"
+        else
+          "nil; "
+        end
+      end
+    end
+
+    def run(tree, frame)
+      return nil unless tree
+
+      nodetype = tree.first
+
+      code = nil
+      begin
+        # first, try to emul the node
+        code = ruby_emul(tree)
+      rescue NoMethodError => e
+      end
+
+      if code then
+        eval(code, frame._binding)
+      else
+        send("handle_node_"+nodetype.to_s, tree, frame)
+      end
+    end
+  end
+
+  class PureRubyContext < Context
+
+#    def handle_node_scope(tree, frame)
+ #     run(tree[1], frame)
+  #  end
+
+    def ruby_emul_nil(tree)
+      "(nil)"
+    end
+
+    def ruby_emul_scope(tree)
+      emul tree[1]
+    end
+
+    def ruby_emul_block(tree)
+      last = nil
+
+      code = ""
+      tree[1..-1].each do  |subtree|
+        code << emul(subtree) << "\n"
+      end
+
+      code
+    end
+
+    def ruby_emul_hash(tree)
+      pairs = Array.new
+      (0..((tree.size - 1) / 2)-1).each do |i|
+        pairs << [ tree[i*2+1], tree[i*2+2] ]
+      end
+
+      "{" + pairs.map{|pair| "(#{emul pair.first})=>(#{emul pair.last} )" }.join(",") + "}"
+    end
+
+#    def handle_node_block(tree, frame)
+ #     last = nil
+  #    tree[1..-1].each do  |subtree|
+   #     last = run(subtree, frame)
+    #  end
+
+     # last
+    #end
+
+    def ruby_emul_lasgn(tree)
+      varname = tree[1]
+      "#{varname} = ( #{emul(tree[2])} );"
+    end
+
+    def ruby_emul_lvar(tree)
+      varname = tree[1]
+      varname.to_s
+    end
+
+    def ruby_emul_const(tree)
+      tree[1].to_s
+    end
+
+    def ruby_emul_colon3(tree)
+      "::" + tree[1].to_s
+    end
+
+    def ruby_emul_colon2(tree)
+      "#{emul tree[1]}::#{tree[2]}"
+    end
+
+    def ruby_emul_class(tree)
+        classtree = tree[1]
+        subtree = tree[3]
+
+        classname = ""
+        if classtree.instance_of? Symbol then
+          classname = classtree
+        else
+          classname = emul classtree
+        end
+
+        return ("
+          class #{classname}
+            #{emul subtree}
+          end
+        ")
+    end
+
+    def ruby_emul_defs(tree)
+      methodname = tree[2]
+      args = tree[3]
+      "def (#{emul tree[1]}).#{methodname}(#{args[1..-1].map(&:to_s).join(",")})
+        #{emul tree[4]}
+      end
+      "
+    end
+
+    def ruby_emul_defn(tree)
+      method_name = tree[1]
+      args = tree[2]
+      impl = tree[3][1]
+
+      "def #{method_name}(#{args[1..-1].map(&:to_s).join(",")})
+          #{emul impl}
+        end
+      "
+    end
+
+    def ruby_emul_lit(tree)
+      obj = tree[1]
+      if obj.instance_of? Symbol or obj.instance_of? Fixnum or obj == nil or obj == true or obj == false
+      "(#{obj.inspect})"
+      else
+      "(#{object_ref tree[1]})"
+      end
+    end
+
+    def ruby_emul_str(tree)
+      "(#{tree[1].inspect})"
+    end
+
+    def ruby_emul_cdecl(tree)
+
+      if tree[1].instance_of? Sexp
+      "(#{emul tree[1]} = #{emul tree[2]})"
+      else
+      "(#{tree[1]} = #{emul tree[2]})"
+      end
+    end
+
+    def ruby_emul_dstr(tree)
+      firststr = tree[1]
+      retstr = firststr
+      tree[2..-1].each do |subtree|
+
+        subtreetype = subtree[0]
+
+        if subtreetype == :evstr
+          retstr << "\#{(#{emul subtree[1]})}"
+        else
+          retstr << "\#{(#{emul subtree})}"
+        end
+      end
+
+      '"' + retstr + '"'
+    end
+
+    def ruby_emul_array(tree)
+      "[" + tree[1..-1].map{ |subtree| "(" + emul(subtree) + ")" }.join(",") + "]"
+    end
+
+    def ruby_emul_self(tree)
+      "(self)"
+    end
+
+    def ruby_emul_true(tree)
+      "true"
+    end
+
+    def ruby_emul_false(tree)
+      "false"
+    end
+
+    def ruby_emul_if(tree)
+      "if (#{emul tree[1]}); (#{emul tree[2]}) else (#{emul tree[3]}) end"
+    end
+
+    def ruby_emul_while(tree)
+      "while (#{emul tree[1]}); (#{emul tree[2]}); end "
+    end
+
+    def process_args(tree)
+      nodetype = tree[0]
+      if nodetype == :lasgn
+        tree.last.to_s
+      elsif nodetype == :masgn
+        tree[1][1..-1].map {|subtree|
+          process_args(subtree)
+        }.join(",")
+      elsif nodetype == :splat
+        "*" + process_args(tree.last)
+      end
+
+    end
+
+    def ruby_emul_iter(tree)
+      callnode = tree[1]
+      innernode = tree[3]
+
+      arguments = tree[2]
+      argumentsstr = ""
+
+      if arguments
+        argumentsstr = "|" + process_args(arguments) + "|"
+      end
+      "#{emul callnode} { #{argumentsstr} #{emul innernode} }"
+    end
+
+    def ruby_emul_until(tree)
+      "until (#{emul tree[1]}); (#{emul tree[2]}); end "
+    end
+
+    def ruby_emul_case(tree)
+      str = "case #{emul tree[1]}; "
+
+      tree[2..-2].each do |subtree|
+        matches = subtree[1][1..-1].map{|subsubtree| "(" + emul(subsubtree) + ")" }.join(",")
+
+        str << "when #{matches}; #{emul subtree[2]};"
+      end
+
+      if tree[-1]
+        str << "else; #{emul tree[-1]}; "
+      end
+
+      str << "end; "
+      str
+    end
+
+    def ruby_emul_splat(tree)
+      "*(#{emul(tree[1])})"
+    end
+
+    def ruby_emul_ensure(tree)
+      "begin;
+         #{emul tree[1]}
+      ensure;
+        #{emul tree[2] }
+      end;
+      "
+    end
+
+    def ruby_emul_ivar(tree)
+      "(" + tree[1].to_s + ")"
+    end
+
+    def ruby_emul_iasgn(tree)
+      "(#{tree[1].to_s} = (#{emul tree[2]}))"
+    end
+
+    def ruby_emul_gvar(tree)
+      "(" + tree[1].to_s + ")"
+    end
+
+    def ruby_emul_gasgn(tree)
+      "(#{tree[1].to_s} = (#{emul tree[2]}))"
+    end
+
+    def ruby_emul_xstr(tree)
+      "`#{tree[1].gsub("`","")}`"
+    end
+
+    def ruby_emul_dxstr(tree)
+      firststr = tree[1]
+      retstr = firststr
+      tree[2..-1].each do |subtree|
+
+        subtreetype = subtree[0]
+
+        if subtreetype == :evstr
+          retstr << "\#{(#{emul subtree[1]})}"
+        else
+          retstr << "\#{(#{emul subtree})}"
+        end
+      end
+
+      '`' + retstr + '`'
+    end
+
+    def ruby_emul_yield(tree)
+
+      strargs = tree[1..-1].map{ |subtree|
+        if subtree[0] == :splat
+          "*(" + emul(subtree[1]) + ")"
+        else
+          "(" + emul(subtree) + ")"
+        end
+      }.join(",")
+
+      "(yield(#{strargs}))"
+    end
+
+    def ruby_emul_module(tree)
+
+      if tree[1].instance_of? Symbol
+        modulename = tree[1].to_s
+      else
+        modulename = emul tree[1]
+      end
+
+      "module #{modulename}
+        #{emul tree[2]}
+      end
+      "
+    end
+
+    def ruby_emul_rescue(tree)
+
+      resbody = tree[2][2]
+
+      strresbody = ""
+      if resbody
+        strresbody = emul resbody
+      else
+        strresbody = ""
+      end
+
+      exceptionarray = tree[2][1][1..-1]
+
+      exceptionstrarray = []
+
+      i = 0
+      while i < exceptionarray.size
+        if exceptionarray[i+1]
+          if exceptionarray[i+1][0] == :lasgn
+           exceptionstrarray << "(" + (emul(exceptionarray[i]) + ") => " + exceptionarray[i+1][1].to_s)
+            i = i + 1
+          else
+            exceptionstrarray << "(" + (emul(exceptionarray[i])) + ")"
+          end
+        else
+          exceptionstrarray << "(" + (emul(exceptionarray[i])) + ")"
+        end
+        i = i + 1
+      end
+
+      "begin;
+        #{emul tree[1]}
+      rescue #{exceptionstrarray.join(",")};
+        #{strresbody}
+      end;
+      "
+    end
+
+    def ruby_emul_return(tree)
+      "; return #{emul tree[1]}; "
+    end
+
+    def ruby_emul_and(tree)
+      "(#{emul tree[1]}) and (#{emul tree[2]})"
+    end
+
+    def ruby_emul_or(tree)
+      "(#{emul tree[1]}) or (#{emul tree[2]})"
+    end
+
+    def ruby_emul_not(tree)
+      "not (#{emul tree[1]})"
+    end
+
+    def ruby_emul_call(tree)
+        object_tree = tree[1]
+        method_name = tree[2]
+
+        arglisttree = tree[3]
+        arglist = arglisttree[1..-1]
+
+        argsstr = arglist.
+              map{|subtree|
+                if subtree[0] == :splat
+                  emul(subtree)
+                else
+                  "(" +  emul(subtree) + ")"
+                end
+                 }.
+              join(",")
+
+        if (object_tree)
+          if arglist.count == 0
+          "(#{emul(object_tree)}).#{method_name}"
+          else
+          "(#{emul(object_tree)}).#{method_name}(#{argsstr})"
+          end
+        else
+          if arglist.count == 0
+          "#{method_name}"
+          else
+          "#{method_name}(#{argsstr})"
+          end
+        end
+
+    end
+  end
+
+#X.new.foo
+end