smparkes-envjs 0.0.3

data/README

@@ -0,0 +1,101 @@
+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:
+     window.location = "some/file.html";
+     Envjs("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:
+
+   a) standard window.load method:
+     load('env.rhino.js');
+     window.location = "some/file.html";
+     Envjs("some/file.html");
+    
+   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();
+
+   c) Other JavaScript frameworks have their own methods of setup, but the general pattern is:
+     // load env.js
+     // load your framework
+     // tell env.js the base DOM to model
+     // run any setup code for your framework
+     // tell the framework that the document is loaded
+
+4) Invoke the Envjs event loop at the end of your script:
+   Envjs.wait();
+    
+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,147 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+
+begin
+  require 'johnson/tracemonkey'
+  require 'johnson/cli'
+  require 'envjs/runtime'
+rescue Exception => e
+  # (temporarily) run out of local if gem not installed
+  $: << File.expand_path( File.join( File.dirname(__FILE__), "..", "lib" ) )
+  $: << File.expand_path( File.join( File.dirname(__FILE__), "..", "vendor", "johnson", "lib" ) )
+  require 'johnson/tracemonkey'
+  require 'johnson/cli'
+  require 'envjs/runtime'
+end
+
+RUNTIME = js = Johnson::Runtime.new
+RUNTIME.extend Envjs::Runtime
+
+RUNTIME.load Envjs::ENVJS
+
+if ARGV.length > 0
+
+  begin
+    ARGV.each do |file|
+      if file =~ /\.x?html?$/
+        RUNTIME.evaluate("window.location = '#{file}'", file, 1)
+      else
+        RUNTIME.load file
+      end
+    end
+  rescue Johnson::Error => je
+    if je.message.match /<SystemExit: exit>/
+      exit
+    end
+    raise je
+  end
+
+  RUNTIME.wait
+
+else
+
+  require "readline"
+  require "johnson/cli"
+
+  RUNTIME.evaluate(Johnson::CLI::JS)
+
+  EXIT_VERBS = [nil] + %w(exit quit)
+
+  local_binding = binding
+  ruby_readline = []
+
+  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)
+    if EXIT_VERBS.include?(input)
+      puts if input.nil?
+      exit
+    end
+  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)
+    rescued { puts "=> " + RUNTIME.evaluate(expression, "(console)").inspect }
+  end
+
+  def eval_in_ruby(expression, bind_to)
+    rescued { puts "=> " + eval(expression, bind_to).inspect }
+  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
+
+  loop do
+    input = Readline.readline("js> ", true)
+    handle_exit(input)
+    
+    if input =~ /^rb\s+(.+)$/
+      eval_in_ruby($1, local_binding)
+      next
+    end
+    
+    if input == "rb"
+      js_readline = copy_history
+      paste_history(ruby_readline)
+      
+      loop do
+        input = Readline.readline("rb> ", true)
+        handle_exit(input)
+
+        break if input == "js"
+
+        if input =~ /^js\s+(.+)$/
+          eval_in_js($1)
+          next
+        end
+
+        eval_in_ruby(input, local_binding)
+      end
+      
+      ruby_readline = copy_history
+      paste_history(js_readline)
+      next
+    end
+    
+    eval_in_js(input)
+  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,98 @@
+//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);
+                    }
+                };
+                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();

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/" $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/" $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

data/bin/test-prototype.sh

@@ -0,0 +1,54 @@
+#!/bin/sh
+
+# Usage: test-prototype.sh [version]
+# Currently supported versions: 1.6.0.3
+#
+# This script will check out the Prototype development tree from Github 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.6.0.3"; fi
+    DEBUG=1
+else 
+    echo 'jquery'
+    if [ -n "$1" ]; then VERSION="$1"; else VERSION="1.6.0.3"; fi
+    DEBUG=0
+fi
+
+PROTOTYPE_DIR="test/vendor/Prototype/$VERSION";
+
+ant concat
+
+if [ ! -d "$PROTOTYPE_DIR" ]; then
+    git clone git://github.com/sstephenson/prototype.git $PROTOTYPE_DIR
+    # - prepares tests - #
+    cd $PROTOTYPE_DIR
+    git submodule init #allow prototype to discover test framework dependencies
+    git submodule update #load the dicovered dependencies
+    cd -
+fi
+
+#replace thier test html template erb (malformed html on purpose..really???)
+cat bin/prototype_1.6.0.3_tmpl.txt > $PROTOTYPE_DIR/test/unit/templates/default.erb
+sed 's/runner\.run/ /g' $PROTOTYPE_DIR/Rakefile > $PROTOTYPE_DIR/Rakefile
+cd $PROTOTYPE_DIR
+rake test 
+cd -
+
+cp dist/env.rhino.js $PROTOTYPE_DIR/test/unit/tmp/env.js
+cp dist/env-js.jar $PROTOTYPE_DIR/test/unit/tmp/env-js.jar
+cp bin/prototype-$VERSION-test.js $PROTOTYPE_DIR/test/unit/tmp/test.js
+
+
+cd $PROTOTYPE_DIR/test/unit/tmp
+if [ $DEBUG -eq 1 ]; then
+    echo 'running with rhino debugger'
+    java -cp env-js.jar org.mozilla.javascript.tools.envjs.Main test.js;
+else
+    echo 'running with rhino'
+    java -cp env-js.jar org.mozilla.javascript.tools.envjs.Main test.js;
+fi
+