rsruby 0.4.5 → 0.5

data/History.txt

@@ -1,3 +1,9 @@
+= 0.5 2008-04-18
+
+* Added easy figure method RSRuby.img()
+* Removed R interactive features.
+* Extra test cases
+
 = 0.4.2 2007-01-09
 
 * Several bugs in the conversion system are fixed

data/Manifest.txt

@@ -1,7 +1,8 @@
 History.txt
 License.txt
 Manifest.txt
-README.txt
+README.txt
+Rakefile.rb
 examples/arrayfields.rb
 examples/bioc.rb
 examples/dataframe.rb
@@ -27,6 +28,7 @@ test/tc_extensions.rb
 test/tc_init.rb
 test/tc_io.rb
 test/tc_library.rb
+test/tc_matrix.rb
 test/tc_modes.rb
 test/tc_robj.rb
 test/tc_sigint.rb

data/Rakefile.rb

@@ -0,0 +1,153 @@
+require 'hoe'
+
+$LOAD_PATH.unshift("./lib")
+$LOAD_PATH.unshift("./ext")
+
+gem_name = RUBY_PLATFORM !~ /mswin32$/ ? "rsruby" : "rsrubywin"
+hoe = Hoe.new(gem_name,'0.5') do |p|
+  
+  p.author = "Alex Gutteridge"
+  p.email = "ag357@cam.ac.uk"
+  p.url = "http://web.kuicr.kyoto-u.ac.jp/~alexg/rsruby/"
+  
+  p.description = p.paragraphs_of("README.txt",1..3)[0]
+  p.summary     = p.paragraphs_of("README.txt",1)[0]
+  p.changes     = p.paragraphs_of("History.txt",0..1).join("\n\n")
+  
+  p.clean_globs = ["ext/*.o","ext/*.so","ext/Makefile","ext/mkmf.log","**/*~","email.txt","manual.{aux,log,out,toc,pdf}"]
+  
+  p.rdoc_pattern = /(^lib\/.*\.rb$|^examples\/.*\.rb$|^README|^History|^License)/
+  
+  p.spec_extras = {
+    :extensions    => RUBY_PLATFORM !~ /mswin32$/ ? ['ext/extconf.rb'] : [],
+    :require_paths => ['lib','test','ext'],       
+    :has_rdoc      => true,
+    :extra_rdoc_files => ["README.txt","History.txt","License.txt"] + FileList["examples/*"],
+    :rdoc_options  => ["--exclude", "test/*", "--main", "README.txt", "--inline-source"]
+  }
+
+  task :setup_rb_package => [:clean, :package] do
+    
+    package_dir = "#{p.name}-#{p.version}"
+    cp("setup.rb","pkg/#{package_dir}")
+    #cp("manual.pdf","pkg/#{package_dir}")
+    
+    Dir.chdir("pkg")
+    system("tar -czf #{p.name}-#{p.version}.tgz #{package_dir}")
+    Dir.chdir("..")
+
+  end
+
+end
+
+hoe.spec.dependencies.delete_if{|dep| dep.name == "hoe"}
+if RUBY_PLATFORM =~ /mswin32$/
+  # add the precompiled rsruby_c.so into the gemspec
+  hoe.spec.files = hoe.spec.files + ["ext/rsruby_c.so"] 
+  
+  # add the :build_extension task to :gem so that the extension gets
+  # built BEFORE packaging (note the task needs to occur first)
+  Rake.application.lookup(:gem).prerequisites.unshift(:build_extension)
+end
+
+desc "Uses extconf.rb and make to build the extension"
+task :build_extension => ['ext/rsruby_c.so']
+SRC = FileList['ext/*.c'] + FileList['ext/*.h']
+file 'ext/rsruby_c.so' => SRC do
+  Dir.chdir('ext')
+  if RUBY_PLATFORM !~ /mswin32$/
+    system("ruby extconf.rb -- --with-R-dir=$R_HOME --with-R-include=/usr/share/R/include/")
+    system("make")
+  else
+    # Windows-specific build that does not use extconf.rb or make
+    # This build was designed using the default One-Click Installer
+    # for Windows (1.8.6-25) and MinGW (5.1.3).  Both are freely
+    # available.  See the following websites for downloads and
+    # installation information:
+    # 
+    # http://rubyforge.org/projects/rubyinstaller/
+    # http://www.mingw.org/
+    #
+    
+    # TODO - 
+    # * add checks for installation paths
+    # * rewrite this build in terms of rake rules? (or at least check 
+    #   so that up-to-date files are not rebuilt)
+    # * add configuration options a-la extconf.rb
+    
+    # Note: here I use slashes '/' rather than backslashes '\' in the paths.
+    # If you enter the gcc command into the command prompt, you do NOT 
+    # need to use the *nix-style paths.  Here it's necessary so the backslashes
+    # aren't treated as character escapes in the ruby strings.
+    ruby_install_dir = ENV['RUBY_INSTALL_DIR'] || "C:/ruby"
+    ruby_headers_dir = "#{ruby_install_dir}/lib/ruby/1.8/i386-mswin32"
+    ruby_lib_dir = "#{ruby_install_dir}/lib"
+    
+    r_install_dir = ENV['R_INSTALL_DIR'] || "C:/Program Files/R/R-2.6.0"
+    r_headers_dir = "#{r_install_dir}/include"
+    r_lib_dir = "#{r_install_dir}/bin"
+    
+    # These defines are all added for a clean compile.   I'm not sure if 
+    # setting these flags is appropriate, but they do work.
+    # HAVE_R_H:: extconf.rb includes this flag
+    # HAVE_ISINF:: prevents "isinf" redefinition
+    # _MSC_VER:: prevents "MSC version unmatch" error -- it may not be smart to bypass this check
+    # STRICT_R_HEADERS:: prevents "ERROR" redefinition
+    defines = "-DHAVE_R_H -DHAVE_ISINF -D_MSC_VER=1200 -DSTRICT_R_HEADERS"
+    
+    # check required files exist
+    [ruby_headers_dir, ruby_lib_dir].each do |dir|
+      next if File.exists?(dir)
+      raise %Q{
+Build Error: 
+ruby directory does not exist (#{dir})
+Try setting RUBY_INSTALL_DIR to the ruby installation directory.
+
+}
+    end
+    
+    [r_headers_dir, r_lib_dir].each do |dir|
+      next if File.exists?(dir)
+      raise %Q{
+Build Error: 
+R directory does not exist (#{dir})
+Try setting R_INSTALL_DIR to the R installation directory.
+
+}
+    end
+    
+    OBJ = SRC.collect do |src|
+      next unless File.extname(src) == ".c"
+      
+      # at this point the src files are like 'ext/src.c'
+      src = File.basename(src)
+      
+      # compile each source file, using the same flags as extconf.rb
+      # notice the quotes encapsulating the include paths, so that 
+      # spaces are allowed (as in the R default install path)
+      sh( %Q{gcc -I. -I"#{ruby_headers_dir}" -I"#{r_headers_dir}" #{defines} -g -O2 -c #{src}} )
+      
+      # double duty... collect the .o filenames
+      File.basename(src).chomp(".c") + ".o"
+    end.compact
+    
+    # same notes as extconf.rb
+    sh( %Q{gcc -shared -s -L. -Wl,--enable-auto-image-base,--enable-auto-import,--export-all -L"#{ruby_lib_dir}" -L"#{r_lib_dir}" -o rsruby_c.so #{OBJ.join(" ")} -lmsvcrt-ruby18 -lR -lwsock32})
+  end
+  Dir.chdir('..')
+end
+
+task :test => [:build_extension]
+
+desc "Build PDF manual"
+task :build_manual => ["manual.pdf"]
+file "manual.pdf" => ["manual.tex"] do
+  out = 'Rerun'
+  while out.match(/Rerun/)
+    out = `pdflatex manual.tex`
+  end  
+end
+
+task :build_manual_clean => [:build_manual] do
+  system("rm manual.{aux,log,out,toc}")
+end

data/ext/Converters.c

@@ -38,6 +38,8 @@
 SEXP ruby_to_R(VALUE obj)
 {
   SEXP robj;
+  VALUE str;
+  char buf [100];
 
   //Return nil if object is nil
   if (obj == Qnil) {
@@ -99,7 +101,10 @@ SEXP ruby_to_R(VALUE obj)
     }
   else 
     {
-      rb_raise(rb_eArgError,"Unsupported object passed to R.\n");
+      str = rb_funcall(obj,rb_intern("inspect"),0);
+      str = rb_funcall(str,rb_intern("slice"),2,INT2NUM(0),INT2NUM(60));
+      sprintf(buf,"Unsupported object '%s' passed to R.\n",RSTRING(str)->ptr);
+      rb_raise(rb_eArgError,buf);
       PROTECT(robj = NULL);       /* Protected to avoid stack inbalance */
     }
 
@@ -143,8 +148,8 @@ SEXP array_to_R(VALUE obj)
 
   state = -1;
   for (i=0; i<RARRAY(obj)->len; i++) {
-    if (!(it = rb_ary_entry(obj, i)))
-      goto exception;
+
+    it = rb_ary_entry(obj, i);
 
     if (state < 0)
       state = type_to_int(it);
@@ -183,6 +188,7 @@ SEXP array_to_R(VALUE obj)
 
 exception:
   UNPROTECT(1);
+  rb_raise(rb_eArgError,"Error converting Array to R\n");
   return NULL;
 }
 
@@ -193,6 +199,12 @@ hash_to_R(VALUE obj)
   VALUE keys, values;
   SEXP robj, names;
 
+  //TODO - Baffling. Not sure what's wrong with these functions?
+  //rb_hash_keys(proc_table);
+  //rb_hash_values(proc_table);
+  //rb_hash_size(proc_table);
+  //compiles, but complains they are undefined symbols when run...
+
   if (FIX2INT(rb_funcall(obj,rb_intern("size"),0)) == 0)
     return R_NilValue;
 
@@ -421,12 +433,15 @@ from_proc_table(SEXP robj, VALUE *fun)
   VALUE args[2];
   int i, l, error;
 
-  proc_table = rb_cvar_get(rb_const_get(rb_cObject, 
-					rb_intern("RSRuby")),
-			   rb_intern("@@proc_table"));
+  proc_table = rb_iv_get(RSRUBY,"@proc_table");
 
   proc  = Qnil;
 
+  //TODO - Baffling. Not sure what's wrong with these functions?
+  //procs = rb_hash_keys(proc_table);
+  //funs  = rb_hash_values(proc_table);
+  //l     = FIX2INT(rb_hash_size(proc_table));
+
   procs = rb_funcall(proc_table,rb_intern("keys"),0);
   funs  = rb_funcall(proc_table,rb_intern("values"),0);
   l     = FIX2INT(rb_funcall(proc_table,rb_intern("size"),0));
@@ -440,13 +455,10 @@ from_proc_table(SEXP robj, VALUE *fun)
   for (i=0; i<l; i++) {
     proc = rb_ary_entry(procs, i);
 
-    mode = rb_cvar_get(rb_const_get(rb_cObject, 
-				    rb_intern("RSRuby")),
-		       rb_intern("@@default_mode"));
-    rb_cvar_set(rb_const_get(rb_cObject, 
-			     rb_intern("RSRuby")),
-		rb_intern("@@default_mode"),
-		INT2FIX(BASIC_CONVERSION),Qtrue);
+    mode = rb_iv_get(RSRUBY,"@default_mode");
+    rb_iv_set(RSRUBY,
+	      "@default_mode",
+	      INT2FIX(BASIC_CONVERSION));
 
     //New safe code
     args[0] = proc;
@@ -469,10 +481,9 @@ VALUE call_proc(VALUE data){
 
 VALUE reset_mode(VALUE mode){
 
-  rb_cvar_set(rb_const_get(rb_cObject, 
-			   rb_intern("RSRuby")),
-	      rb_intern("@@default_mode"),
-	      mode,Qtrue); 
+  rb_iv_set(RSRUBY,
+	    "@default_mode",
+	    mode); 
 
   return Qnil;
 
@@ -504,13 +515,8 @@ to_ruby_proc(SEXP robj, VALUE *obj)
   rb_iv_set(tmp,"@wrap",Qfalse);
 
   //Again set conversion mode to basic to prevent recursion
-  mode = rb_cvar_get(rb_const_get(rb_cObject, 
-				  rb_intern("RSRuby")),
-		     rb_intern("@@default_mode"));
-  rb_cvar_set(rb_const_get(rb_cObject, 
-			   rb_intern("RSRuby")),
-	      rb_intern("@@default_mode"),
-	      INT2FIX(BASIC_CONVERSION),Qtrue);
+  mode = rb_iv_get(RSRUBY,"@default_mode");
+  rb_iv_set(RSRUBY, "@default_mode", INT2FIX(BASIC_CONVERSION));
 
   //New safe code
   args[0] = fun;
@@ -527,9 +533,7 @@ VALUE from_class_table(SEXP robj)
   VALUE key, fun, class_table;
   int i;
 
-  class_table = rb_cvar_get(rb_const_get(rb_cObject, 
-					 rb_intern("RSRuby")),
-			    rb_intern("@@class_table"));
+  class_table = rb_iv_get(RSRUBY, "@class_table");
 
   PROTECT(rclass = GET_CLASS(robj));
 
@@ -577,13 +581,8 @@ to_ruby_class(SEXP robj, VALUE *obj)
   rb_iv_set(tmp,"@wrap",Qfalse);
 
   //Again set conversion mode to basic to prevent recursion
-  mode = rb_cvar_get(rb_const_get(rb_cObject, 
-				  rb_intern("RSRuby")),
-		     rb_intern("@@default_mode"));
-  rb_cvar_set(rb_const_get(rb_cObject, 
-			   rb_intern("RSRuby")),
-	      rb_intern("@@default_mode"),
-	      INT2FIX(BASIC_CONVERSION),Qtrue);
+  mode = rb_iv_get(RSRUBY, "@default_mode");
+  rb_iv_set(RSRUBY, "@default_mode", INT2FIX(BASIC_CONVERSION));
 
   //New safe code
   args[0] = fun;

data/ext/Converters.h

@@ -58,7 +58,7 @@ VALUE to_ruby_hash(VALUE obj, SEXP names);
 VALUE to_ruby_array(VALUE obj, int *dims, int l);
 
 VALUE ltranspose(VALUE list, int *dims, int *strides,
-			int pos, int shift, int len);
+		 int pos, int shift, int len);
 
 //Macros for quick checks
 #define Robj_Check(v) (rb_obj_is_instance_of(v,rb_const_get(rb_cObject,rb_intern("RObj"))))

data/ext/extconf.rb

@@ -10,4 +10,4 @@ unless have_header("R.h")
   exit 1
 end
 
-create_makefile("rsruby")
+create_makefile("rsruby_c")

data/ext/robj.c

@@ -70,9 +70,7 @@ VALUE RObj_lcall(VALUE self, VALUE args){
     return Qnil;
   }
 
-  default_mode = NUM2INT(rb_cvar_get(rb_const_get(rb_cObject, 
-						  rb_intern("RSRuby")),
-				     rb_intern("@@default_mode")));
+  default_mode = NUM2INT(rb_iv_get(RSRUBY,"@default_mode"));
 
   // Convert
   if (default_mode < 0){
@@ -88,6 +86,45 @@ VALUE RObj_lcall(VALUE self, VALUE args){
   return obj;
 }
 
+
+//lcall method that is safe to call during RSRuby initialisation
+VALUE RObj_init_lcall(VALUE self, VALUE args){
+  SEXP  exp, e, res;
+  SEXP  r_obj;
+  VALUE obj;
+
+  //Ensure we have an array
+  args = rb_check_array_type(args);
+
+  // A SEXP with the function to call and the arguments
+  PROTECT(exp = allocVector(LANGSXP, (RARRAY(args)->len)+1));
+  e = exp;
+
+  Data_Get_Struct(self, struct SEXPREC, r_obj);
+
+  SETCAR(e, r_obj);
+  e = CDR(e);
+
+  // Add the arguments to the SEXP
+  if (!make_argl(args, &e)) {
+    UNPROTECT(1);
+    return Qnil;
+  }
+
+  // Evaluate
+  PROTECT(res = do_eval_expr(exp));
+  if (!res) {
+    UNPROTECT(2);
+    return Qnil;
+  }
+
+  obj = to_ruby_with_mode(res, BASIC_CONVERSION);
+
+  UNPROTECT(2);
+
+  return obj;
+}
+
 /* Convert a sequence of (name, value) pairs to arguments to an R
    function call */
 int
@@ -145,9 +182,7 @@ VALUE RObj_to_ruby(VALUE self, VALUE args){
   }
 
   if (RARRAY(args)->len == 0){
-    conv = NUM2INT(rb_cvar_get(rb_const_get(rb_cObject, 
-					    rb_intern("RSRuby")),
-			       rb_intern("@@default_mode")));
+    conv = NUM2INT(rb_iv_get(RSRUBY,"@default_mode"));
   } else {
     conv = NUM2INT(rb_ary_entry(args,0));
   }

data/ext/rsruby.c

@@ -33,7 +33,7 @@
 
 /* Global list to protect R objects from garbage collection */
 /* This is inspired in $R_SRC/src/main/memory.c */
-static SEXP R_References;
+//static SEXP R_References;
 
 SEXP
 RecursiveRelease(SEXP obj, SEXP list)
@@ -48,19 +48,18 @@ RecursiveRelease(SEXP obj, SEXP list)
 }
 
 /* TODO: This needs implementing as a Ruby destructor for each RObj */
-void
-Robj_dealloc(VALUE self)
-{
-  /* Remove the object from the list of protected objects */
+/*static void
+  Robj_dealloc(VALUE self)
+  {
   SEXP robj;
-
+  
   Data_Get_Struct(self, struct SEXPREC, robj);
-
+  
   R_References = RecursiveRelease(robj, R_References);
   SET_SYMVALUE(install("R.References"), R_References);
-
+  
   return;
-}
+  }*/
 
 
 /* Obtain an R object via its name.
@@ -73,7 +72,6 @@ VALUE get_fun(VALUE self, VALUE name){
   int conversion=TOP_MODE;
   SEXP robj;
   VALUE  rubyobj;
-  //VALUE  params[2];
   char* cstr_name;
 
   str = StringValue(name);
@@ -104,6 +102,7 @@ void r_finalize(void)
   R_RunExitFinalizers();  
   CleanEd();              
   KillAllDevices();       
+
   if((tmpdir = getenv("R_SESSION_TMPDIR"))) {          
     snprintf((char *)buf, 1024, "rm -rf %s", tmpdir); 
     R_system((char *)buf);                            
@@ -116,9 +115,10 @@ void r_finalize(void)
 /*
  * Shutdown the R interpreter
  */
-VALUE cShutdown(VALUE self){
+VALUE rs_shutdown(VALUE self){
 
   r_finalize();
+  Rf_endEmbeddedR(0);
   return Qtrue;
 
 }
@@ -147,24 +147,36 @@ void init_R(int argc, char **argv){
   char *defaultArgv[] = {"rsruby","-q","--vanilla"};
 
   Rf_initEmbeddedR(sizeof(defaultArgv) / sizeof(defaultArgv[0]), defaultArgv);
+  R_Interactive = FALSE; //Remove crash menu (and other interactive R features)
 }
+             
+/* This method is for testing catching of segfaults */
+VALUE crash(){
+	int* ptr = (int*)0;
+	 *ptr = 1;
+	return Qtrue; 
+}
+
 
 /* Ruby code */
 
 VALUE cRRuby;
 VALUE cRObj;
 
-void Init_rsruby(){
+void Init_rsruby_c(){
 
   cRRuby = rb_define_class("RSRuby",rb_cObject);
-  cRObj  = rb_const_get(rb_cObject,rb_intern("RObj"));
 
-  rb_define_method(cRRuby, "initialize", rr_init, 0);
+  rb_define_method(cRRuby, "r_init", rr_init, 0);
   rb_define_method(cRRuby, "get_fun", get_fun, 1);
-  rb_define_method(cRRuby, "shutdown", cShutdown, 0);
+  rb_define_method(cRRuby, "shutdown", rs_shutdown, 0);
+
+rb_define_method(cRRuby, "crash", crash, 0);
 
   //Add the lcall method to RObj
+  cRObj  = rb_const_get(rb_cObject,rb_intern("RObj"));
   rb_define_method(cRObj, "lcall", RObj_lcall, 1);
+  rb_define_method(cRObj, "__init_lcall__", RObj_init_lcall, 1);  
   rb_define_method(cRObj, "to_ruby", RObj_to_ruby, -2);
 
 }

data/ext/rsruby.h

@@ -55,13 +55,16 @@
 
 #define TOP_MODE 4
 
+#define RSRUBY rb_funcall(rb_const_get(rb_cObject,rb_intern("RSRuby")),rb_intern("instance"),0)
+
 /* Missing definitions from Rinterface.h or RStartup.h */
 # define CleanEd Rf_CleanEd
+extern int Rf_initEmbeddedR(int argc, char **argv);   
+extern int R_Interactive;
 extern void CleanEd(void);
 extern int R_CollectWarnings; 
 # define PrintWarnings Rf_PrintWarnings
 extern void PrintWarnings(void);
-extern void Rf_initEmbeddedR(int argc, char **argv);
 
 void Init_rsruby();
 
@@ -69,14 +72,16 @@ void init_R(int argc, char *argv[0]);
 void r_finalize(void);
 
 SEXP RecursiveRelease(SEXP obj, SEXP list);
-void Robj_dealloc(VALUE self);
+//static void Robj_dealloc(VALUE self);
 
-VALUE shutdown(VALUE self);
+VALUE rs_shutdown(VALUE self);
 VALUE get_fun(VALUE self, VALUE name);
-VALUE rr_init(VALUE self);
+VALUE rr_init(VALUE self);   
+
+VALUE crash(void);
 
 VALUE RObj_lcall(VALUE self, VALUE args);
+VALUE RObj_init_lcall(VALUE self, VALUE args);
 VALUE RObj_to_ruby(VALUE self, VALUE args);
 int make_argl(VALUE args, SEXP *e);
-
 #endif

data/lib/rsruby.rb

@@ -1,5 +1,5 @@
 require 'rsruby/robj'
-require 'rsruby.so'
+require 'rsruby_c'
 require 'singleton'
 
 require 'complex'
@@ -53,7 +53,7 @@ require 'complex'
 
 class RSRuby
 
-  VERSION = '0.4.3'
+  VERSION = '0.5'
 
   include Singleton
 
@@ -66,40 +66,63 @@ class RSRuby
   NO_CONVERSION = 0
   NO_DEFAULT = -1
 
-  alias c_initialize initialize
+  attr_accessor :proc_table, :class_table, :default_mode, :caching
 
   #Create a new RSRuby interpreter instance. The Singleton design pattern
   #ensures that only one instance can be running in a script. Further
   #calls to RSRuby.instance will return the original instance.
   def initialize()
 
-    #Initialize in C
-    c_initialize
+    #Initialize R
+    r_init
 
-    @@default_mode = NO_DEFAULT
+    @default_mode = NO_DEFAULT
 
-    @@class_table = {}
-    @@proc_table  = {}
+    @class_table = {}
+    @proc_table  = {}
+    
+    @caching = true
+    reset_cache
+    
+    #Catch errors
+    self.__init_eval_R__("options(error=expression(NULL))")
+    #disable errors
+    self.__init_eval_R__("options(show.error.messages=F)")
 
+  end
+  
+  def reset_cache
     #Setup R object cache
-    @@cache = {}
-    @@cache['get'] = self.get_fun('get')
+    @cache = {}
+    @cache['get'] = self.get_fun('get')
 
     #Get constants
-    @@cache['TRUE']  = self.__getitem__('T')
-    @@cache['FALSE'] = self.__getitem__('F')
-    @@cache['NA']    = self.eval_R('NA')
-    # @@cache['NAN']   = self.eval_R('as.double(NA)')
-    @@cache['NaN']   = self.eval_R('NaN')
+    @cache['TRUE']  = self.__getitem__('T',true)
+    @cache['FALSE'] = self.__getitem__('F',true)
+
+    @cache['parse'] = self.__getitem__('parse',true)
+    @cache['eval']  = self.__getitem__('eval',true)
+
+    @cache['NA']    = self.__init_eval_R__('NA')
+    @cache['NaN']   = self.__init_eval_R__('NaN')
+    # @cache['NAN']   = self.eval_R('as.double(NA)')
     
     #help!
-    @@cache['helpfun'] = self.with_mode(NO_CONVERSION, self.__getitem__('help'))
-
-    #Catch errors
-    self.eval_R("options(error=expression(NULL))")
-    #disable errors
-    self.options('show.error.messages' => false)
+    @cache['helpfun'] = self.with_mode(NO_CONVERSION, self.__getitem__('help',true))
+  end
+  
+  #Delete an R object from the cache. Use R-style function naming, not ruby style.
+  def delete_from_cache(x)
+    @cache.delete(x)
+  end
 
+  def self.img(filename,args={})
+    format = File.extname(filename).gsub(".","").to_sym
+    r = RSRuby.instance
+    raise ArgumentError, "Format #{format.to_s} is not supported" unless [:pdf].include? format
+    r.pdf(filename,args)
+    yield(r)
+    r.dev_off.call
   end
 
   #Handles method name conversion and calling of R functions
@@ -193,15 +216,17 @@ class RSRuby
 
   #Sets the default conversion mode for RSRuby. The constants defined
   #in #RSRuby should be used
+  #DEPRECATED: Use the accessor instead
   def RSRuby.set_default_mode(m)
     if m < -1 or m > TOP_CONVERSION
       raise ArgumentError, "Invalid mode requested"
     end
-    @@default_mode = m
+    RSRuby.instance.default_mode = m
   end
   #Returns the current default conversion mode as an Integer.
+  #DEPRECATED: Use the accessor on the RSRuby instance isntead
   def RSRuby.get_default_mode
-    @@default_mode
+    RSRuby.instance.default_mode
   end
 
   #TODO - not implemented
@@ -234,46 +259,38 @@ class RSRuby
     @@rsruby_showfiles
   end
 
-  #Returns the current class table Hash for RSRuby.
-  def class_table
-    @@class_table
-  end
-
-  #Sets the RSRuby class table Hash.
-  def class_table=(h)
-    @@class_table = h
-  end
-
-  #Returns the current proc table Hash for RSRuby.  
-  def proc_table
-    @@proc_table
-  end
-
-  #Sets the RSRuby proc table Hash.  
-  def proc_table=(h)
-    @@proc_table = h
-  end
-
   #Evaluates the given string in R. Returns the result of the evaluation.
   def eval_R(s)
     self.eval(self.parse(:text => s))
   end
 
+
   #Wraps the R help function.
   def help(*args)
-    helpobj = @@cache['helpfun'].call(args)
+    helpobj = @cache['helpfun'].call(args)
     self.print(helpobj)
   end
 
-  def __getitem__(name)
+
+  def __init_eval_R__(s)
+    parsed = self.parse.__init_lcall__([['text',s]])
+    self.eval.__init_lcall__([['',parsed]])
+  end
+
+  def __getitem__(name,init=false)
 
     #Find the identifier and cache (unless already cached)
-    unless @@cache.has_key?(name)
-      @@cache[name] = @@cache['get'].lcall([['',name]])
+    unless @cache.has_key?(name) && @caching
+      if init
+        robj = @cache['get'].__init_lcall__([['',name]])
+      else
+        robj = @cache['get'].lcall([['',name]])
+      end
+      @cache[name] = robj if @caching
     end
 
     #Retrieve object from cache
-    robj = @@cache[name]
+    robj ||= @cache[name]
 
     return robj
 

data/lib/rsruby/dataframe.rb

@@ -55,12 +55,37 @@ class DataFrame < ERObj
   #Returns an array of the column names used in the R data frame.
   def columns
     cols = @r.colnames(@robj)
-    cols = [cols] unless cols.class == 'Array'
+    cols = [cols] unless cols.kind_of?(Array)
     return cols
   end
 
-  def[](col)
-    return @r['$'].call(@robj,col.to_s)
+  #def[](col)
+  #  return @r['$'].call(@robj,col.to_s)
+  #end
+
+  #Needs to work for named and numbered columns
+  def[](row,col)
+    if col.kind_of?(Integer) and !(columns.include?(col))
+      col = columns[col]
+    end
+    return @r['$'].call(@robj,col.to_s)[row]
+  end
+
+  def[]=(row,col,val)
+    #How to set a value in this dataframe?
+    @r.assign("rsrubytemp",@robj)
+    
+    ### VERY HACKY - This relies on val having the same
+    #string representation in R and Ruby. An assign based
+    #solution with proper conversion of val would be much 
+    #better
+    @r.eval_R("rsrubytemp[#{row+1},#{col+1}] <- #{val}")
+    #
+    #@r.assign("rsrubytemp[#{row+1},#{col+1}]",val)
+
+    @robj = @r.eval_R('get("rsrubytemp")')
+
+    return @r['$'].call(@robj,columns[col].to_s)[row]
   end
 
   def method_missing(attr)

data/test/tc_array.rb

@@ -4,8 +4,8 @@ require 'rsruby'
 class TestArray < Test::Unit::TestCase
 
   def setup
-
     @r = RSRuby.instance
+    #@r.gctorture(:on => false)
     @ruby_AoA = [[[0,6,12,18],[2,8,14,20],[4,10,16,22]],
                  [[1,7,13,19],[3,9,15,21],[5,11,17,23]]]
 
@@ -16,6 +16,10 @@ class TestArray < Test::Unit::TestCase
     @r.array.autoconvert(RSRuby::BASIC_CONVERSION)
   end
 
+  def test_boolean
+    assert_equal [true,false], @r.c(true,false)
+  end
+
   def test_convert_to_ruby
     assert_equal(@ruby_AoA,@r_array.to_ruby)
   end

data/test/tc_boolean.rb

@@ -6,6 +6,7 @@ class TestBoolean < Test::Unit::TestCase
   def setup
     @r = RSRuby.instance
     RSRuby.set_default_mode(RSRuby::NO_DEFAULT)
+    @r.c.autoconvert(RSRuby::BASIC_CONVERSION)
   end
 
   def test_true
@@ -21,4 +22,9 @@ class TestBoolean < Test::Unit::TestCase
        @r.as_logical(@r.FALSE))
     end
   end
+
+  def test_boolean_array
+    assert_equal([true,false,true,false],@r.c(true,false,true,false))
+  end
+
 end

data/test/tc_cleanup.rb

@@ -1,6 +1,6 @@
 require 'test/unit'
 require 'rsruby'
-
+         
 class TestCleanup < Test::Unit::TestCase
 
   def setup
@@ -8,13 +8,15 @@ class TestCleanup < Test::Unit::TestCase
   end
 
   def test_shutdown
-    tempdir = @r.tempdir.call
-    @r.postscript(tempdir+"/foo.ps")
-    @r.plot(1,1)
-    @r.dev_off.call
-    assert(File.exists?(tempdir))
-    @r.shutdown
-    assert(!File.exists?(tempdir))
+    #@r.eval_R("shutdown_test=10")
+    #@r.shutdown
+    #assert_raise(RException){ @r.eval_R("shutdown_test") }
+  end 
+  
+  def test_crash
+    #Signal.trap('BUS','EXIT')
+    #Signal.trap('BUS',proc{ puts 'hi there'; exit!})
+    #@r.crash    
   end
 
 end

data/test/tc_eval.rb

@@ -5,6 +5,8 @@ class TestEval < Test::Unit::TestCase
 
   def setup
     @r = RSRuby.instance
+    @r.proc_table = {}
+    @r.class_table = {}
   end
 
   def test_eval_R

data/test/tc_extensions.rb

@@ -2,7 +2,8 @@ require 'test/unit'
 require 'rsruby'
 
 class TestNewCases < Test::Unit::TestCase
-
+  @@test_dir = File.expand_path File.dirname(__FILE__) 
+  
   def test_erobj
     
     require 'rsruby/erobj'
@@ -19,8 +20,23 @@ class TestNewCases < Test::Unit::TestCase
 
   def test_dataframe
 
+    require 'rsruby/dataframe'
     r = RSRuby.instance
-    r.as_data_frame({'x' => [1,2,3], 'row.names' => ['a','b','c']})
+    r.class_table['data.frame'] = lambda{|x| DataFrame.new(x)}
+    RSRuby.set_default_mode(RSRuby::CLASS_CONVERSION)
+    table = r.read_table(@@test_dir+"/table.txt",:header=>true)
+    assert_instance_of(DataFrame,table)
+    
+    assert_equal(['A','B','C','D'],table.columns)
+    assert_equal([1,2,3],table.rows)
+
+    #assert_equal(['X1','X2','X3'],table['A'])
+    assert_equal('X2',table[1,'A'])
+    assert_equal('X2',table[1,0])
+
+    assert_equal(7,table[1,1])
+    table[1,1] = 5
+    assert_equal(5,table[1,1])
 
   end
 

data/test/tc_init.rb

@@ -0,0 +1,11 @@
+require 'test/unit'
+require 'rsruby'
+
+class TestInit < Test::Unit::TestCase
+
+  def test_init
+    assert_nothing_raised(){RSRuby.instance}
+    assert_instance_of(RSRuby, RSRuby.instance)
+    assert_equal(RSRuby.instance, RSRuby.instance)
+  end
+end

data/test/tc_matrix.rb

@@ -0,0 +1,23 @@
+require 'test/unit'
+require 'rsruby'
+
+class Matrix
+  def as_r
+    "wibble"
+  end
+end
+
+class TestMatrix < Test::Unit::TestCase
+
+  def setup
+    @r = RSRuby.instance
+  end
+
+  def test_matrix_no_convert
+    r = RSRuby.instance
+    r.matrix.autoconvert(RSRuby::NO_CONVERSION)
+    m = r.matrix([1,2,3,4], :ncol => 2, :nrow => 2)
+    assert r.is_matrix(m)
+
+  end
+end

data/test/tc_to_r.rb

@@ -17,6 +17,7 @@ class TestToR < Test::Unit::TestCase
 
   def setup
     @r = RSRuby.instance
+    #@r.gctorture(:on => true)
     RSRuby.set_default_mode(RSRuby::NO_DEFAULT)
   end
 
@@ -88,6 +89,7 @@ class TestToR < Test::Unit::TestCase
   def test_hash_to_named_vector
     @r.c.autoconvert(RSRuby::NO_CONVERSION)    
     assert_equal(@r.typeof(@r.c(:foo => 5, :bar => 7)),'integer')
+    
     assert(@r.attributes(@r.c(:foo => 5, :bar => 7))['names'].include?('foo'))
     assert(@r.attributes(@r.c(:foo => 5, :bar => 7))['names'].include?('bar'))
     #TODO - these fail because of the different calling semantics in
@@ -113,7 +115,7 @@ class TestToR < Test::Unit::TestCase
   def test_instances_not_convertible
     foo = Foo.new
     assert_raises(ArgumentError){@r.c(foo)}
-  end
+   end
 
   def test_as_r_method
     @r.c.autoconvert(RSRuby::BASIC_CONVERSION)

data/test/tc_to_ruby.rb

@@ -2,7 +2,8 @@ require 'test/unit'
 require 'rsruby'
 
 class TestToRuby < Test::Unit::TestCase
-
+  @@test_dir = File.expand_path File.dirname(__FILE__) 
+  
   def setup
     @r = RSRuby.instance
     RSRuby.set_default_mode(RSRuby::NO_DEFAULT)
@@ -70,7 +71,7 @@ class TestToRuby < Test::Unit::TestCase
   #TODO - table.txt?????????
   def test_dataframe_to_list
     @r.read_table.autoconvert(RSRuby::BASIC_CONVERSION)
-    assert_equal(@r.read_table("test/table.txt", {:header => 1}), 
+    assert_equal(@r.read_table(@@test_dir+"/table.txt", {:header => 1}), 
       {
         'A' => ['X1','X2','X3'], 
         'C' => [5,8,2], 

data/test/test_all.rb

@@ -10,6 +10,7 @@ require 'tc_extensions'
 require 'tc_init'
 #require 'tc_io'
 require 'tc_library'
+require 'tc_matrix'
 require 'tc_modes'
 require 'tc_robj'
 #require 'tc_sigint'

metadata

@@ -1,39 +1,38 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.2
-specification_version: 1
 name: rsruby
 version: !ruby/object:Gem::Version 
-  version: 0.4.5
-date: 2007-08-10 00:00:00 +09:00
-summary: RSRuby is a bridge library for Ruby giving Ruby developers access to the full R statistical programming environment. RSRuby embeds a full R interpreter inside the running Ruby script, allowing R methods to be called and data passed between the Ruby script and the R interpreter. Most data conversion is handled automatically, but user-definable conversion routines can also be written to handle any R or Ruby class.
-require_paths: 
-- lib
-- test
-email: alexg@kuicr.kyoto-u.ac.jp
-homepage: http://web.kuicr.kyoto-u.ac.jp/~alexg/rsruby/
-rubyforge_project: rsruby
-description: RSRuby is a bridge library for Ruby giving Ruby developers access to the full R statistical programming environment. RSRuby embeds a full R interpreter inside the running Ruby script, allowing R methods to be called and data passed between the Ruby script and the R interpreter. Most data conversion is handled automatically, but user-definable conversion routines can also be written to handle any R or Ruby class.
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: "0.5"
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Alex Gutteridge
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-04-18 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: RSRuby is a bridge library for Ruby giving Ruby developers access to the full R statistical programming environment. RSRuby embeds a full R interpreter inside the running Ruby script, allowing R methods to be called and data passed between the Ruby script and the R interpreter. Most data conversion is handled automatically, but user-definable conversion routines can also be written to handle any R or Ruby class.
+email: ag357@cam.ac.uk
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- README.txt
+- History.txt
+- License.txt
+- examples/arrayfields.rb
+- examples/bioc.rb
+- examples/dataframe.rb
+- examples/erobj.rb
 files: 
 - History.txt
 - License.txt
 - Manifest.txt
 - README.txt
+- Rakefile.rb
 - examples/arrayfields.rb
 - examples/bioc.rb
 - examples/dataframe.rb
@@ -59,6 +58,7 @@ files:
 - test/tc_init.rb
 - test/tc_io.rb
 - test/tc_library.rb
+- test/tc_matrix.rb
 - test/tc_modes.rb
 - test/tc_robj.rb
 - test/tc_sigint.rb
@@ -67,27 +67,37 @@ files:
 - test/tc_util.rb
 - test/tc_vars.rb
 - test/test_all.rb
-test_files: 
-- test/test_all.rb
+has_rdoc: true
+homepage: http://web.kuicr.kyoto-u.ac.jp/~alexg/rsruby/
+post_install_message: 
 rdoc_options: 
 - --exclude
 - test/*
 - --main
 - README.txt
 - --inline-source
-extra_rdoc_files: 
-- README.txt
-- History.txt
-- License.txt
-- examples/arrayfields.rb
-- examples/bioc.rb
-- examples/dataframe.rb
-- examples/erobj.rb
-executables: []
-
-extensions: 
-- ext/extconf.rb
+require_paths: 
+- lib
+- test
+- ext
+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: []
 
-dependencies: []
-
+rubyforge_project: rsruby
+rubygems_version: 1.1.0
+signing_key: 
+specification_version: 2
+summary: RSRuby is a bridge library for Ruby giving Ruby developers access to the full R statistical programming environment. RSRuby embeds a full R interpreter inside the running Ruby script, allowing R methods to be called and data passed between the Ruby script and the R interpreter. Most data conversion is handled automatically, but user-definable conversion routines can also be written to handle any R or Ruby class.
+test_files: 
+- test/test_all.rb