envjs 0.1.0

data/README

@@ -0,0 +1,113 @@
+env.js : A pure JavaScript browser environment.
+Developed by John Resig (http://ejohn.org)
+
+Major Contributers:
+Chris Thatcher (http://github.com/thatcher)
+
+GitHub repositories:
+http://github.com/jeresig/env-js/
+http://github.com/thatcher/env-js/
+
+Mailing List:
+http://groups.google.com/group/envjs
+
+Lighthouse (Bug Tracking):
+http://envjs.lighthouseapp.com/projects/21590-envjs/
+
+Build Status:
+http://runcoderun.com/thatcher/env-js
+
+Original blog post:
+http://ejohn.org/projects/bringing-the-browser-to-the-server/
+
+Rhino (Java-based JavaScript engine)
+http://www.mozilla.org/rhino/
+
+Getting the code:
+
+* Check the code out from git: git clone git://github.com/thatcher/env-js.git
+
+Building:
+* run "ant concat"
+* Creates a platform-agnostic "dist/env.js" file and a Rhino-specific "dist/env.rhino.js" file.
+
+Testing:
+* Checkout qunit: "git submodule update --init"
+* run "ant test"
+
+Java command line:
+
+env.rhino.js can be run either with a "generic" version of the Rhino
+library (js.jar), or with the repackaged/extended version of Rhino
+supplied with env.js (env-js.jar).  If your application uses multiple
+windows, frames, or iframes, or if it depends on precise adherence to
+JavaScript object scoping in event handlers, you will have to use
+env-js.jar.  Simple applications may be able to run with the generic
+version of Rhino.
+
+The command line used for testing env.js can be found in build.xml,
+although the general form is:
+     java -jar [jar file] [javascript file]
+Where "jar file" is either "dist/env-js.jar", "rhino/js.jar", or your
+local path to a different version of the Rhino js.jar file.  The
+"javascript file" is the path to the JavaScript you wish to execute.
+
+Installing:
+1) Include the proper env.js file for your platform.
+     load('env.rhino.js'); //if in a Rhino script
+
+2) Tell env.js to load an HTML file from your file system that it should model:
+     Envjs("some/file.html");
+       or
+     var someWindow = window.open("some/file.html");
+       or
+     window.location = "some/file.html";
+
+   Optionally you can turn on/off settings by passing an options object:
+     Envjs("some/file.html", {log: function(msg){ console.debug(msg) }});
+
+3) Optionally trigger "document ready" events in one of these ways:
+
+4) Start processing of window(s)' event queue:
+     Envjs.wait();
+
+All together, the steps could be:
+
+   a) simplest method:
+     load('env.rhino.js');
+     Envjs("some/file.html");
+     Envjs.wait();
+
+   b) jQuery ready method:
+     load('env.rhino.js');
+     load('jquery-1.3.2.js');
+     Envjs("some/file.html");
+     load('some-code-that-sets-up-jquery-onready-behaviors.js')
+     jQuery.ready();
+     Envjs.wait();
+
+   c) Other JavaScript frameworks have their own methods of setup, but the general pattern is:
+     // step 1: load env.js
+     // optionally: load your framework(s)
+     // step 2: tell env.js the base DOM to model
+     // optionally: run any setup code for your framework(s0
+     // step 3: tell the framework that the document is loaded
+     // step 4: Envjs.wait();
+
+Note that env.js is currently limited to loading a single HTML page
+from the original window.  If you are going to load multiple pages in
+succession into the same window, load the first into a new window
+object using window.open().
+
+Testing jQuery Compatibility:
+* run ./bin/test-jquery.sh 1.3.2
+* run ./bin/test-jquery.sh 1.3.1
+* run ./bin/test-jquery.sh 1.2.6
+* Checks out the given jQuery tag from Subversion into test/vendor/jQuery/[version], 
+  moves dist/env.rhino.js into the correct location in their tree, and runs the test suites.
+
+Changes with new timer code:
+
+Previously with envjs, you could call Java's thread sleep() method to delay execution. This was mostly used in test suites. This may no
+longer work the same since it will inhibit all events from firing. You can now use the Envjs.wait(milliseconds) call to achieve an
+effect similar to calling sleep().

data/bin/envjsrb

@@ -0,0 +1,239 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'pathname'
+
+require 'envjs/options'
+
+require 'johnson/tracemonkey'
+require 'johnson/cli'
+require 'envjs/runtime'
+
+RUNTIME = js = Johnson::Runtime.new
+RUNTIME.extend Envjs::Runtime
+
+RUNTIME.load Envjs::ENVJS
+
+EXIT_VERBS = [nil] + %w(exit quit)
+  
+prepped = false
+ruby_readline = []
+js_readline = []
+local_binding = binding
+mode = nil
+
+(class<<self; self; end).send :define_method, :prep do
+
+  return if prepped
+  prepped = true
+
+  require "readline"
+  require "johnson/cli"
+
+  RUNTIME.evaluate(Johnson::CLI::JS)
+
+  def copy_history
+    new_history = []
+    until Readline::HISTORY.empty?
+      new_history.push(Readline::HISTORY.pop)
+    end
+    new_history
+  end
+
+  def paste_history(old_history)
+    until old_history.empty?
+      Readline::HISTORY << old_history.pop
+    end
+  end
+
+  def handle_exit(input)
+    return EXIT_VERBS.include?(input)
+  end
+
+  def rescued(&block)
+    yield
+  rescue Exception => e
+    exit if SystemExit === e
+
+    puts e.message
+    puts e.backtrace.reject { |l| l =~ /bin\/johnson/ }
+  end
+
+  def eval_in_js(expression,stream)
+    rescued do
+      v = RUNTIME.evaluate(expression, "(console)")
+      stream.result { "=> " + v.inspect }
+  end
+  end
+
+  def eval_in_ruby(expression, bind_to, stream)
+    rescued do
+      v = eval(expression, bind_to)
+      stream.result { "=> " + v.inspect }
+    end
+  end
+  
+  (class<<self; self; end).send :define_method, :do_loop do |stream|
+  # def foo
+
+    catch "Breakout" do
+      loop do
+        mode = :js
+        input = stream.next("js> ")
+        input and input.chomp!
+        begin stream.exit(input); throw "Breakout" end if handle_exit(input)
+        
+        if input =~ /^rb\s+(.+)$/
+          eval_in_ruby($1, local_binding, stream)
+          next
+        end
+        
+        if input == "rb"
+          js_readline = copy_history
+          paste_history(ruby_readline)
+          
+          loop do
+            mode = :rb
+            # input = Readline.readline("rb> ", true)
+            input = stream.next("rb> ")
+            begin stream.exit(input); throw "Breakout" end if handle_exit(input)
+
+            break if input == "js"
+
+            if input =~ /^js\s+(.+)$/
+              eval_in_js($1)
+              next
+            end
+
+            eval_in_ruby(input, local_binding, stream)
+          end
+          
+          ruby_readline = copy_history
+          paste_history(js_readline)
+          next
+        end
+        
+        eval_in_js(input, stream)
+      end
+    end
+  end
+end
+
+if ARGV.length > 0
+
+  begin
+    about_blank = true
+    ARGV.each do |file|
+      if file == "about:blank"
+        RUNTIME.wait
+        RUNTIME.evaluate("window.location = 'about:blank'", "(comand line)", 1)
+        about_blank = true
+      elsif file =~ /\.x?html?$/ || file =~ %r(^https?://)
+        # this might want to go alway; jazrb does it manually now, which I think was the use case
+        # that wanted this
+        if !about_blank
+          RUNTIME.wait
+          RUNTIME.evaluate("window.location = 'about:blank'", "(comand line)", 1)
+        end
+        RUNTIME.wait
+        RUNTIME.evaluate("window.location = 'file://#{Pathname.new(file).realpath}'", file, 1)
+        about_blank = false
+      else
+        RUNTIME.become_first_script_window
+        RUNTIME.top_level_load file
+        RUNTIME.load file
+      end
+    end
+  rescue Johnson::Error => je
+    if je.message.match /<SystemExit: exit>/
+      exit
+    end
+    raise je
+  end
+
+  RUNTIME.wait
+
+else
+
+  prep
+
+  if !(files = Dir[".envjsrbrc",File.join(ENV["HOME"],".envjsrbrc")]).empty?
+    file = Class.new do
+      def initialize f
+        @file = open f
+      end
+      def next prompt
+        @file.gets
+      end
+      def result &block
+      end
+      def exit v; end
+    end.new files[0]
+
+    do_loop file
+  end
+
+  options = Johnson::CLI::Options.parse!(ARGV)
+
+  options.load_paths.each { |d| $LOAD_PATH << d }
+  options.paths_to_require.each { |p| RUNTIME.evaluate("Johnson.require('#{p}')") }
+  options.files_to_preload.each { |f| RUNTIME.load(f) }
+
+  unless options.expressions.empty?
+    options.expressions.each { |e| RUNTIME.evaluate(e, '-e') }
+    exit if options.files_to_evaluate.empty?
+  end
+
+  unless options.files_to_evaluate.empty?
+    RUNTIME[:arguments] = options.arguments
+    
+    options.files_to_evaluate.each do |file|
+      RUNTIME.load(file)
+    end
+    
+    exit
+  end
+
+  reader = Class.new do
+    def next prompt
+      Readline.readline(prompt, true)
+    end
+    def result
+      puts yield
+    end
+    def exit v; puts if v.nil?; end
+  end.new
+
+  begin
+  open(File.join(ENV["HOME"],".envjsrb.js")) do |f|
+    js_readline = f.read.split("\n")
+  end
+  rescue; end
+
+  begin
+  open(File.join(ENV["HOME"],".envjsrb.ruby")) do |f|
+    ruby_readline = f.read.split("\n")
+  end
+  rescue; end
+
+  case mode
+  when :js; paste_history js_readline
+  when :rb; paste_history ruby_readline
+  end
+
+  do_loop reader
+
+  case mode
+  when :js; js_readline = copy_history
+  when :rb; ruby_readline = copy_history
+  end
+
+  open(File.join(ENV["HOME"],".envjsrb.js"),"w") do |f|
+    f.write js_readline[0..100].join("\n")+"\n"
+  end
+
+  open(File.join(ENV["HOME"],".envjsrb.ruby"),"w") do |f|
+    f.write ruby_readline[0..100].join("\n")+"\n"
+  end
+
+end

data/bin/jquery-1.2.6-test.js

@@ -0,0 +1,33 @@
+// Init
+load("build/runtest/env.js");
+
+var isLocal;
+window.onload = function(){
+    isLocal  = !!(window.location.protocol == 'file:');
+    
+    // Load the test runner
+    load("dist/jquery.js",
+        "build/runtest/testrunner.js");
+    
+    // Load the tests
+    load(
+        "test/unit/core.js",
+        "test/unit/selector.js",
+        "test/unit/event.js",
+        "test/unit/fx.js",
+        "test/unit/dimensions.js",
+        
+        // offset relies on window.open, which is currently unimplemented in env.js
+        //"test/unit/offset.js",
+        
+        // these tests require hitting a server, so we will need some clever env.js
+        // way of testing them
+        // by defining isLocal we can still load the test
+        "test/unit/ajax.js"
+    );
+    
+    // Display the results
+    results();
+};
+
+window.location = "test/index.html";

data/bin/jquery-1.3.1-test.js

@@ -0,0 +1,33 @@
+// Init
+load("build/runtest/env.js");
+
+var isLocal;
+window.onload = function(){
+    isLocal  = !!(window.location.protocol == 'file:');
+    
+    // Load the test runner
+    load("dist/jquery.js",
+        "build/runtest/testrunner.js");
+    
+    // Load the tests
+    load(
+        "test/unit/core.js",
+        "test/unit/selector.js",
+        "test/unit/event.js",
+        "test/unit/fx.js",
+        "test/unit/dimensions.js",
+        "test/unit/data.js",
+        
+        // offset relies on window.open, which is currently unimplemented in env.js
+        //"test/unit/offset.js",
+        
+        // these tests require hitting a server, so we will need some clever env.js
+        // way of testing them
+        "test/unit/ajax.js"
+    );
+    
+    // Display the results
+    results();
+};
+
+window.location = "test/index.html";

data/bin/jquery-1.3.2-test.js

@@ -0,0 +1,106 @@
+//debugger;
+load("build/runtest/env.js");
+
+(function(Envjs){
+    var $env = Envjs.$env;
+
+    Envjs("test/index.html", {
+        //let it load the script from the html
+		logLevel: $env.INFO,
+        scriptTypes: {
+            "text/javascript"   :true
+        },
+        afterScriptLoad:{
+            'qunit/testrunner.js': function(){
+                //hook into qunit.log
+                var count = 0;
+                QUnit.log = function(result, message){
+                    $env.log('(' + (count++) + ')[' + 
+                        ((!!result) ? 'PASS' : 'FAIL') + '] ' + message);
+                };
+                //hook into qunit.done
+                QUnit.done = function(pass, fail){
+                    $env.warn('Writing Results to File');
+                    jQuery('script').each(function(){
+                        this.type = 'text/envjs';
+                    });
+                    $env.writeToFile(
+                        document.documentElement.xml, 
+                        $env.location('jqenv-'+Date.now()+'.html')
+                    );
+                };
+                
+                //allow jquery to run ajax
+                isLocal = false;
+                
+                
+                var unsafeStop = stop,
+                    unsafeStart = start,
+                    isStopped = null;
+
+                var config_timeout;
+                stop = function(timeout){
+                    if(isStopped === null || isStopped === false){
+                        $env.log('PAUSING QUNIT');
+                        isStopped = true;
+                        unsafeStop.call(this);
+                        timeout = ( timeout && timeout > 0 ) ? timeout : 10000;
+	                if (timeout)
+	                  config_timeout = setTimeout(function() {
+        			    QUnit.ok( false, "Test timed out" );
+        			    start();
+        		      }, timeout);
+                      /* $env.wait() */
+                    }
+                };
+                start = function(){
+                    if(isStopped === null || isStopped === true ){
+                        $env.log('RESTARTING QUNIT');
+                        isStopped = false;
+                        if(config_timeout) {
+                          clearTimeout(config_timeout);
+                          config_timeout = undefined;
+                        }
+                        unsafeStart.call(this);
+                    }
+                };
+                //we know some ajax calls will fail becuase
+                //we are not running against a running server
+                //for php files
+                var handleError = jQuery.handleError;
+                jQuery.handleError = function(){
+                    ok(false, 'Ajax may have failed while running locally');
+                    try{
+                        handleError(arguments);
+                    }catch(e){}
+                    //allow tests to gracefully continue
+                    start();
+                };
+                //allow unanticipated xhr error with no ajax.handleError 
+                //callback (eg jQuery.getScript) to exit gracefully
+                $env.onInterrupt = function(){
+                    $env.info('thread interupt: gracefully continuing test');
+                    start();
+                };
+                
+               
+                $env.onScriptLoadError = function(script){
+                    Envjs.error("failed to load script \n"+script.text);    
+                    ok(false, 'Ajax may have failed to load correct script while running locally');
+                    //allow tests to gracefully continue
+                    start();
+                };
+            }
+        }
+    });
+    
+})(Envjs);
+
+Envjs.wait();
+
+// Local Variables:
+// espresso-indent-level:4
+// c-basic-offset:4
+// tab-width:4
+// mode:auto-revert
+// End:

data/bin/prototype-1.6.0.3-test.js

@@ -0,0 +1,82 @@
+//debugger;
+load("env.js");
+
+(function($env){
+    
+    
+    $env("array_test.html", {
+        //let it load the script from the html
+        scriptTypes: {
+            "text/javascript"   :true
+        },
+        afterload:{
+            'lib_assets/unittest.js': function(){
+                 //hook into some messaging
+                 var assertBlock = Test.Unit.Assertions.assertBlock;
+                 Test.Unit.Assertions.assertBlock = function(){
+                    $env.log(arguments[0]);
+                    return assertBlock(arguments);
+                 };
+                 Test.Unit.Logger.prototype.initialize = function(id) {
+                     this.id = id;
+                     $env.debug(' ['+this.id+'] initialized');
+                 };
+                  
+                 Test.Unit.Logger.prototype.start = function(testName) {
+                     this.currentTest = testName;
+                     $env.debug(' ['+this.id+'] starting test ('+this.currentTest+')');
+                 };
+                  
+                  
+                 Test.Unit.Logger.prototype.setStatus = function(status) {
+                     $env.log(' ['+this.id+'] ('+this.currentTest+') '+status);
+                 };
+                  
+                 Test.Unit.Logger.prototype.finish = function(status, summary) {
+                     $env.log(' ['+this.id+'] ('+this.currentTest+
+                         ') '+status+' '+summary.replace(/\n/g,"\t"));
+                 };
+                  
+            }
+        }
+    });
+    $env.writeToFile(
+        document.documentElement.xml, 
+        $env.location('jqenv-array_test-'+Date.now()+'.html')
+    );
+    
+    $env("base_test.html", {
+        //let it load the script from the html
+        scriptTypes: {
+            "text/javascript"   :true
+        }
+    });
+    $env.writeToFile(
+        document.documentElement.xml, 
+        $env.location('jqenv-base_test-'+Date.now()+'.html')
+    );
+    
+    
+    $env("class_test.html", {
+        //let it load the script from the html
+        scriptTypes: {
+            "text/javascript"   :true
+        }
+    });
+    $env.writeToFile(
+        document.documentElement.xml, 
+        $env.location('jqenv-class_test-'+Date.now()+'.html')
+    );
+    
+    $env("date_test.html", {
+        //let it load the script from the html
+        scriptTypes: {
+            "text/javascript"   :true
+        }
+    });
+    $env.writeToFile(
+        document.documentElement.xml, 
+        $env.location('jqenv-date_test-'+Date.now()+'.html')
+    );
+    
+})(Envjs);

data/bin/prototype_1.6.0.3_tmpl.txt

@@ -0,0 +1,27 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <title>Unit test file | <%= title %> | <%= template_name %> template | <%= timestamp %></title>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
+  <script type="text/javascript" charset="utf-8">
+    var eventResults = {};
+    var originalElement = window.Element;
+  </script>
+  <%= script_tag('assets/prototype.js') %>
+  <%= script_tag('lib_assets/unittest.js') %>
+  <%= link_tag('lib_assets/unittest.css') %>
+  <%= css_fixtures %>
+  <%= js_fixtures %>
+  <%= test_file %>
+</head>
+<body>
+
+<div id="testlog"></div>
+
+<%= html_fixtures %>
+<script type="text/javascript" charset="utf-8">
+  eventResults.endOfDocument = true;
+</script>
+</body>
+</html>

data/bin/test-jquery.sh

@@ -0,0 +1,58 @@
+#!/bin/sh
+
+# Usage: test-jquery.sh [version]
+# Currently supported versions: 1.3.2, 1.3.1, and 1.2.6
+#
+# This script will check out the jQuery development tree from Subversion if necessary,
+# massage the testing scripts as necessary, copy our latest version of env.js into place,
+# and then run the test scripts.
+
+
+if [ -n "$2" ]; then 
+    echo 'debug'
+    if [ -n "$2" ]; then VERSION="$2"; else VERSION="1.3.2"; fi
+    DEBUG=1
+else 
+    echo 'jquery'
+    if [ -n "$1" ]; then VERSION="$1"; else VERSION="1.3.2"; fi
+    DEBUG=0
+fi
+
+JQUERY_DIR="test/vendor/jQuery/$VERSION";
+
+ant concat
+
+if [ ! -d "$JQUERY_DIR" ]; then
+  svn export http://jqueryjs.googlecode.com/svn/tags/$VERSION/ $JQUERY_DIR
+  case "$VERSION" in
+      "1.3.2")
+          rm -rf "$JQUERY_DIR/test/qunit"
+          svn export -r6173 http://jqueryjs.googlecode.com/svn/trunk/qunit $JQUERY_DIR/test/qunit
+          ;;
+      "1.3.1")
+          rm -rf "$JQUERY_DIR/test/qunit"
+          svn export -r6133 http://jqueryjs.googlecode.com/svn/trunk/qunit $JQUERY_DIR/test/qunit
+          ;;
+  esac
+fi
+
+cp dist/env.rhino.js $JQUERY_DIR/build/runtest/env.js
+cp dist/env-js.jar $JQUERY_DIR/build/js.jar
+cp bin/jquery-$VERSION-test.js $JQUERY_DIR/build/runtest/test.js
+
+if [ $DEBUG -eq 1 ]; then
+    echo 'enabling rhino debugger'
+    perl -pi~ -e "s/^JAR(.*)(-jar.*|-cp.*)/JAR\1 -cp \\$\{BUILD_DIR}\/js.jar org.mozilla.javascript.tools.debugger.Main -opt -1/" $JQUERY_DIR/Makefile;
+else
+    if [ "x$JOHNSON" == "x " ]; then
+        echo 'running with rhino'
+        perl -pi~ -e "s/^JAR(.*)(-jar.*|-cp.*)/JAR\1 -cp \\$\{BUILD_DIR}\/js.jar org.mozilla.javascript.tools.envjs.Main  -opt -1/" $JQUERY_DIR/Makefile;
+    else
+        echo 'running with johnson'
+        echo > $JQUERY_DIR/build/runtest/env.js
+        perl -pi~ -e "s/^JAR(.*)(-jar.*|-cp.*)/JAR = envjsrb/" $JQUERY_DIR/Makefile;
+    fi
+fi
+
+cd $JQUERY_DIR
+make runtest