distil 0.7.0

data/lib/test/HtmlTestReporter.js

@@ -0,0 +1,127 @@
+var TestReporter= {
+
+    __numberOfFailures: 0,
+    __numberOfTests: 0,
+    __numberOfPasses: 0,
+    __numberOfSkipped: 0,
+    
+    __currentTest: '',
+    
+    setup: function(id)
+    {
+        this.container= document.getElementById(id);
+        this.results= document.createElement('p');
+        this.results.className='test-results';
+        this.container.appendChild(this.results);
+        this.node= document.createElement('ul');
+        this.node.className='test-report-items';
+        this.container.appendChild(this.node);
+    },
+    
+    statistics: function()
+    {
+        return {
+            numberOfFailures: this.__numberOfFailures,
+            numberOfTests: this.__numberOfTests,
+            numberOfPasses: this.__numberOfPasses,
+            numberOfSkipped: this.__numberOfSkipped
+        };
+    },
+    
+    complete: function()
+    {
+        var text= [this.__numberOfTests, ' tests: ', this.__numberOfPasses,
+                   ' passed ', this.__numberOfFailures, ' failed ',
+                   this.__numberOfSkipped, ' skipped'].join("");
+                   
+        var node= document.createTextNode(text);
+        this.results.innerHTML="";
+        this.results.appendChild(node);
+    },
+    
+    log: function()
+    {
+        var len= arguments.length;
+        var m= [];
+        
+        for (var i=0; i<len; ++i)
+            m.push(String(arguments[i]));
+        this.print('  log: ' + this.__currentTest + ': ' + m.join(' '));
+    },
+    
+    print: function(m, status)
+    {
+        var line= document.createElement('li');
+        if (status)
+            line.className='test-report-item-' + status;
+            
+        line.appendChild(document.createTextNode(m));
+        var text= line.innerHTML;
+        var r= /((?:(?:&lt;)|\s|^)(\w+:\/\/[^\s]*?)(?:(?:&gt;)|\s|$))/g;
+        text= text.replace(r, '<a href="$2">$1</a>');
+        line.innerHTML= text;
+        this.node.appendChild(line);
+        
+        if ('failure'==status && this.onfailure)
+            this.onfailure(m);
+    },
+    
+    beginTest: function(test, testName)
+    {
+        this.__currentTest= test + '#' + testName;
+        ++this.__numberOfTests;
+    },
+    
+    endTest: function(test, testName)
+    {
+    },
+    
+    failed: function(test, testName, message)
+    {
+        this.print('failed: ' + test + "#" + testName + ": " + message, 'failure');
+        ++this.__numberOfFailures;
+    },
+
+    skipped: function(test, testName, message)
+    {
+        this.print('skipped: ' + test + "#" + testName + ': ' + message,
+                   'skip');
+        ++this.__numberOfSkipped;
+    },
+    
+    passed: function(test, testName)
+    {
+        this.print('passed: ' + test + '#' + testName);
+        ++this.__numberOfPasses;
+    },
+    
+    uncaughtException: function(test, testName, e)
+    {
+        this.print('uncaught exception: ' + test + '#' + testName + ': ' +
+                   e.name + ': ' + e.message, 'failure');
+        ++this.__numberOfFailures;
+    },
+    
+    exceptionInSetup: function(test, testName, e)
+    {
+        this.print('uncaught exception in setup: ' + test + '#' + testName + ': ' +
+                   e.name + ': ' + e.message, 'failure');
+        ++this.__numberOfFailures;
+    },
+
+    exceptionInTeardown: function(test, testName, e)
+    {
+        this.print('uncaught exception in teardown: ' + test + '#' + testName + ': ' +
+                   e.name + ': ' + e.message, 'failure');
+        ++this.__numberOfFailures;
+    },
+    
+    timeoutExpired: function(test, testName, timeout)
+    {
+        this.print('timeout: ' + test + '#' + testName +
+                   ': did not complete after ' + timeout + ' milliseconds',
+                   'failure');
+        ++this.__numberOfFailures;
+    }
+    
+};

data/lib/test/Test.js

@@ -0,0 +1,248 @@
+function TestHelper(scope, report, test, testName)
+{
+    this.scope= scope;
+    this.report= report;
+    this.test= test;
+    this.testName= testName;
+    this._async= false;    
+}
+TestHelper.prototype= {
+
+    __ASYNC_MARKER__: 'async_marker',
+    
+    stringFromValue: function(v)
+    {
+        return String(v);
+    },
+    
+    compareArrays: function(a1, a2)
+    {
+        if (a1.length==a2.length)
+        {
+            var len=a1.length;
+            var i;
+
+            for (i=0; i<len; ++i)
+                if (a1[i]!==a2[i])
+                    return false;
+            return true;
+        }
+
+        return false;
+    },
+    
+    log: function()
+    {
+        this.report.log.apply(this.report, arguments);
+    },
+    
+    passed: function()
+    {
+        if (this._finished)
+            return;
+            
+        this.report.passed(this.test, this.testName);
+        this.finishAsync();
+    },
+    
+    clearTimer: function()
+    {
+        if (!this._timer)
+            return;
+        window.clearTimeout(this._timer);
+        this._timer= 0;
+    },
+    
+    finishAsync: function()
+    {
+        if (!this._async || this._finished)
+            return;
+        
+        this._finished= true;
+        this.clearTimer();
+        try
+        {
+            if (this.teardown)
+                this.teardown.call(this.scope);
+        }
+        catch (e)
+        {
+            this.report.exceptionInTeardown(this.test, this.testName, e);
+        }
+        
+        this.report.endTest(this.test, this.testName);
+        if (this.ontestcomplete)
+            this.ontestcomplete();
+    },
+    
+    /** Create an asynchronous handler for this method. If the test
+     *  doesn't complete before the timeout expires, then the test
+     *  fails.
+     */
+    async: function(timeout)
+    {
+        var helper= this;
+        
+        function timeoutFn()
+        {
+            helper.report.timeoutExpired(helper.test, helper.testName, timeout);
+            helper.finishAsync();
+        }
+        
+        this._timer= window.setTimeout(timeoutFn, timeout);
+        this._async= true;
+        return this.__ASYNC_MARKER__;
+    },
+
+    assert: function(value, msg)
+    {
+        this.assertTrue(value, msg);
+    },
+    
+    assertEqual: function(value, expected, msg)
+    {
+        if ('object'===typeof(value) && 'object'===typeof(expected) &&
+            value.splice && expected.splice)
+        {
+            if (this.compareArrays(value, expected))
+                return;
+        }
+        else if (value===expected)
+            return;
+
+        this.fail(msg||(this.stringFromValue(value) + '===' +
+                        this.stringFromValue(expected)));
+    },
+
+    assertNotEqual: function(value, expected, msg)
+    {
+        if (value!==expected)
+            return;
+        this.fail(msg||(this.stringFromValue(value) + '!==' +
+                        this.stringFromValue(expected)));
+    },
+
+    assertTrue: function(value, msg)
+    {
+        if (true===value)
+            return;
+        this.fail(msg||(this.stringFromValue(value) + ' is not true'));
+    },
+
+    assertFalse: function(value, msg)
+    {
+        if (false===value)
+            return;
+        this.fail(msg||(this.stringFromValue(value) + ' is not false'));
+    },
+
+    assertNull: function(value, msg)
+    {
+        if (null===value)
+            return;
+        this.fail(msg||(this.stringFromValue(value) + ' is not null'));
+    },
+
+    assertNotNull: function(value, msg)
+    {
+        if (null!==value)
+            return;
+        this.fail(msg||(this.stringFromValue(value) + ' is null'));
+    },
+
+    assertUndefined: function(value, msg)
+    {
+        if ('undefined'===typeof(value))
+            return;
+        this.fail(msg||(this.stringFromValue(value) + ' is not undefined'));
+    },
+
+    assertNotUndefined: function(value, msg)
+    {
+        if ('undefined'!==typeof(value))
+            return;
+        this.fail(msg||(this.stringFromValue(value) + ' is undefined'));
+    },
+
+    assertMatch: function(regex, value, msg)
+    {
+        if (regex.exec(value))
+            return;
+        this.fail(msg||(this.stringFromValue(value) + ' did not match /' + regex.source + '/'));
+    },
+
+    assertNotMatch: function(regex, value, msg)
+    {
+        if (!regex.exec(value))
+            return;
+        this.fail(msg||(this.stringFromValue(value) + ' matched /' + regex.source + '/'));
+    },
+    
+    assertInstanceOf: function(value, klass, msg)
+    {
+        if (value instanceof klass)
+            return;
+        this.fail(msg||(this.stringFromValue(value) + ' is not an instance'));
+    },
+
+    assertNotInstanceOf: function(value, klass, msg)
+    {
+        if (!(value instanceof klass))
+            return;
+        this.fail(msg||(this.stringFromValue(value) + ' is an instance'));
+    },
+    
+    fail: function(msg)
+    {
+        if (this._finished)
+            return;
+            
+        msg= msg||'failed';
+        this.report.failed(this.test, this.testName, msg);
+        
+        this.finishAsync();
+        
+        var error= new Error(msg);
+        error.name= 'AssertionError';
+        throw error;
+    },
+    
+    skip: function(why)
+    {
+        if (this._finished)
+            return;
+            
+        why= why||'Test skipped';
+        this.report.skipped(this.test, this.testName, why);
+        
+        this.finishAsync();
+
+        var error= new Error(why);
+        error.name= 'AssertionError';
+        throw error;
+    }
+
+};
+
+
+var Test= {
+
+    /** Register a group of tests. This might do some clever processing of
+     *  each test function.
+     */
+    create: function(name, decl)
+    {
+        window.top.Test.numberOfRegisteredTests++;
+        window.top.Test._tests[name]= decl;
+    },
+    
+    reset: function()
+    {
+        this._tests={};
+        this.numberOfRegisteredTests= 0;
+    },
+    
+    numberOfRegisteredTests: 0,
+    _tests: {}
+
+};

data/lib/test/TestReporter.js

@@ -0,0 +1,79 @@
+function print(msg)
+{
+    console.log(msg);
+}
+
+var TestReporter= {
+
+    __numberOfFailures: 0,
+    __numberOfTests: 0,
+    __numberOfPasses: 0,
+    __numberOfSkipped: 0,
+    
+    setup: function()
+    {},
+    
+    complete: function()
+    {
+        print(this.__numberOfTests + ' tests ' + this.__numberOfPasses + ' passed ' +
+              this.__numberOfFailures + ' failed ' + this.__numberOfSkipped + ' skipped');
+    },
+    
+    beginTest: function(test, testName)
+    {
+        print('begin: ' + test + '#' + testName);
+        ++this.__numberOfTests;
+    },
+    
+    endTest: function(test, testName)
+    {
+        print('end: ' + test + '#' + testName);
+    },
+    
+    failed: function(test, testName, message)
+    {
+        print('failed: ' + test + "#" + testName + ": " + message);
+        ++this.__numberOfFailures;
+    },
+    
+    skipped: function(test, testName, message)
+    {
+        print('skipped: ' + test + "#" + testName + ': ' + message);
+        ++this.__numberOfSkipped;
+    },
+    
+    passed: function(test, testName)
+    {
+        print('passed: ' + test + '#' + testName);
+        ++this.__numberOfPasses;
+    },
+    
+    uncaughtException: function(test, testName, e)
+    {
+        print('uncaught exception: ' + test + '#' + testName + ': ' +
+              e.name + ': ' + e.message);
+        ++this.__numberOfFailures;
+    },
+    
+    exceptionInSetup: function(test, testName, e)
+    {
+        print('uncaught exception in setup: ' + test + '#' + testName + ': ' +
+              e.name + ': ' + e.message);
+        ++this.__numberOfFailures;
+    },
+
+    exceptionInTeardown: function(test, testName, e)
+    {
+        print('uncaught exception in teardown: ' + test + '#' + testName + ': ' +
+              e.name + ': ' + e.message);
+        ++this.__numberOfFailures;
+    },
+    
+    timeoutExpired: function(test, testName, timeout)
+    {
+        print('timeout: ' + test + '#' + testName +
+              ': did not complete after ' + timeout + ' milliseconds');
+        ++this.__numberOfFailures;
+    }
+    
+};

data/lib/test/TestRunner.js

@@ -0,0 +1,132 @@
+/*jsl:import Test.js*/
+/*jsl:import TestReporter.js*/
+
+var TestRunner = {
+    
+    _queue: [],
+    _timer: 0,
+    
+    run: function(testGroup, reporter)
+    {
+        var test= Test._tests[testGroup];
+        reporter= reporter || TestReporter;
+        
+        for (var testName in test)
+        {
+            if (!/^test[A-Z]/.test(testName))
+                continue;
+            this._queue.push([testGroup, testName, reporter]);
+        }
+        
+        this.next();
+    },
+
+    runAll: function(reporter)
+    {
+        reporter= reporter || TestReporter;
+        for (var testGroup in Test._tests)
+            this.run(testGroup, reporter);
+        this.next();
+    },
+    
+    next: function()
+    {
+        if (this._timer)
+            return;
+        
+        if (!this._queue.length)
+        {
+            TestReporter.complete();
+            if (this.oncomplete)
+                this.oncomplete();
+            return;
+        }
+
+        var args= this._queue.shift();
+        var runner= this;
+        
+        function go()
+        {
+            runner._timer= 0;
+            runner._run.apply(runner, args);
+        }
+        this._timer= window.setTimeout(go, 10);
+    },
+    
+    _run: function(testGroup, testName, reporter)
+    {
+        var runner= this;
+        var test= Test._tests[testGroup];
+        if (!test)
+        {
+            reporter.failed(testGroup, null, 'could not find test group: "' + testGroup + '"');
+            return;
+        }
+        
+        var setup= test['setup'];
+        var teardown= test['teardown'];
+        
+        if (!test[testName])
+        {
+            reporter.failed(testGroup, testName, 'could not find test function: "' + testName + '"');
+            return;
+        }
+        
+        function Scope()
+        {
+        }
+        Scope.prototype= test;
+        
+        reporter.beginTest(testGroup, testName);
+    
+        var scope= new Scope();
+        var helper= new TestHelper(scope, reporter, testGroup, testName);
+        helper.ontestcomplete= function()
+        {
+            runner.next();
+        }
+        
+        try
+        {
+            if (setup)
+                setup.call(scope);
+        }
+        catch (e)
+        {
+            reporter.exceptionInSetup(testGroup, testName, e);
+            return;
+        }
+        
+        try
+        {
+            var result= scope[testName](helper);
+            
+            if (result===helper.__ASYNC_MARKER__)
+            {
+                helper.teardown= teardown;
+                return;
+            }
+            
+            reporter.passed(testGroup, testName);
+        }
+        catch (e)
+        {
+            if ('AssertionError'!=e.name)
+                reporter.uncaughtException(testGroup, testName, e);
+        }
+        
+        try
+        {
+            if (teardown)
+                teardown.call(scope);
+        }
+        catch (e)
+        {
+            reporter.exceptionInTeardown(testGroup, testName, e);
+        }
+        
+        reporter.endTest(testGroup, testName);
+        this.next();
+    }
+
+};

data/lib/test/browser.rb

@@ -0,0 +1,97 @@
+class Browser
+  def supported?; true; end
+  def setup ; end
+  def open(url) ; end
+  def teardown ; end
+
+  def host
+    require 'rbconfig'
+    Config::CONFIG['host']
+  end
+  
+  def macos?
+    host.include?('darwin')
+  end
+  
+  def windows?
+    host.include?('mswin')
+  end
+  
+  def linux?
+    host.include?('linux')
+  end
+  
+  def applescript(script)
+    raise "Can't run AppleScript on #{host}" unless macos?
+    system "osascript -e '#{script}' 2>&1 >/dev/null"
+  end
+end
+
+class FirefoxBrowser < Browser
+  def initialize(path=File.join(ENV['ProgramFiles'] || 'c:\Program Files', '\Mozilla Firefox\firefox.exe'))
+    @path = path
+  end
+
+  def visit(url)
+    system("open -a \"Firefox 3.5.app\" '#{url}'") if macos?
+    system("#{@path} #{url}") if windows? 
+    system("firefox #{url}") if linux?
+  end
+
+  def to_s
+    "Firefox"
+  end
+end
+
+class SafariBrowser < Browser
+  def supported?
+    macos?
+  end
+  
+  def setup
+    applescript('tell application "Safari" to make new document')
+  end
+  
+  def visit(url)
+    applescript('tell application "Safari" to set URL of front document to "' + url + '"')
+  end
+
+  def teardown
+    #applescript('tell application "Safari" to close front document')
+  end
+
+  def to_s
+    "Safari"
+  end
+end
+
+class IEBrowser < Browser
+  def setup
+    require 'win32ole' if windows?
+  end
+
+  def supported?
+    windows?
+  end
+  
+  def visit(url)
+    if windows?
+      ie = WIN32OLE.new('InternetExplorer.Application')
+      ie.visible = true
+      ie.Navigate(url)
+      while ie.ReadyState != 4 do
+        sleep(1)
+      end
+    end
+  end
+
+  def to_s
+    "Internet Explorer"
+  end
+end
+
+$browsers= {
+  "safari" => SafariBrowser,
+  "firefox" => FirefoxBrowser,
+  "ie" => IEBrowser
+}

data/lib/test/scriptwrapper.html

@@ -0,0 +1,10 @@
+<!DOCTYPE HTML">
+<html>
+    <head>
+        <title>@title@</title>
+        <script src="/lib/test/Test.js" type="text/javascript" charset="utf-8"></script>
+        @scripts@
+    </head>
+    <body>
+    </body>
+</html>