envjs 0.1.0

data/lib/envjs/net/cgi.rb

@@ -0,0 +1,94 @@
+require 'net/protocol'
+
+require 'envjs/net'
+
+class Envjs::Net::CGI
+
+  def save_and_set k, v
+    @saved[k] = ENV[k]
+    ENV[k] = v
+  end
+
+  def restore
+    @saved.keys.each do |k|
+      ENV[k] = @saved[k]
+    end
+    @saved = {}
+  end
+
+  def initialize xhr, data
+    if (match = %r((.*\.php)(\?(.*))?).match xhr.url).nil?
+      raise "Not CGI"
+    end
+
+    @saved = {}
+
+    begin
+
+      # p match[0]
+
+      path = match[1]
+      path.sub! %r(^file://), ""
+
+      save_and_set( "GATEWAY_INTERFACE", "CGI/1.1" )
+
+      save_and_set( "REQUEST_METHOD", xhr["method"] )
+      if ( match[3] )
+        save_and_set( "QUERY_STRING", match[3] )
+      end
+
+      if ct = xhr["headers"]["Content-Type"]
+        save_and_set( "CONTENT_TYPE", ct )
+      end
+
+      if data
+        save_and_set( "CONTENT_LENGTH", data.length.to_s )
+      end
+
+      xhr["headers"].each do |k,v|
+        k.gsub!("-","_")
+        k = "HTTP_"  + k
+        save_and_set( k, v )
+      end
+
+      result = nil
+
+      save_and_set( "PATH_INFO",  path )
+      save_and_set( "PATH_TRANSLATED",  path )
+      save_and_set( "REDIRECT_STATUS", "200" )
+
+      open("|php-cgi", "r+") do |php|
+        if data
+          php.write data
+          php.flush
+        end
+        result = php.read
+      end
+
+      result && result = result.split("\r\n")
+      @headers = {}
+      while line = result.shift
+        break if line == ""
+        match = /([^:]*):\s*(.*)/.match line
+        @headers[match[1]]=match[2]
+      end
+      # p "q", result.join("\r\n")
+      @body = result.join("\r\n")
+    ensure
+      restore
+    end
+
+  end
+
+  def each 
+    @headers.each do |k,v|
+      yield k, v
+    end
+  end
+
+  def finish
+  end
+
+  attr_reader :body
+
+end

data/lib/envjs/net/file.rb

@@ -0,0 +1,75 @@
+require 'net/protocol'
+
+require 'envjs/net'
+
+class Envjs::Net::File < Net::Protocol
+
+  class << self
+    attr_accessor :on_open
+  end
+
+  class Get
+    attr_accessor :path
+    def initialize path
+      @path = path
+    end
+  end
+
+  def initialize host, port
+  end
+
+  def self.start host, port
+    new( host, port ).start
+  end
+
+  def start
+    self
+  end
+
+  def finish
+  end
+
+  def request request
+    Response.new request.path
+  end
+
+  class Response
+    def initialize path
+      @path = path
+      on_open = Envjs::Net::File.on_open
+      on_open and on_open.call( path )
+      @file = File.new @path
+      @body = @file.read
+      @code = @file.nil? ? "404" : "200";
+      @file.close
+    end
+
+    def [] *args
+      nil
+    end
+
+    def each &block
+    end
+
+    def getHeaderFields
+      []
+    end
+
+    def getContentEncoding
+      nil
+    end
+
+    def getResponseCode
+      @file.nil? ? 404 : 200;
+    end
+
+
+    def getInputStream
+      self
+    end
+
+    attr_reader :body, :code
+
+  end
+
+end

data/lib/envjs/net.rb

@@ -0,0 +1,3 @@
+require 'envjs'
+
+module Envjs::Net; end

data/lib/envjs/options.rb

@@ -0,0 +1,11 @@
+require 'optparse'
+
+$envjsrb_deps = nil
+
+OptionParser.new do |o|
+
+  o.on("--deps path") do |path|
+    $envjsrb_deps = path
+  end
+
+end.parse!

data/lib/envjs/runtime.rb

@@ -0,0 +1,280 @@
+require 'envjs'
+require "open-uri"
+require 'rubygems'
+begin
+  require 'fsdb'
+rescue LoadError; end
+require 'envjs/net/file'
+
+module Envjs::Runtime
+
+  def self.extended object
+    object.instance_eval do
+
+      evaluate <<'EOJS'
+print = function() {
+  var l = arguments.length
+  for( var i = 0; i < l; i++ ) {
+    var s;
+    if ( arguments[i] === null ) {
+      s = "null";
+    } else if ( arguments[i] === undefined  ) {
+      s = "undefined"      
+    } else {
+      s = arguments[i].toString();
+    }
+    Ruby.print(s);
+    if( i < l-1 ) {
+      Ruby.print(" ");
+    }
+  }
+  Ruby.print("\n");
+  Ruby['$stdout'].flush();
+};
+EOJS
+
+      evaluate <<'EOJS'
+debug = function() {
+  var l = arguments.length
+  for( var i = 0; i < l; i++ ) {
+    var s;
+    if ( arguments[i] === null ) {
+      s = "null";
+    } else if ( arguments[i] === undefined  ) {
+      s = "undefined"      
+    } else {
+      s = arguments[i].toString();
+    }
+    Ruby['$stderr'].print(s);
+    if( i < l-1 ) {
+      Ruby['$stderr'].print(" ");
+    }
+  }
+  Ruby['$stderr'].print("\n");
+};
+EOJS
+
+      evaluate <<'EOJS'
+puts = function() {
+  var l = arguments.length
+  for( var i = 0; i < l; i++ ) {
+    var s;
+    if ( arguments[i] === null ) {
+      s = "null";
+    } else if ( arguments[i] === undefined  ) {
+      s = "undefined"      
+    } else {
+      s = arguments[i].toString();
+    }
+    Ruby.print(s);
+    Ruby.eval("$stdout.flush")
+  }
+};
+EOJS
+
+      master = global["$master"] = evaluate("new Object")
+      master.symbols = [ "Johnson", "Ruby", "print", "debug", "puts", "load", "reload", "whichInterpreter", "multiwindow" ]
+      master.symbols.each { |symbol| master[symbol] = global[symbol] }
+
+      master.whichInterpreter = "Johnson"
+
+      master.multiwindow = true
+
+      # calling this from JS is hosed; the ruby side is confused, maybe because HTTPHeaders is mixed in?
+      master.add_req_field = lambda { |r,k,v| r.add_field(k,v) }
+
+      db = lambda do
+        $envjsrb_deps && ( @db ||= FSDB::Database.new $envjsrb_deps )
+      end
+
+      top_level_js = nil
+
+      add_dep = nil
+
+      clear_deps = lambda do |w|
+        begin
+          if db.call
+            loc = w
+            begin loc = w.location; rescue; end
+            loc && ( loc = loc.to_s )
+            if ( loc !~ %r((http?s|file|about):) )
+              begin
+                loc = "file://" + Pathname(loc).realpath.to_s
+              rescue Errno::ENOENT; end
+            end
+            # $stderr.puts "clear", loc
+            if loc and loc != "about:blank"
+              paths = db.call[loc+".on.yml"] || []
+              paths.each do |path|
+                # $stderr.print "#{path} not by #{loc}\n";
+                db.call[path+".by.yml"].delete loc
+              end
+              # $stderr.print "#{loc} not on anything\n";
+              db.call.delete loc+".on.yml"
+            end
+          end
+          add_dep.call( nil, loc )
+        rescue Exception => e; $stderr.puts e, e.class; $stderr.puts e.backtrace; end
+      end
+
+      if $envjsrb_deps
+        Envjs::Net::File.on_open = clear_deps
+      end
+      
+      add_dep = lambda do |w, f|
+        if db.call
+          loc = nil
+          begin loc = w.location; rescue Exception; end
+          loc && ( loc = loc.to_s )
+          if ( loc && loc !~ %r((http?s|file|about):) )
+            loc = "file://" + Pathname(loc).realpath.to_s
+          end
+          path = f
+          if ( path !~ %r((http?s|file|about):) )
+            begin
+              path = "file://" + Pathname(path).realpath.to_s
+            rescue Errno::ENOENT
+              return
+            end
+          end
+          if !loc || loc == "about:blank"
+            tll = "file://" + Pathname(top_level_js).realpath.to_s
+            if ( tll != path ) 
+              loc = tll
+            end
+          end
+          if loc and loc != "about:blank"
+            on = db.call[loc+".on.yml"] || []
+            on << path
+            on.uniq!
+            db.call[loc+".on.yml"] = on
+            by = db.call[path+".by.yml"] || []
+            by << loc
+            by.uniq!
+            db.call[path+".by.yml"] = by
+            # $stderr.print "#{loc} on #{path}: #{db.call[loc+'.on.yml'].join(' ')}\n"
+            # $stderr.print "#{path} by #{loc}: #{db.call[path+'.by.yml'].join(' ')}\n"
+          end
+        end
+      end
+
+      (class << self; self; end).send :define_method, :top_level_load do |path|
+        # $stderr.print "tll #{path}\n"
+        top_level_js = path
+        clear_deps.call( path )
+      end
+
+      master.load = lambda { |*files|
+        if files.length == 2 && !(String === files[1])
+          f = files[0]
+          w = files[1]
+          v = open(f).read.gsub(/\A#!.*$/, '')
+          loc = nil
+          add_dep.call w, f
+          evaluate(v, f, 1, w, w, f)
+        else
+          load *files
+        end
+      }
+
+      master.reload = lambda { |*files|
+        if files.length == 2 && !(String === files[1])
+          f = files[0]
+          w = files[1]
+          v = open(f).read.gsub(/\A#!.*$/, '')
+          loc = nil
+          add_dep.call w, f
+          reevaluate(v, f, 1, w, w, f)
+        else
+          reload *files
+        end
+      }
+
+      master.evaluate = lambda { |v,w|
+        evaluate(v,"inline",1,w,w);
+      }
+
+      master.new_split_global_outer = lambda { new_split_global_outer }
+      master.new_split_global_inner = lambda { |outer,_| new_split_global_inner outer }
+
+      # create an proto window object and proxy
+
+      outer = new_split_global_outer
+      window = inner = new_split_global_inner( outer )
+
+      master.symbols.each do |symbol|
+        window[symbol] = master[symbol]
+      end
+
+      master.first_script_window = window
+
+      window["$master"] = master
+      window["$options"] = evaluate("new Object");
+      window["$options"].proxy = outer
+
+      window.load = lambda { |*files|
+        files.each do |f|
+          master.load.call f, window
+        end
+      }
+
+      window.reload = lambda { |*files|
+        files.each do |f|
+          master.reload.call f, window
+        end
+      }
+
+      ( class << self; self; end ).send :define_method, :wait do
+        master["finalize"] && master.finalize.call
+        master.timers && master.timers.wait
+      end
+
+      scripts = {}
+
+      ( 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
+        # print "eval in " + script[0,50].inspect + (scope ? scope.toString() : "nil") + "\n"
+        global = nil
+        scope ||= inner
+        if fn
+          compiled_script = scripts[fn]
+        end
+        # compiled_script = compile(script, file, line, global)
+        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
+        # print "eval in " + script[0,50].inspect + (scope ? scope.toString() : "nil") + "\n"
+        global = nil
+        scope ||= inner
+        compiled_script = compile(script, file, line, global)
+        if fn
+          scripts[fn] = compiled_script
+        end
+        evaluate_compiled_script(compiled_script,scope)
+      end
+
+      @envjs = inner
+
+      ( class << self; self; end ).send :define_method, :"[]" do |key|
+        key == "this" && evaluate("this") || @envjs[key]
+      end
+
+      ( class << self; self; end ).send :define_method, :"[]=" do |k,v|
+        @envjs[k] = v
+      end
+
+    end
+  end
+
+end

data/lib/envjs/tempfile.rb

@@ -0,0 +1,24 @@
+require 'tempfile'
+
+require 'envjs'
+
+class Envjs::TempFile < Tempfile
+
+  def initialize pattern, suffix = nil
+    super(pattern)
+
+
+    if suffix
+      new_path = path + "." + suffix
+      File.link path, new_path
+      File.unlink path
+      # blah ... implementation specific ...
+      @data[0] = @tmpname = new_path
+    end
+  end
+
+  def getAbsolutePath
+    path
+  end
+
+end

data/lib/envjs.rb

@@ -0,0 +1,23 @@
+module Envjs
+
+  def self.js_exception_stack e
+    result = %(Exception: )+e.to_s
+    e.stack.to_s.split(%(\n)).each do |line|
+      next if line == "@:0"
+      m = line.match(/(.*)@([^@]*)$/)
+      s = m[1]
+      limit = 50
+      if ( s.length > limit )
+        s = s[0,limit] + %(...)
+      end
+      result += "\n" + m[2]+%( )+s
+    end
+    result
+  end
+  
+  ENVJS = 
+    File.expand_path( File.join( File.dirname(__FILE__),
+                                  "envjs",
+                                  "env.js" ) )
+
+end

data/test/call-load-test.js

@@ -0,0 +1,15 @@
+load("test/qunit.js");
+
+Envjs("test/index.html", {});
+
+test("'index.html' loaded correctly via 'Envjs()' call", function(){
+    expect(1);
+    try{ ok(document.getElementById('body').id == "body",
+        "'index.html' page content available");
+    }catch(e){print(e);}
+});
+
+test("window.location= following Envjs() initialization flagged as error",
+     function(){
+    expect(0);
+});

data/test/debug.js

@@ -0,0 +1,53 @@
+// Init
+load("src/env.js");
+load("src/htmlparser.js");
+
+window.location = "test/index.html";
+
+window.onload = function(){
+	load("test/testrunner.js");
+	load("test/jquery.js");
+
+	var depth = 0;
+
+	function indent(){
+		var str = "";
+		for ( var i = 0; i < depth; i++ ) {
+			str += "  ";
+		}
+		return str;
+	}
+
+	function dump(name, args, ret){
+		print(name + ": " + Array.prototype.slice.call(args) + " - Return: " + ret);
+	}
+
+	for ( var method in jQuery.fn ) (function(method){ if ( method != "init" ) {
+		var old = jQuery.fn[method];
+		jQuery.fn[method] = function(){
+			print(indent() + method + ": " + Array.prototype.slice.call(arguments));
+			depth++;
+			var ret = old.apply(this, arguments);
+			depth--;
+			print(indent() + method + ": Return " + ret);
+			return ret;
+		};
+	} })(method);
+
+	for ( var method in jQuery ) (function(method){ if ( method != "prototype" && method != "fn" ) {
+		var old = jQuery[method];
+		jQuery[method] = function(){
+			print(indent() + "$." + method + ": " + Array.prototype.slice.call(arguments));
+			depth++;
+			var ret = old.apply(this, arguments);
+			depth--;
+			print(indent() + "$." + method + ": Return " + ret);
+			return ret;
+		};
+	} })(method);
+
+	jQuery.prototype.toString = DOMNodeList.prototype.toString;
+	Function.prototype.toString = function(){ return "function()"; };
+
+	print("Ready.");
+};