opal 0.0.1

data/runtime/hash.js

@@ -0,0 +1,181 @@
+/* 
+ * hash.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_cHash, rb_envtbl;
+
+function rb_hash_alloc(klass) {
+  var hash = new RHash();
+  hash.klass = klass;
+  FL_SET(hash, T_HASH);
+  hash.ifnone = nil;
+  return hash;
+};
+
+function rb_hash_new() {
+  return rb_hash_alloc(rb_cHash);
+};
+
+function rb_hash_aset(hash, k, v) {
+  if (hash.keys.indexOf(k) == -1) {
+    hash.keys.push(k);
+  }
+  hash.dict[k] = v;
+  return v;
+};
+
+function rb_hash_aref(hash, k) {
+  if (hash.keys.indexOf(k) != -1) {
+    return hash.dict[k];
+  }
+  return hash.ifnone;
+};
+
+function rb_hash_size(hash) {
+  return hash.keys.length;
+};
+
+function rb_hash_has_key(hash, k) {
+  if (hash.keys.indexOf(k) != -1) {
+    return true;
+  }
+  return false;
+};
+
+function Init_Hash() {
+  rb_cHash = rb_define_class("Hash", rb_cObject);
+  // rb_include_module(rb_cHash, rb_mEnumerable);
+  // rb_define_alloc_func(rb_cHash, rb_hash_alloc);
+  
+  // rb_define_singleton_method(rb_cHash, "[]", rb_hash_s_create, -1);
+  // rb_define_singleton_method(rb_cHash, "try_convert", rb_hash_s_try_convert, 1);
+  
+  // rb_define_method(rb_cHash,"initialize", rb_hash_initialize, -1);
+  // rb_define_method(rb_cHash,"initialize_copy", rb_hash_replace, 1);
+  // rb_define_method(rb_cHash,"rehash", rb_hash_rehash, 0);
+
+  // rb_define_method(rb_cHash,"to_hash", rb_hash_to_hash, 0);
+  // rb_define_method(rb_cHash,"to_a", rb_hash_to_a, 0);
+  // rb_define_method(rb_cHash,"to_s", rb_hash_inspect, 0);
+  // rb_define_method(rb_cHash,"inspect", rb_hash_inspect, 0);
+
+  // rb_define_method(rb_cHash,"==", rb_hash_equal, 1);
+  rb_define_method(rb_cHash,"[]", rb_hash_aref, 1);
+  // rb_define_method(rb_cHash,"hash", rb_hash_hash, 0);
+  // rb_define_method(rb_cHash,"eql?", rb_hash_eql, 1);
+  // rb_define_method(rb_cHash,"fetch", rb_hash_fetch_m, -1);
+  rb_define_method(rb_cHash,"[]=", rb_hash_aset, 2);
+  // rb_define_method(rb_cHash,"store", rb_hash_aset, 2);
+  // rb_define_method(rb_cHash,"default", rb_hash_default, -1);
+  // rb_define_method(rb_cHash,"default=", rb_hash_set_default, 1);
+  // rb_define_method(rb_cHash,"default_proc", rb_hash_default_proc, 0);
+  // rb_define_method(rb_cHash,"default_proc=", rb_hash_set_default_proc, 1);
+  // rb_define_method(rb_cHash,"key", rb_hash_key, 1);
+  // rb_define_method(rb_cHash,"index", rb_hash_index, 1);
+  rb_define_method(rb_cHash,"size", rb_hash_size, 0);
+  rb_define_method(rb_cHash,"length", rb_hash_size, 0);
+  // rb_define_method(rb_cHash,"empty?", rb_hash_empty_p, 0);
+
+  // rb_define_method(rb_cHash,"each_value", rb_hash_each_value, 0);
+  // rb_define_method(rb_cHash,"each_key", rb_hash_each_key, 0);
+  // rb_define_method(rb_cHash,"each_pair", rb_hash_each_pair, 0);
+  // rb_define_method(rb_cHash,"each", rb_hash_each_pair, 0);
+
+  // rb_define_method(rb_cHash,"keys", rb_hash_keys, 0);
+  // rb_define_method(rb_cHash,"values", rb_hash_values, 0);
+  // rb_define_method(rb_cHash,"values_at", rb_hash_values_at, -1);
+
+  // rb_define_method(rb_cHash,"shift", rb_hash_shift, 0);
+  // rb_define_method(rb_cHash,"delete", rb_hash_delete, 1);
+  // rb_define_method(rb_cHash,"delete_if", rb_hash_delete_if, 0);
+  // rb_define_method(rb_cHash,"select", rb_hash_select, 0);
+  // rb_define_method(rb_cHash,"reject", rb_hash_reject, 0);
+  // rb_define_method(rb_cHash,"reject!", rb_hash_reject_bang, 0);
+  // rb_define_method(rb_cHash,"clear", rb_hash_clear, 0);
+  // rb_define_method(rb_cHash,"invert", rb_hash_invert, 0);
+  // rb_define_method(rb_cHash,"update", rb_hash_update, 1);
+  // rb_define_method(rb_cHash,"replace", rb_hash_replace, 1);
+  // rb_define_method(rb_cHash,"merge!", rb_hash_update, 1);
+  // rb_define_method(rb_cHash,"merge", rb_hash_merge, 1);
+  // rb_define_method(rb_cHash, "assoc", rb_hash_assoc, 1);
+  // rb_define_method(rb_cHash, "rassoc", rb_hash_rassoc, 1);
+  // rb_define_method(rb_cHash, "flatten", rb_hash_flatten, -1);
+
+  rb_define_method(rb_cHash,"include?", rb_hash_has_key, 1);
+  rb_define_method(rb_cHash,"member?", rb_hash_has_key, 1);
+  rb_define_method(rb_cHash,"has_key?", rb_hash_has_key, 1);
+  // rb_define_method(rb_cHash,"has_value?", rb_hash_has_value, 1);
+  // rb_define_method(rb_cHash,"key?", rb_hash_has_key, 1);
+  // rb_define_method(rb_cHash,"value?", rb_hash_has_value, 1);
+
+  // rb_define_method(rb_cHash,"compare_by_identity", rb_hash_compare_by_id, 0);
+  // rb_define_method(rb_cHash,"compare_by_identity?",rb_hash_compare_by_id_p, 0);
+
+  // rb_envtbl = rb_obj_alloc(rb_cObject);
+  // rb_extend_object(rb_envtbl, rb_mEnumerable);
+
+  // rb_define_singleton_method(rb_envtbl,"[]", rb_f_getenv, 1);
+  // rb_define_singleton_method(rb_envtbl,"fetch", env_fetch, -1);
+  // rb_define_singleton_method(rb_envtbl,"[]=", env_aset, 2);
+  // rb_define_singleton_method(rb_envtbl,"store", env_aset, 2);
+  // rb_define_singleton_method(rb_envtbl,"each", env_each_pair, 0);
+  // rb_define_singleton_method(rb_envtbl,"each_pair", env_each_pair, 0);
+  // rb_define_singleton_method(rb_envtbl,"each_key", env_each_key, 0);
+  // rb_define_singleton_method(rb_envtbl,"each_value", env_each_value, 0);
+  // rb_define_singleton_method(rb_envtbl,"delete", env_delete_m, 1);
+  // rb_define_singleton_method(rb_envtbl,"delete_if", env_delete_if, 0);
+  // rb_define_singleton_method(rb_envtbl,"clear", rb_env_clear, 0);
+  // rb_define_singleton_method(rb_envtbl,"reject", env_reject, 0);
+  // rb_define_singleton_method(rb_envtbl,"reject!", env_reject_bang, 0);
+  // rb_define_singleton_method(rb_envtbl,"select", env_select, 0);
+  // rb_define_singleton_method(rb_envtbl,"shift", env_shift, 0);
+  // rb_define_singleton_method(rb_envtbl,"invert", env_invert, 0);
+  // rb_define_singleton_method(rb_envtbl,"replace", env_replace, 1);
+  // rb_define_singleton_method(rb_envtbl,"update", env_update, 1);
+  // rb_define_singleton_method(rb_envtbl,"inspect", env_inspect, 0);
+  // rb_define_singleton_method(rb_envtbl,"rehash", env_none, 0);
+  // rb_define_singleton_method(rb_envtbl,"to_a", env_to_a, 0);
+  // rb_define_singleton_method(rb_envtbl,"to_s", env_to_s, 0);
+  // rb_define_singleton_method(rb_envtbl,"key", env_key, 1);
+  // rb_define_singleton_method(rb_envtbl,"index", env_index, 1);
+  // rb_define_singleton_method(rb_envtbl,"size", env_size, 0);
+  // rb_define_singleton_method(rb_envtbl,"length", env_size, 0);
+  // rb_define_singleton_method(rb_envtbl,"empty?", env_empty_p, 0);
+  // rb_define_singleton_method(rb_envtbl,"keys", env_keys, 0);
+  // rb_define_singleton_method(rb_envtbl,"values", env_values, 0);
+  // rb_define_singleton_method(rb_envtbl,"values_at", env_values_at, -1);
+  // rb_define_singleton_method(rb_envtbl,"include?", env_has_key, 1);
+  // rb_define_singleton_method(rb_envtbl,"member?", env_has_key, 1);
+  // rb_define_singleton_method(rb_envtbl,"has_key?", env_has_key, 1);
+  // rb_define_singleton_method(rb_envtbl,"has_value?", env_has_value, 1);
+  // rb_define_singleton_method(rb_envtbl,"key?", env_has_key, 1);
+  // rb_define_singleton_method(rb_envtbl,"value?", env_has_value, 1);
+  // rb_define_singleton_method(rb_envtbl,"to_hash", env_to_hash, 0);
+  // rb_define_singleton_method(rb_envtbl,"assoc", env_assoc, 1);
+  // rb_define_singleton_method(rb_envtbl,"rassoc", env_rassoc, 1);
+
+  // rb_define_global_const("ENV", rb_envtbl);
+}

data/runtime/init.js

@@ -0,0 +1,59 @@
+/* 
+ * init.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.
+ */
+ 
+/**
+  Basically start opal.
+*/
+function ruby_init() {
+  rb_call_inits();
+};
+
+/**
+  embed script name/type
+*/
+function ruby_script(name) {
+  
+};
+
+
+/**
+  Init core.
+*/
+function rb_call_inits() {
+  Init_Object();
+  Init_top_self();
+  Init_Array();
+  Init_Number();
+  Init_String();
+  Init_Hash();
+  Init_Range();
+  Init_Regexp();
+  Init_File();
+  Init_Dir();
+  Init_VM();
+  Init_vm_eval();
+  Init_load();
+};

data/runtime/load.js

@@ -0,0 +1,251 @@
+/* 
+ * load.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.
+ */
+
+ 
+/**
+  Entry point 1.
+  ==============
+  
+  This should be used for apps that do not require the vienna build tools. Simply
+  pass it the root .rb file that you wish to use. simples.
+  
+  usage:
+  
+    vm_rb_main('my_file.rb');
+      => app runs.
+      
+  All searches, for require() statements, look for .rb files, not bundles.
+*/
+function vm_rb_main(path) {
+  rb_call_inits();
+  rb_top_vm.search_style = ".rb";
+  if (path.substr(path.length - 3) === ".rb") {
+    path = path.substr(0, path.length - 3);
+  }
+  return rb_f_require(rb_top_self, path);
+}
+
+/**
+  Entry point 2.
+  ==============
+  
+  Used for the bundles appraoch, where all files are already pre-compiled, or
+  vn-server is used to deploy files. This basically means no raw .rb files will
+  need to be compiled, so all searches take place for .vngem files
+  
+  This loads the .rb file from the app bundle.
+  
+  This actually loads each vendor bundle and the app bundle from the server, and
+  then, only when that is complete, does it actually load and run the given file.
+  
+  For now, synchronous callbacks: in future, this will be async to avoid blocking
+  browser. Will need to make use of callbacks.
+*/
+// function vm_bundle_main(filename) {
+//   if (!window.VN_VENDOR_PATH) VN_VENDOR_PATH = '/vendor';
+//   if (!window.VN_APPLICATION_PATH) VN_APPLICATION_PATH = '/';
+//   // VN_BOOTSTRAP_APPLICATION = "sample_controls";
+//   // VN_BOOTSTRAP_BUNDLES = ["vienna"];
+//   for (var i = 0; i < VN_BOOTSTRAP_BUNDLES.length; i++) {
+//     var fullpath = VN_VENDOR_PATH + '/' + VN_BOOTSTRAP_BUNDLES[i] + '.opal';
+//     // console.log("Need to load: " + fullpath);
+//   }
+//   
+//   // app
+//   var fullpath = VN_BOOTSTRAP_APPLICATION + '.js';
+//   // console.log("need to load " + fullpath);
+//   var r = new XMLHttpRequest();
+//   r.open("GET", fullpath, false);
+//   r.send(null);
+//   // console.log(r.responseText);
+//   
+//   // load the root gem
+//   // vn_gem_boot(VN_BOOTSTRAP_APPLICATION, "", r.responseText);
+//   // console.log(r.responseText);
+//   eval(r.responseText);
+//   // we can now start the VM
+//   // rb_call_inits();
+//   
+//   
+//   
+//   // run the main file
+//   // filename = '/' + filename + '.rb';
+//   // console.log(filename);
+//   // console.log(vn_fs_path_hash[filename]);
+//   // rb_require_file(filename);
+// }
+
+// /**
+//   Main entry point (ish). At this point, only the core library exists, and all the
+//   inits() have been called. In development mode, VN_MAIN_BNDLE_NAME will be used to
+//   load the root .rb file. In production mode, it will load the root .vn file. which
+//   is a bundle. for now, assume everything is a .vn file.
+// */
+// function rb_run_vm() {
+//   vn_bundle_load_at_path(VN_MAIN_BUNDLE_NAME, function(bundle) {
+//     var f = bundle.files['lib/' + VN_MAIN_BUNDLE_NAME + '.rb'];
+//     // require_file...
+//     var o = eval(f.source);
+//     // o is our opcodes..
+//     f.required = true;
+//     
+//     // run vm.
+//     rb_iseq_eval(o);
+//   });
+// }
+
+/**
+  Array of the loadpaths - i.e. where to look for 'require()' statements
+*/
+var ruby_loadpath;
+
+/**
+  load path initialization
+*/
+function ruby_init_loadpath() {
+  ruby_loadpath = [""];
+};
+
+/**
+  Add path to the loadpaths array
+*/
+function ruby_incpush(path) {
+  ruby_loadpath.push(path);
+};
+
+
+/**
+  array of full filenames which have been included: these should be the same 
+  names as appear in vn_fs_path_hash
+*/
+var rb_required_files = {};
+
+/**
+  Actually do a require with the given filename.
+  
+  Already checked file exists, and we pass the raw filename which is already in
+  the vn_fs_path_hash. This method marks the file as being already required and
+  will then exectute the file, by putting it to the top of the vm.
+*/
+function rb_require_file(file_path) {
+  if (rb_required_files[file_path]) {
+    // console.log("Already required " + file_path);
+  }
+  else {
+    rb_required_files[file_path] = true;
+    if (file_path.substr(file_path.length - 3) === '.js') {
+      // THIS shoulesnt ever happen now..
+      throw "no js includes!"
+      
+      // // javascript
+      // // with (window) { 
+      //   // eval(vn_fs_path_hash[file_path]);
+      // // }
+      // eval(vn_fs_path_hash[file_path]);
+      // if (window.execScript) {
+      // 
+      //     window.execScript(vn_fs_path_hash[file_path]);
+      //   }
+      //   else {
+      //     with (window) {
+      //       eval(vn_fs_path_hash[file_path]);
+      //     }
+      //     
+      //   }
+    }
+    else {
+      // ruby
+      rb_iseq_eval(eval(vn_fs_path_hash[file_path]));
+    }
+  }
+}
+
+/**
+  Main entry point for a require statement.
+*/
+function rb_f_require(obj, path) {
+  path = rb_file_s_expand_path(1, [path], nil);
+  // the file this was called from (basically last but one sf)
+  var called_from_file = rb_top_vm.cfs[rb_top_vm.cfs.length - 2].iseq[3];
+  var correct_path;
+  // console.log("want to require: " + path + '.rb');
+  // find the file..
+  var found = rb_find_require_path(path);
+  if (found === nil) {
+    throw "cannot find require: " + path + ", called from " + called_from_file;
+  }
+  else {
+    // console.log(found);
+    rb_require_file(found);
+    return true;
+  }
+};
+
+/**
+  find a require statement path. Returns the full path, or nil if not found.
+*/
+function rb_find_require_path(path) {
+  var try_path;
+  for (var i = 0; i < ruby_loadpath.length; i++) {
+    // try base
+    try_path = ruby_loadpath[i] + path + '.rb';
+    if (vn_fs_path_hash[try_path]) {
+      return try_path;
+    }
+    // try without .rb extension incase we included it in path
+    try_path = ruby_loadpath[i] + path;
+    if (vn_fs_path_hash[try_path]) {
+      return try_path;
+    }
+  }
+  return nil;
+};
+
+/**
+  load root path - only called from js
+*/
+function rb_loadpath(path) {
+  var found = rb_find_require_path(path);
+  if (found === nil) {
+    throw "cannot find require: " + path + ", called from " + called_from_file;
+  }
+  else {
+    rb_require_file(found);
+    return true;
+  }
+};
+
+/**
+  Load, parse, eval the given text
+*/
+function rb_eval_raw(str) {
+  
+}
+
+function Init_load() {
+  // require
+  rb_define_method(rb_cBasicObject, "require", rb_f_require, 1);
+}