opal 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+build

data/Rakefile

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "opal"
+    gem.summary = %q{Ruby runtime for the browser}
+    gem.description = %q{Ruby runtime for the browser}
+    gem.email = "adam@adambeynon.com"
+    gem.homepage = "http://github.com/adambeynon/opal"
+    gem.authors = ["Adam Beynon"]
+    gem.add_development_dependency "vienna", ">= 0.0.3"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "opal #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/docs/jarv.rdoc

@@ -0,0 +1,27 @@
+== JARV
+
+JARV is a (bad) name for the op codes used by this ruby implementation. It is heavily influenced by the opcodes used by ruby. JARV stands for (Javascript/Just/JSON) Another Ruby Vm. Hence the prepended "bad name". JARV takes out some of the data encoded within the instruction sequences, to provide the bare minimum to run the opcodes successfully. The following in a structure of an ISeq, which is represented as an array at runtime in javascript:
+
+	[args, locals, name, filename, type, local_names, args, catch, jumps, opcodes]
+
+=== args
+
+The total number of args that the iseq takes. For methods, this is simply the number of method arguments. Some iseqs, like top or class, do not actually take
+any arguments, so this will be 0.
+
+=== locals
+
+The total number of locals in the iseq. For every var defined, a local is needed, so this represents the size of the local var. GETLOCAL etc reference an index in this set, so an array is essentially used to store these. Args and locals are stored together and referenced using the same idx path, where args are references then locals, in a joint array.
+
+
+
+s = "["
+s << %{#{@args.length},}
+s << %{#{@locals.length},}
+s << %{"#{@name}",}
+s << %{"#{@filename}",}
+s << %{#{@type},}
+s << %{0,}
+s << %{[],}
+s << %{[#{@opcodes.join(",")}]}
+s << %{]}

data/lib/opal.rb

@@ -0,0 +1,29 @@
+# 
+# opal.rb
+# opal
+# 
+# Created by Adam Beynon.
+# Copyright 2010 Adam Beynon.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+
+module Opal
+  
+end

data/runtime/array.js

@@ -0,0 +1,153 @@
+/* 
+ * array.js
+ * opal
+ * 
+ * Created by Adam Beynon.
+ * Copyright 2010 Adam Beynon.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+var rb_cArray;
+
+if (!Array.prototype.indexOf){
+  Array.prototype.indexOf = function(obj){
+	  for (var i = 0; i< this.length; i++){
+	   if (this[i] == obj){
+       return i;
+	    }
+	  }
+	  return -1;
+	}
+}
+
+function rb_ary_each(ary) {
+  var i;
+  // if (!rb_block_given_p()) {
+    // throw "return enumerator thingy"
+  // }
+  for (i = 0; i < ary.length; i++) {
+    rb_yield(ary[i]);
+    // console.log("should yield: " + ary[i]);
+  }
+  return ary;
+}
+
+function Init_Array() {
+  
+  rb_cArray = rb_define_class("Array", rb_cObject);
+  Array.prototype.klass = rb_cArray;
+  
+  // rb_include_module(rb_cArray, rb_mEnumerable);
+  
+  // rb_define_alloc_func(rb_cArray, rb_ary_alloc);
+  // rb_define_singleton_method(rb_cArray, "[]", rb_ary_s_create, -1);
+  // rb_define_singleton_method(rb_cArray, "try_convert", rb_ary_s_try_convert, 1);
+  // rb_define_method(rb_cArray, "initialize", rb_ary_initialize, -1);
+  // rb_define_method(rb_cArray, "initialize_copy", rb_ary_replace, 1);
+
+  // rb_define_method(rb_cArray, "to_s", rb_ary_inspect, 0);
+  // rb_define_method(rb_cArray, "inspect", rb_ary_inspect, 0);
+  // rb_define_method(rb_cArray, "to_a", rb_ary_to_a, 0);
+  // rb_define_method(rb_cArray, "to_ary", rb_ary_to_ary_m, 0);
+  // rb_define_method(rb_cArray, "frozen?",  rb_ary_frozen_p, 0);
+
+  // rb_define_method(rb_cArray, "==", rb_ary_equal, 1);
+  // rb_define_method(rb_cArray, "eql?", rb_ary_eql, 1);
+  // rb_define_method(rb_cArray, "hash", rb_ary_hash, 0);
+
+  // rb_define_method(rb_cArray, "[]", rb_ary_aref, -1);
+  // rb_define_method(rb_cArray, "[]=", rb_ary_aset, -1);
+  // rb_define_method(rb_cArray, "at", rb_ary_at, 1);
+  // rb_define_method(rb_cArray, "fetch", rb_ary_fetch, -1);
+  // rb_define_method(rb_cArray, "first", rb_ary_first, -1);
+  // rb_define_method(rb_cArray, "last", rb_ary_last, -1);
+  // rb_define_method(rb_cArray, "concat", rb_ary_concat, 1);
+  // rb_define_method(rb_cArray, "<<", rb_ary_push, 1);
+  // rb_define_method(rb_cArray, "push", rb_ary_push_m, -1);
+  // rb_define_method(rb_cArray, "pop", rb_ary_pop_m, -1);
+  // rb_define_method(rb_cArray, "shift", rb_ary_shift_m, -1);
+  // rb_define_method(rb_cArray, "unshift", rb_ary_unshift_m, -1);
+  // rb_define_method(rb_cArray, "insert", rb_ary_insert, -1);
+  rb_define_method(rb_cArray, "each", rb_ary_each, 0);
+  // rb_define_method(rb_cArray, "each_index", rb_ary_each_index, 0);
+  // rb_define_method(rb_cArray, "reverse_each", rb_ary_reverse_each, 0);
+  // rb_define_method(rb_cArray, "length", rb_ary_length, 0);
+  // rb_define_alias(rb_cArray,  "size", "length");
+  // rb_define_method(rb_cArray, "empty?", rb_ary_empty_p, 0);
+  // rb_define_method(rb_cArray, "find_index", rb_ary_index, -1);
+  // rb_define_method(rb_cArray, "index", rb_ary_index, -1);
+  // rb_define_method(rb_cArray, "rindex", rb_ary_rindex, -1);
+  // rb_define_method(rb_cArray, "join", rb_ary_join_m, -1);
+  // rb_define_method(rb_cArray, "reverse", rb_ary_reverse_m, 0);
+  // rb_define_method(rb_cArray, "reverse!", rb_ary_reverse_bang, 0);
+  // rb_define_method(rb_cArray, "sort", rb_ary_sort, 0);
+  // rb_define_method(rb_cArray, "sort!", rb_ary_sort_bang, 0);
+  // rb_define_method(rb_cArray, "collect", rb_ary_collect, 0);
+  // rb_define_method(rb_cArray, "collect!", rb_ary_collect_bang, 0);
+  // rb_define_method(rb_cArray, "map", rb_ary_collect, 0);
+  // rb_define_method(rb_cArray, "map!", rb_ary_collect_bang, 0);
+  // rb_define_method(rb_cArray, "select", rb_ary_select, 0);
+  // rb_define_method(rb_cArray, "values_at", rb_ary_values_at, -1);
+  // rb_define_method(rb_cArray, "delete", rb_ary_delete, 1);
+  // rb_define_method(rb_cArray, "delete_at", rb_ary_delete_at_m, 1);
+  // rb_define_method(rb_cArray, "delete_if", rb_ary_delete_if, 0);
+  // rb_define_method(rb_cArray, "reject", rb_ary_reject, 0);
+  // rb_define_method(rb_cArray, "reject!", rb_ary_reject_bang, 0);
+  // rb_define_method(rb_cArray, "zip", rb_ary_zip, -1);
+  // rb_define_method(rb_cArray, "transpose", rb_ary_transpose, 0);
+  // rb_define_method(rb_cArray, "replace", rb_ary_replace, 1);
+  // rb_define_method(rb_cArray, "clear", rb_ary_clear, 0);
+  // rb_define_method(rb_cArray, "fill", rb_ary_fill, -1);
+  // rb_define_method(rb_cArray, "include?", rb_ary_includes, 1);
+  // rb_define_method(rb_cArray, "<=>", rb_ary_cmp, 1);
+
+  // rb_define_method(rb_cArray, "slice", rb_ary_aref, -1);
+  // rb_define_method(rb_cArray, "slice!", rb_ary_slice_bang, -1);
+
+  // rb_define_method(rb_cArray, "assoc", rb_ary_assoc, 1);
+  // rb_define_method(rb_cArray, "rassoc", rb_ary_rassoc, 1);
+
+  // rb_define_method(rb_cArray, "+", rb_ary_plus, 1);
+  // rb_define_method(rb_cArray, "*", rb_ary_times, 1);
+
+  // rb_define_method(rb_cArray, "-", rb_ary_diff, 1);
+  // rb_define_method(rb_cArray, "&", rb_ary_and, 1);
+  // rb_define_method(rb_cArray, "|", rb_ary_or, 1);
+
+  // rb_define_method(rb_cArray, "uniq", rb_ary_uniq, 0);
+  // rb_define_method(rb_cArray, "uniq!", rb_ary_uniq_bang, 0);
+  // rb_define_method(rb_cArray, "compact", rb_ary_compact, 0);
+  // rb_define_method(rb_cArray, "compact!", rb_ary_compact_bang, 0);
+  // rb_define_method(rb_cArray, "flatten", rb_ary_flatten, -1);
+  // rb_define_method(rb_cArray, "flatten!", rb_ary_flatten_bang, -1);
+  // rb_define_method(rb_cArray, "count", rb_ary_count, -1);
+  // rb_define_method(rb_cArray, "shuffle!", rb_ary_shuffle_bang, 0);
+  // rb_define_method(rb_cArray, "shuffle", rb_ary_shuffle, 0);
+  // rb_define_method(rb_cArray, "sample", rb_ary_sample, -1);
+  // rb_define_method(rb_cArray, "cycle", rb_ary_cycle, -1);
+  // rb_define_method(rb_cArray, "permutation", rb_ary_permutation, -1);
+  // rb_define_method(rb_cArray, "combination", rb_ary_combination, 1);
+  // rb_define_method(rb_cArray, "product", rb_ary_product, -1);
+
+  // rb_define_method(rb_cArray, "take", rb_ary_take, 1);
+  // rb_define_method(rb_cArray, "take_while", rb_ary_take_while, 0);
+  // rb_define_method(rb_cArray, "drop", rb_ary_drop, 1);
+  // rb_define_method(rb_cArray, "drop_while", rb_ary_drop_while, 0);
+}

data/runtime/class.js

@@ -0,0 +1,469 @@
+/* 
+ * class.js
+ * opal
+ * 
+ * Created by Adam Beynon.
+ * Copyright 2010 Adam Beynon.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+
+function rb_class_inherited(super_class, klass) {
+  if (!super_class) super_class = rb_cObject ;
+  // return rb_funcall(super_class, "inherited", klass);
+};
+
+function rb_define_class(id, super_class) {
+  var k;
+  // if already defined, just ensure right type then return existing class/mod.
+  if (rb_const_defined(rb_cObject, id)) {  
+    k = rb_const_get(rb_cObject, id);
+    if (!(k.flags & T_CLASS)) {
+      throw id + " is not a class"
+    }
+    if (k.sup != super_class) {
+      if (k != rb_cObject) {
+        throw id + " is already defined"
+      }
+    }
+    return k
+  }
+  if (!super_class) {
+    console.log("no superclass given for " + id + " . Object assumed");
+  }
+  k = rb_define_class_id(id, super_class);
+  rb_class_tbl[id] = k;
+  
+  // class bundle...?
+  // rb_ivar_set(k, '__bundle__', window.vn_current_bundle);
+  
+  rb_name_class(k, id);
+  rb_const_set(rb_cObject, id, k);
+  rb_class_inherited(super_class, k);
+  return k;
+}
+
+function rb_define_class_under(outer, id, super_klass) {
+  var klass;
+  // if already defined in context... just ensure it is a macthing class def
+  /**
+    this should be const_defined_at
+  */
+  if (rb_const_defined_at(outer, id)) {
+    // klass = VN.const_get_at(outer, id);
+    /**
+      this should be const_get_at
+    */
+    // klass = outer.$c_g_a(id);
+    klass = rb_const_get_at(outer, id);
+    // console.log(klass);
+    // if (!(klass.flags & VN.CLASS) {
+    //   VN.type_error(id + ' is not a class');
+    // }
+    // if (RClass.real(klass.$super) != super_klass) {
+    //   // avoid error for cObject
+    //   if (klass != cObject) {
+    //     VN.name_error(id + ' is already defined');
+    //   }
+    //   
+    // }
+    return klass;
+  }
+  // not existing...
+  if (!super_klass) {
+    VN.warning('no super class for `' + VN.class2name(outer), + '::' + id + '`, Object assumed');
+  }
+  klass = rb_define_class_id(id, super_klass);
+  
+  rb_name_class(klass, id);
+  rb_const_set(outer, id, klass);
+  rb_class_inherited(super_klass, klass);
+
+  return klass;
+};
+
+RClass.class2name = function(klass) {
+  return klass.$class_name();
+};
+
+RClass.obj_classname = function(obj) {
+  return VN.class2name(obj.$klass);
+};
+
+function make_metametaclass(metaclass) {
+  console.log("wwowow");
+  var metametaclass, super_of_metaclass;
+
+  if (metaclass.klass == metaclass) {
+    // console.log(1);
+    metametaclass = rb_class_boot(null);
+    metametaclass.klass = metametaclass;
+  }
+  else {
+    // console.log(2);
+    metametaclass = rb_class_boot(null);
+    metametaclass.klass = metaclass.klass.klass == metaclass.klass ? make_metametaclass(metaclass.klass) : metaclass.klass.klass;
+  }
+  // console.log(1);
+  FL_SET(metametaclass, FL_SINGLETON);
+  // console.log(2);
+  rb_singleton_class_attached(metametaclass, metaclass);
+  metaclass.klass = metametaclass;
+
+  super_of_metaclass = metaclass.sup;
+  while (FL_TEST(super_of_metaclass, T_ICLASS)) {
+    super_of_metaclass = super_of_metaclass.sup;
+  }
+
+  metametaclass.sup = rb_ivar_get(super_of_metaclass.klass, '__attached__') == super_of_metaclass ? super_of_metaclass.klass : make_metametaclass(super_of_metaclass);
+  return metametaclass;
+};
+
+function rb_class_real(klass) {
+  while (klass.flags & FL_SINGLETON) klass = klass.sup;
+  return klass;
+}
+
+RClass.real = function(klass) {
+  while ((klass.$singleton == true) || (klass.$type == VN.ICLASS)) {
+    klass = klass.$super
+  }
+  return klass
+};
+
+function class_alloc(type, klass) {
+  var o = new RClass();
+  o.klass = klass;
+  o.flags |= type;
+  return o;
+}
+
+function rb_class_boot(super_class) {
+  var k = class_alloc(T_CLASS, rb_cClass);
+  k.sup = super_class;
+  return k;
+}
+
+function rb_check_inheritable(super_class) {
+  if (!FL_TEST(super_class, T_CLASS)) {
+    throw 'super class must be a Class (' + VN.obj_classname(super_klass) + ' given)';
+  }
+  if (super_class.flags & FL_SINGLETON) {
+    throw 'can\'t make a subclass of singleton class';
+  }
+};
+
+function rb_class_create(super_klass) {
+  rb_check_inheritable(super_klass);
+
+  if (super_klass == rb_cClass) {
+    VN.raise(VN.TypeError, "can't make subclass of Class")
+  }
+  return rb_class_boot(super_klass);
+};
+
+function rb_define_class_id(id, super_klass) {
+  var klass;
+  if (!super_klass) super_klass = rb_cObject;
+  klass = rb_class_create(super_klass);
+  rb_make_metaclass(klass, super_klass.klass);
+  return klass;
+};
+
+function rb_singleton_class(obj) {
+  var klass;
+  // console.log(obj);
+  // console.log("here");
+  if (FL_TEST(obj, T_NUMBER) || FL_TEST(obj, T_SYMBOL)) {
+    console.log(obj);
+    throw 'can\'t define singleton';
+  }
+// console.log("yeap");
+  if (FL_TEST(obj.klass, FL_SINGLETON) && rb_ivar_get(obj.klass, '__attached__') == obj) {
+    klass = obj.klass;
+  }
+  else {
+    // klass = RClass.make_metaclass(obj, obj.$klass);
+    // console.log(obj);
+    // klass = obj.$make_metaclass(obj.$klass) ;
+    klass = rb_make_metaclass(obj, obj.klass);
+  }
+  // console.log("nearly done");
+
+  if (FL_TEST(obj, T_CLASS)) {
+    if (rb_ivar_get(klass.klass, '__attached__') != klass) {
+      // console.log("this far down");
+      // console.log(klass);
+      
+      //FIXME: def need to fix this.!!!!!!!!!!!!! uncomment basically.
+      // make_metametaclass(klass);
+    }
+  }
+  // console.log("completely done");
+
+  return klass;
+};
+
+function rb_name_class(klass, id) {
+  rb_ivar_set(klass, '__classid__', id);
+}
+
+// RClass.prototype.$class_name = function() {
+//   return VN.class_path(klass.$real());
+// };
+
+function rb_make_metaclass(klass, super_class) {
+  if (FL_TEST(klass, T_CLASS) && FL_TEST(klass, FL_SINGLETON)) {
+    return make_metametaclass(klass);
+  }
+  else {
+    var meta = rb_class_boot(super_class);
+    FL_SET(meta, FL_SINGLETON);
+    klass.klass = meta;
+    rb_singleton_class_attached(meta, klass);
+    
+    var metasuper = meta.klass;
+    if (metasuper) {
+      meta.klass = metasuper;
+    }
+    return meta;
+  }
+}
+
+function rb_singleton_class_attached(klass, obj) {
+  if (FL_TEST(klass, FL_SINGLETON)) {
+    rb_ivar_set(klass, '__attached__', obj);
+  }
+}
+
+
+// RClass.prototype.$ = function(id, args) {
+//   var method = this.$klass.$search_method(id);
+//   // console.log('searching for: ' + id);
+//   // console.log(this.$klass);
+//   if (!method) throw 'VN#funcall cannot find method: ' + id ;
+//   return method.apply(this, args) ;
+// };
+// 
+// /**
+//   cvar_get (klassvar_get)
+// */
+// RClass.prototype.$k_g = function(id) {
+//   var tmp = this;
+//   var value;
+//   while(tmp) {
+//     if (value = tmp.$iv_tbl[id]) {
+//       return value;
+//     }
+//     tmp = tmp.$super;
+//   }
+//   VN.name_error('uninitialized class variable ' + id + ' in ' + this);
+//   return nil ;
+// };
+// 
+// /**
+//   class var defined
+// */
+// RClass.prototype.$k_d = function(id) {
+//   var tmp = this;
+//   var value;
+//   while(tmp) {
+//     if (value = tmp.$iv_tbl[id]) {
+//       return true;
+//     }
+//     tmp = tmp.$super;
+//   }
+//   return false;
+// }
+// 
+// /**
+//   cvar_set (klassvar_set)
+// */
+// RClass.prototype.$k_s = function(id, val) {
+//   return this.$iv_tbl[id] = val;
+// };
+// 
+// RClass.prototype.$i_g = function(id) {
+//   return this.$iv_tbl[id];
+// };
+// 
+// RClass.prototype.$i_s = function(id, val) {
+//   this.$iv_tbl[id] = val;
+//   return val ;
+// }
+
+/**
+  Define 'normal' method
+*/
+function rb_define_method(klass, name, func, argc) {
+  func.rb_argc = argc;
+  rb_add_method(klass, name, func, NOEX_PUBLIC);
+}
+
+function rb_define_private_method(klass, name, func, argc) {
+  func.rb_argc = argc;
+  rb_add_method(klass, name, func, NOEX_PRIVATE);
+}
+
+function rb_define_private_method(klass, name, func, argc) {
+  func.rb_argc = argc;
+  rb_add_method(klass, name, func, NOEX_PROTECTED);
+}
+
+function rb_define_singleton_method(klass, name, func, argc) {
+  rb_define_method(rb_singleton_class(klass), name, func, argc);
+}
+
+function rb_add_method(klass, name, func) {
+  klass.m_tbl[name] = func;
+  // func.displayName = klass.iv_tbl.__classid__ + "#" + name;
+}
+
+function rb_define_alloc_func(klass, func) {
+  rb_define_method(rb_singleton_class(klass), 'allocate', func, 0);
+}
+
+
+// RClass.prototype.$def = function(name, func) {
+//   this.$add_method(name, func);
+// };
+// 
+// RClass.prototype.$define_protected_method = function(name, func) {
+//   this.$add_method(name, func);
+// };
+// 
+// RClass.prototype.$define_private_method = function(name, func) {
+//   this.$add_method(name, func);
+// };
+// 
+// RClass.prototype.$undef_method = function(name, func) {
+//   this.$add_method(name, func);
+// };
+// 
+// RClass.prototype.$add_method = function(name, func) {
+//   this.$m_tbl[name] = func;
+// };
+
+/**
+  Define singleton
+*/
+// RClass.prototype.$def_s = function(name, func) {
+//   RClass.singleton_class(this).$def(name, func);
+// };
+// 
+// RClass.prototype.$define_alias = function(id1, id2) {
+//   
+// };
+// 
+// RClass.prototype.$define_alloc_func = function(func) {
+//   RClass.singleton_class(this).$add_method('allocate', func);
+// };
+// 
+// RClass.prototype.$undef_alloc_func = function() {
+//   RClass.singleton_class(this).$add_method('allocate', null);
+// };
+// 
+// RClass.prototype.$search_method = function search_method(id) {
+//   // console.log('checking ' + id);
+//   // console.log(this);
+//   var klass = this; var func ;
+//   // console.log(id);
+//   // console.log(klass);
+//   // return null ;
+//   while (!(func = klass.$m_tbl[id])) {
+//     klass = klass.$super;
+//     // console.log(this.$super.__classid__);
+//     if (!klass) return undefined;
+//   }
+//   // console.log('returning true for ' + id);
+//   return func;
+// };
+// 
+// RClass.prototype.$search_super_method = function(from,id) {
+//   // get current
+//   
+//   /**
+//     Match func = from, to match current function
+//     THEN search by name from there up, otherwise, chains of more then
+//     2 supers will keep rematching second super
+//   */
+//   var klass = this; var func;
+//   while (!((func = klass.$m_tbl[id]) && func == from)) {
+//     klass = klass.$super;
+//     if (!klass) return undefined;
+//   }
+//   // now skip up one
+//   klass = klass.$super;
+//   if (!klass) return undefined;
+//   while (!(func = klass.$m_tbl[id])) {
+//      klass = klass.$super;
+//      if(!klass) return undefined;
+//    }
+//    return func;
+//   
+//     // 
+//     // var klass = this; var func;
+//     // while (!((func = klass.$m_tbl[id]) && func != from)) {
+//     //    klass = klass.$super;
+//     //    if(!klass) return undefined;
+//     //  }
+//     // 
+//     // var klass = this; var func;
+//     // // console.log('from');
+//     // // console.log(from);
+//     // // console.log('views');
+//     // // console.log(klass.$m_tbl[id]);
+//     // // console.log(klass.$m_tbl[id] === from);
+//     // // console.log(klass.$m_tbl[id]);
+//     // while (!((func = klass.$m_tbl[id]) && func != from)) {
+//     //    klass = klass.$super;
+//     //    if(!klass) return undefined;
+//     //  }
+//     // // return func = klass.$m_tbl[id];
+//     // // return func = klass.$m_tbl[id];
+//     // return func;
+// 
+//   // var klass = this; var func ;
+//   // 
+//   // while (!(func = klass.$m_tbl[id])) {
+//   //   klass = klass.$super;
+//   //   if (!klass) return undefined;
+//   // }
+//   // console.log('this point');
+//   // // we have the current impl, now we need to search for the super from this point..
+//   // klass = klass.$super;
+//   // if (!klass) return undefined;
+//   // while (!(func = klass.$m_tbl[id])) {
+//   //   klass = klass.$super;
+//   //   if (!klass) return undefined;
+//   // }
+//   // return func;
+// };
+// 
+// RClass.prototype.$ = function(id, args) {
+//   // var method = this.$search_method(this.$klass, id);
+//   var method = this.$klass.$search_method(id);
+//   if (!method) throw 'VN#funcall cannot find method: ' + id ;
+//   return method.apply(this, args) ;
+// };
+
+/**
+  $const_set
+*/