envjs19 0.3.8.20101029121421

data/htmlparser/README

@@ -0,0 +1,34 @@
+Envjs make use the awesome project 'http://about.validator.nu/htmlparser/'
+which generates an HTML5 compliant parsing engine, written in Java, into
+javascript via GWT.
+
+The generated files are available in 
+    env-js/
+        src/
+            parser/
+                html5.js  
+                html5.min.js
+                html5.detailed.js
+                
+The various versions are simply generated with varying verbosity of source.
+html.js is the most readable at 60KB, html.detailed.js is almost too verbose at 
+over 120KB, and finally html5.min.js is totally unreadable but weighs in at only
+30KB.  By default the html5.min.js is included in Envjs releases because most
+folks aren't too worried about the gory details of the parser. 
+
+The scripts in this folder can be used to checkout and download the various
+components you will need to generate these yourself.
+
+Once generated, there are a couple very small and specific changes that must be
+made by hand to allow the parser to be initialized with the usual GWT hooks.
+
+You will need to download the appropiate gwt for your platform
+
+http://google-web-toolkit.googlecode.com/files/gwt-mac-1.5.1.tar.gz
+http://google-web-toolkit.googlecode.com/files/gwt-windows-1.5.1.zip
+http://google-web-toolkit.googlecode.com/files/gwt-linux-1.5.1.tar.bz2
+
+Our scripts expect that it will be available at 
+    env-js/
+        htmlparser/
+            gwt-1.5.1/

data/htmlparser/build.sh

@@ -0,0 +1,38 @@
+#!/bin/sh
+
+svn co https://whattf.svn.cvsdude.com/htmlparser/trunk/ html5
+
+cp BrowserTreeBuilder.java html5/gwt-src/nu/validator/htmlparser/gwt/BrowserTreeBuilder.java
+
+cp gwt-1.5.1/gwt-dev-*.jar gwt-1.5.1/gwt-dev.jar
+
+APPDIR=`dirname $0`/html5/;
+
+echo $APPDIR
+
+echo "Generating Minified HTMLParser"
+java -XstartOnFirstThread -Xmx256M -cp "$APPDIR/src:$APPDIR/gwt-src:$APPDIR/super:./gwt-1.5.1/gwt-user.jar:./gwt-1.5.1/gwt-dev.jar" com.google.gwt.dev.GWTCompiler -out "build/min" "$@" nu.validator.htmlparser.HtmlParser;
+cp ./build/min/nu.*.HtmlParser/nu.*.HtmlParser.nocache.js ./build/html5.min.js
+perl -pi~ -e "s/if\(j\.addEventListener\)(.*)50\)/\/\*envjsedit\*\//" ./build/html5.min.js 
+perl -pi~ -e "s/if\(j\.removeEventListener\)/if\(false\/\*envjsedit\*\/\)/" ./build/html5.min.js
+perl -pi~ -e "s/function kb\(\)/\/\*envjsedit\*\/var kb = Html5Parser = function\(\)/" ./build/html5.min.js
+
+echo "Generating Pretty HTMLParser"
+java -XstartOnFirstThread -Xmx256M -cp "$APPDIR/src:$APPDIR/gwt-src:$APPDIR/super:./gwt-1.5.1/gwt-user.jar:./gwt-1.5.1/gwt-dev.jar" com.google.gwt.dev.GWTCompiler -style PRETTY -out "build/pretty" "$@" nu.validator.htmlparser.HtmlParser;
+cp ./build/pretty/nu.*.HtmlParser/nu.*.HtmlParser.nocache.js ./build/html5.pretty.js
+perl -pi~ -e "s/if(.*)\((.*)doc_0\.addEventListener\)/\/\*envjsedit/s" ./build/html5.pretty.js 
+perl -pi~ -e "s/,\s50\);/envjsedit\*\//s" ./build/html5.pretty.js 
+perl -pi~ -e "s/if(.*)\((.*)doc_0\.removeEventListener\)/if\(false\/\*envjsedit\*\/\)/" ./build/html5.pretty.js
+perl -pi~ -e "s/function onBodyDone\(\)/\/\*envjsedit\*\/var onBodyDone = Html5Parser = function\(\)/" ./build/html5.pretty.js
+
+echo "Generating Detailed HTMLParser"
+java -XstartOnFirstThread -Xmx256M -cp "$APPDIR/src:$APPDIR/gwt-src:$APPDIR/super:./gwt-1.5.1/gwt-user.jar:./gwt-1.5.1/gwt-dev.jar" com.google.gwt.dev.GWTCompiler -style DETAILED -out "build/detailed" "$@" nu.validator.htmlparser.HtmlParser;
+cp ./build/detailed/nu.*.HtmlParser/nu.*.HtmlParser.nocache.js ./build/html5.detailed.js
+perl -pi~ -e "s/if(.*)\((.*)doc\.addEventListener\)/\/\*envjsedit/s" ./build/html5.detailed.js 
+perl -pi~ -e "s/,\s50\);/envjsedit\*\//s" ./build/html5.detailed.js 
+perl -pi~ -e "s/if(.*)\((.*)doc\.removeEventListener\)/if\(false\/\*envjsedit\*\/\)/" ./build/html5.detailed.js
+perl -pi~ -e "s/function onBodyDone\(\)/\/\*envjsedit\*\/var onBodyDone = Html5Parser = function\(\)/" ./build/html5.detailed.js
+
+rm ./build/*.js~
+
+cp ./build/html5.*.js ../src/parser/

data/jsl/jsl.default.conf

@@ -0,0 +1,129 @@
+#
+# Configuration File for JavaScript Lint 0.3.0
+# Developed by Matthias Miller (http://www.JavaScriptLint.com)
+#
+# This configuration file can be used to lint a collection of scripts, or to enable
+# or disable warnings for scripts that are linted via the command line.
+#
+
+### Warnings
+# Enable or disable warnings based on requirements.
+# Use "+WarningName" to display or "-WarningName" to suppress.
+#
++no_return_value              # function {0} does not always return a value
++duplicate_formal             # duplicate formal argument {0}
++equal_as_assign              # test for equality (==) mistyped as assignment (=)?{0}
++var_hides_arg                # variable {0} hides argument
++redeclared_var               # redeclaration of {0} {1}
++anon_no_return_value         # anonymous function does not always return a value
++missing_semicolon            # missing semicolon
++meaningless_block            # meaningless block; curly braces have no impact
++comma_separated_stmts        # multiple statements separated by commas (use semicolons?)
++unreachable_code             # unreachable code
++missing_break                # missing break statement
++missing_break_for_last_case  # missing break statement for last case in switch
++comparison_type_conv         # comparisons against null, 0, true, false, or an empty string allowing implicit type conversion (use === or !==)
++inc_dec_within_stmt          # increment (++) and decrement (--) operators used as part of greater statement
++useless_void                 # use of the void type may be unnecessary (void is always undefined)
++multiple_plus_minus          # unknown order of operations for successive plus (e.g. x+++y) or minus (e.g. x---y) signs
++use_of_label                 # use of label
+-block_without_braces         # block statement without curly braces
++leading_decimal_point        # leading decimal point may indicate a number or an object member
++trailing_decimal_point       # trailing decimal point may indicate a number or an object member
++octal_number                 # leading zeros make an octal number
++nested_comment               # nested comment
++misplaced_regex              # regular expressions should be preceded by a left parenthesis, assignment, colon, or comma
++ambiguous_newline            # unexpected end of line; it is ambiguous whether these lines are part of the same statement
+-empty_statement              # empty statement or extra semicolon
+-missing_option_explicit      # the "option explicit" control comment is missing
++partial_option_explicit      # the "option explicit" control comment, if used, must be in the first script tag
++dup_option_explicit          # duplicate "option explicit" control comment
++useless_assign               # useless assignment
++ambiguous_nested_stmt        # block statements containing block statements should use curly braces to resolve ambiguity
++ambiguous_else_stmt          # the else statement could be matched with one of multiple if statements (use curly braces to indicate intent)
++missing_default_case         # missing default case in switch statement
++duplicate_case_in_switch     # duplicate case in switch statements
++default_not_at_end           # the default case is not at the end of the switch statement
++legacy_cc_not_understood     # couldn't understand control comment using /*@keyword@*/ syntax
++jsl_cc_not_understood        # couldn't understand control comment using /*jsl:keyword*/ syntax
++useless_comparison           # useless comparison; comparing identical expressions
++with_statement               # with statement hides undeclared variables; use temporary variable instead
++trailing_comma_in_array      # extra comma is not recommended in array initializers
++assign_to_function_call      # assignment to a function call
++parseint_missing_radix       # parseInt missing radix parameter
+
+
+### Output format
+# Customize the format of the error message.
+#    __FILE__ indicates current file path
+#    __FILENAME__ indicates current file name
+#    __LINE__ indicates current line
+#    __ERROR__ indicates error message
+#
+# Visual Studio syntax (default):
++output-format __FILE__(__LINE__): __ERROR__
+# Alternative syntax:
+#+output-format __FILE__:__LINE__: __ERROR__
+
+
+### Context
+# Show the in-line position of the error.
+# Use "+context" to display or "-context" to suppress.
+#
++context
+
+
+### Semicolons
+# By default, assignments of an anonymous function to a variable or
+# property (such as a function prototype) must be followed by a semicolon.
+#
++lambda_assign_requires_semicolon
+
+
+### Control Comments
+# Both JavaScript Lint and the JScript interpreter confuse each other with the syntax for
+# the /*@keyword@*/ control comments and JScript conditional comments. (The latter is
+# enabled in JScript with @cc_on@). The /*jsl:keyword*/ syntax is preferred for this reason,
+# although legacy control comments are enabled by default for backward compatibility.
+#
++legacy_control_comments
+
+
+### JScript Function Extensions
+# JScript allows member functions to be defined like this:
+#     function MyObj() { /*constructor*/ }
+#     function MyObj.prototype.go() { /*member function*/ }
+#
+# It also allows events to be attached like this:
+#     function window::onload() { /*init page*/ }
+#
+# This is a Microsoft-only JavaScript extension. Enable this setting to allow them.
+#
+-jscript_function_extensions
+
+
+### Defining identifiers
+# By default, "option explicit" is enabled on a per-file basis.
+# To enable this for all files, use "+always_use_option_explicit"
+-always_use_option_explicit
+
+# Define certain identifiers of which the lint is not aware.
+# (Use this in conjunction with the "undeclared identifier" warning.)
+#
+# Common uses for webpages might be:
+#+define window
+#+define document
+
+
+### Interactive
+# Prompt for a keystroke before exiting.
+#+pauseatend
+
+
+### Files
+# Specify which files to lint
+# Use "+recurse" to enable recursion (disabled by default).
+# To add a set of files, use "+process FileName", "+process Folder\Path\*.js",
+# or "+process Folder\Path\*.htm".
+#
++process jsl-test.js

data/lib/envjs.rb

@@ -0,0 +1,35 @@
+module Envjs
+
+  VERSION = "0.3.8"
+
+  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" ) )
+
+  EVENT_LOOP = 
+    File.expand_path( File.join( File.dirname(__FILE__),
+                                  "envjs",
+                                  "event_loop.js" ) )
+
+  STATIC = 
+    File.expand_path( File.join( File.dirname(__FILE__),
+                                  "envjs",
+                                  "static.js" ) )
+
+end

data/lib/envjs/event_loop.js

@@ -0,0 +1,206 @@
+(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){
+    debug("timer error: "+s);
+    if (s.stack) {
+      debug("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 {
+            // FIX ME: has to evaluate in inner ... probably in caller?
+            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() { 
+        // FIX ME: has to evaluate in inner ... probably in caller(?)
+        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 ];
+  };
+
+}());