envjs 0.1.3 → 0.1.4

data/lib/envjs/event_loop.js

@@ -0,0 +1,204 @@
+(function(){
+  if ($master.eventLoop) {
+    throw new Error("event loop multiply defined");
+  }
+  var el = $master.eventLoop = {};
+
+  var $env = {};
+  $env.sync = function(f){return f;};
+  $env.error = function(s){
+    print("timer error: "+s);
+    if (s.stack) {
+      print("timer error: "+s.stack);
+    }
+  };
+  $env.sleep = function(t){ Ruby.sleep(t/1000.); };
+  
+  var $timers = [];
+  var $event_loop_running = false;
+  $timers.lock = $env.sync(function(fn){fn();});
+
+  var $timer = function(w, fn, interval){
+    this.w = w;
+    this.fn = fn;
+    this.interval = interval;
+    this.at = Date.now() + interval;
+    this.running = false; // allows for calling wait() from callbacks
+  };
+  
+  var convert_time = function(time) {
+    time = time*1;
+    if ( isNaN(time) || time < 0 ) {
+      time = 0;
+    }
+    // html5 says this should be at least 4, but the parser is using a setTimeout for the SAX stuff
+    // which messes up the world
+    var min = /* 4 */ 0;
+    if ( $event_loop_running && time < min ) {
+      time = min;
+    }
+    return time;
+  };
+
+  var enter_and_exec = function(w,fn) {
+
+  };
+
+  el.setTimeout = function(w, fn, time){
+    var num;
+    time = convert_time(time);
+    $timers.lock(function(){
+      num = $timers.length+1;
+      var tfn;
+      if (typeof fn == 'string') {
+        tfn = function() {
+          try {
+            eval(fn);
+          } catch (e) {
+            $env.error(e);
+          } finally {
+            el.clearInterval(num);
+          }
+        };
+      } else {
+        tfn = function() {
+          try {
+            fn();
+          } catch (e) {
+            $env.error(e);
+          } finally {
+            el.clearInterval(num);
+          }
+        };
+      }
+      $timers[num] = new $timer(w, tfn, time);
+    });
+    return num;
+  };
+
+  el.setInterval = function(w, fn, time){
+    time = convert_time(time);
+    if ( time < 10 ) {
+      time = 10;
+    }
+    if (typeof fn == 'string') {
+      var fnstr = fn; 
+      fn = function() { 
+        eval(fnstr);
+      }; 
+    }
+    var num;
+    $timers.lock(function(){
+      num = $timers.length+1;
+      $timers[num] = new $timer(w, fn, time);
+    });
+    return num;
+  };
+
+  el.clear = el.clearInterval = el.clearTimeout = function(num){
+    //$log("clearing interval "+num);
+    $timers.lock(function(){
+      if ( $timers[num] ) {
+        delete $timers[num];
+      }
+    });
+  };	
+
+  // wait === null/undefined: execute any timers as they fire, waiting until there are none left
+  // wait(n) (n > 0): execute any timers as they fire until there are none left waiting at least n ms
+  // but no more, even if there are future events/current threads
+  // wait(0): execute any immediately runnable timers and return
+      // wait(-n): keep sleeping until the next event is more than n ms in the future
+
+  // FIX: make a priority queue ...
+
+  el.wait = function(wait) {
+    // print("wait",wait,$event_loop_running);
+    var fired = false;
+    var delta_wait;
+    if (wait < 0) {
+      delta_wait = -wait;
+      wait = 0;
+    }
+    var start = Date.now();
+    var old_loop_running = $event_loop_running;
+    $event_loop_running = true; 
+    if (wait !== 0 && wait !== null && wait !== undefined){
+      wait += Date.now();
+    }
+    for (;;) {
+      var earliest;
+      $timers.lock(function(){
+        earliest = undefined;
+        for(var i in $timers){
+          if( isNaN(i*0) ) {
+            continue;
+          }
+          var timer = $timers[i];
+          if( !timer.running && ( !earliest || timer.at < earliest.at) ) {
+            earliest = timer;
+          }
+        }
+      });
+      var sleep = earliest && earliest.at - Date.now();
+      if ( earliest && sleep <= 0 ) {
+        var f = earliest.fn;
+        var previous = $master.first_script_window;
+        fired = true;
+        try {
+          earliest.running = true;
+          $master.first_script_window = earliest.w;
+          f();
+        } catch (e) {
+          $env.error(e);
+        } finally {
+          earliest.running = false;
+          $master.first_script_window = previous;
+        }
+        var goal = earliest.at + earliest.interval;
+        var now = Date.now();
+        if ( goal < now ) {
+          earliest.at = now;
+        } else {
+          earliest.at = goal;
+        }
+        continue;
+      }
+
+      // bunch of subtle cases here ...
+      if ( !earliest ) {
+        // no events in the queue (but maybe XHR will bring in events, so ...
+        if ( !wait || wait < Date.now() ) {
+          // Loop ends if there are no events and a wait hasn't been requested or has expired
+          break;
+        }
+        // no events, but a wait requested: fall through to sleep
+      } else {
+        // there are events in the queue, but they aren't firable now
+        // print(delta_wait,sleep);
+        if ( delta_wait && sleep <= delta_wait ) {
+          // if they will happen within the next delta, fall through to sleep
+        } else if ( wait === 0 || ( wait > 0 && wait < Date.now () ) ) {
+          // loop ends even if there are events but the user specifcally asked not to wait too long
+          break;
+        }
+        // there are events and the user wants to wait: fall through to sleep
+      }
+
+      // Related to ajax threads ... hopefully can go away ..
+      var interval =  el.wait.interval || 100;
+      if ( !sleep || sleep > interval ) {
+        sleep = interval;
+      }
+      // the parser sets the timeout at 1 ... the chances of us getting back through this loop in that amount of time
+      // are small, no need to both the driver for something so small; just spin
+      if (sleep>1) {
+        $env.sleep(sleep);
+      }
+    }
+    $event_loop_running = old_loop_running;
+    // print("unwait",earliest,sleep);
+    return [ fired, earliest && sleep ];
+  };
+
+}());

data/lib/envjs/runtime.rb

@@ -11,7 +11,59 @@ module Envjs::Runtime
   def self.extended object
     object.instance_eval do
 
-      evaluate <<'EOJS'
+      outer = nil
+      scripts = {}
+      
+      master = global["$master"] = evaluate("new Object", nil, nil, nil, global)
+      
+      ( class << self; self; end ).send :define_method, :master do
+        master
+      end
+
+      ( class << self; self; end ).send :define_method, :evaluate do |*args|
+        ( script, file, line, global, scope, fn ) = *args
+        scope ||= outer["$inner"]
+        raise "cannot evaluate nil script" if script.nil?
+        raise "cannot evaluate without a scope" if scope.nil?
+        raise "outer given when inner needed" if !scope == global and !scope["isInner"]
+        # print "eval in " + script[0,50].inspect + scope.inspect + " " + ( scope ? scope.isInner.inspect : "none" ) + "\n"
+        global = nil
+        # scope ||= inner
+        if fn
+          compiled_script = scripts[fn]
+        end
+        compiled_script ||= compile(script, file, line, global)
+        raise "hell" if !compiled_script
+        if fn && !scripts[fn]
+          scripts[fn] = compiled_script
+        end
+        save = master["first_script_window"]
+        if false
+          p scope
+          if master["first_script_window"]
+            print "ignored: " +  ( scope["location"] ? scope["location"]["href"] : "nil" ) + " using " + ( master["first_script_window"]["location"] ?  master["first_script_window"]["location"]["href"] : "nil" ) + "\n"
+          else
+            print "pushing into " + ( scope["location"] ? scope["location"]["href"] : "nil" ) + "\n"
+          end
+        end
+
+        master["first_script_window"] ||= scope
+        raise "hell" if !master["first_script_window"]["isInner"] && master["first_script_window"] != self.global
+        v = nil
+        begin
+          v = evaluate_compiled_script(compiled_script,scope)
+          # p "pe", v, compiled_script, scope
+        rescue Exception => e
+          # p "oopsrt", e
+          raise e
+        ensure
+          master["first_script_window"] = save
+        end
+        # print "done\n"
+        v
+      end
+
+      evaluate( <<'EOJS', nil, nil, nil, global )
 print = function() {
   var l = arguments.length
   for( var i = 0; i < l; i++ ) {
@@ -33,7 +85,7 @@ print = function() {
 };
 EOJS
 
-      evaluate <<'EOJS'
+      evaluate <<'EOJS', nil, nil, nil, global
 debug = function() {
   var l = arguments.length
   for( var i = 0; i < l; i++ ) {
@@ -54,7 +106,7 @@ debug = function() {
 };
 EOJS
 
-      evaluate <<'EOJS'
+      evaluate <<'EOJS', nil, nil, nil, global
 puts = function() {
   var l = arguments.length
   for( var i = 0; i < l; i++ ) {
@@ -72,10 +124,15 @@ puts = function() {
 };
 EOJS
 
-      master = global["$master"] = evaluate("new Object")
       master["runtime"] = self
-      master.symbols = [ "Johnson", "Ruby", "print", "debug", "puts", "load", "reload", "whichInterpreter", "multiwindow" ]
+      window_index = -1
+      master["next_window_index"] = lambda { window_index += 1 }
+      master.symbols = [ "Johnson", "Ruby", "print", "debug", "puts", "load", "reload", "whichInterpreter", "multiwindow", "seal" ]
       master.symbols.each { |symbol| master[symbol] = global[symbol] }
+      master["seal"] = lambda do |*args|
+        object, deep = *args
+        seal object, deep
+      end
 
       master.whichInterpreter = "Johnson"
 
@@ -180,8 +237,10 @@ EOJS
 
       master.load = lambda { |*files|
         if files.length == 2 && !(String === files[1])
+          # now = Time.now
           f = files[0]
           w = files[1]
+          # p "load", f, w
 
           # Hmmm ...
           uri = URI.parse f
@@ -206,6 +265,7 @@ EOJS
           loc = nil
           add_dep.call w, f
           evaluate(v, f, 1, w, w, f)
+          # print "load #{uri_s}: #{Time.now-now}\n"
         else
           load *files
         end
@@ -265,63 +325,43 @@ EOJS
       # create an proto window object and proxy
 
       outer = new_split_global_outer
-      window = inner = new_split_global_inner( outer )
+      inner = new_split_global_inner( outer )
 
       master.symbols.each do |symbol|
-        window[symbol] = master[symbol]
+        inner[symbol] = master[symbol]
       end
 
-      master.first_script_window = window
+      inner["$inner"] = inner
+      inner["$master"] = master
+      inner["$options"] = evaluate("new Object", nil, nil, nil, inner);
+      inner["$options"].proxy = outer
 
-      window["$inner"] = inner
-      window["$master"] = master
-      window["$options"] = evaluate("new Object");
-      window["$options"].proxy = outer
-
-      window.evaluate = lambda { |s|
-        return master.evaluate.call(s,window);
+      inner.evaluate = lambda { |s|
+        return master.evaluate.call(s,inner);
       }
 
-      window.load = lambda { |*files|
+      inner.load = lambda { |*files|
         files.each do |f|
-          master.load.call f, window
+          master.load.call f, inner
         end
       }
 
-      window.reload = lambda { |*files|
+      inner.reload = lambda { |*files|
         files.each do |f|
-          master.reload.call f, window
+          master.reload.call f, inner
         end
       }
 
       ( class << self; self; end ).send :define_method, :wait do
         master["finalize"] && master.finalize.call
-        master.timers && master.timers.wait
+        master.eventLoop && master.eventLoop.wait
       end
 
-      scripts = {}
-
-      ( class << self; self; end ).send :define_method, :become_first_script_window do
+      ( class << self; self; end ).send :define_method, :_become_first_script_window do
         # p "heh ++++++++++++++++++++++++++++", inner, master.first_script_window
         inner = master.first_script_window
       end
 
-      ( class << self; self; end ).send :define_method, :evaluate do |*args|
-        ( script, file, line, global, scope, fn ) = *args
-        raise "cannot evaluate nil script" if script.nil?
-        # print "eval in " + script[0,50].inspect + scope.inspect + " " + ( scope ? scope.isInner.inspect : "none" ) + "\n"
-        global = nil
-        scope ||= inner
-        if fn
-          compiled_script = scripts[fn]
-        end
-        compiled_script ||= compile(script, file, line, global)
-        if fn && !scripts[fn]
-          scripts[fn] = compiled_script
-        end
-        evaluate_compiled_script(compiled_script,scope)
-      end
-
       ( class << self; self; end ).send :define_method, :reevaluate do |*args|
         ( script, file, line, global, scope, fn ) = *args
         raise "cannot evaluate nil script" if script.nil?
@@ -332,20 +372,58 @@ EOJS
         if fn
           scripts[fn] = compiled_script
         end
-        evaluate_compiled_script(compiled_script,scope)
+        begin
+          evaluate_compiled_script(compiled_script,scope)
+        rescue Exception => e
+          p e
+          raise e
+        end
       end
 
-      @envjs = inner
-
       ( class << self; self; end ).send :define_method, :"[]" do |key|
-        key == "this" && evaluate("this") || @envjs[key]
+        # key == "this" && evaluate("this", nil, nil, nil, inner) || @envjs[key]
+        key == "this" && outer || outer[key]
       end
 
       ( class << self; self; end ).send :define_method, :"[]=" do |k,v|
-        @envjs[k] = v
+        # inner[k] = v
+        outer[k] = v
+      end
+
+      master.load.call Envjs::EVENT_LOOP, global
+      
+if false
+      static_outer = new_split_global_outer
+      static_inner = new_split_global_inner static_outer
+      
+      master.symbols.each do |symbol|
+        static_inner[symbol] = master[symbol]
+      end
+
+      static_inner["$inner"] = static_inner
+      static_inner["$master"] = master
+
+      master.load.call Envjs::STATIC, static_inner
+
+      master["static"] = static_inner
+end
+if true
+      static = new_global
+      
+      master.symbols.each do |symbol|
+        static[symbol] = master[symbol]
       end
 
-      load Envjs::ENVJS
+      static["$master"] = master
+
+      master.load.call Envjs::STATIC, static
+
+      master["static"] = static
+end
+
+      master.load.call Envjs::ENVJS, inner
+
+      inner = nil
     end
   end