newjs 1.5.1 → 1.7.0

data/vendor/jshoulda/dist/jshoulda.js

@@ -0,0 +1,186 @@
+/*  jShoulda, version 1.2.1
+ *  (c) 2008 Choan Galvez
+ *
+ *  jShoulda is freely distributable under
+ *  the terms of an MIT-style license.
+ *  For details, see the web site: http://jshoulda.scriptia.net
+ *
+ *--------------------------------------------------------------------------*/
+
+var jShoulda = function() {
+  // the test runner
+  var tr,
+  // handle all testcases with the same testrunner
+  unique = false,
+  // styles definitions
+  styles = {};
+
+  function dummy() {
+  };
+
+  function runQueue(queue, name, before, after, ext) {
+    var i, tests;
+    for (i = 0; i < queue.length; i += 1) {
+      tests = queue[i](name, before, after, ext);
+      if (tests)
+        tr.tests.push(tests);
+    }
+    before.pop();
+    after.pop();
+  }
+
+  function makeBatch(fn_a) {
+    var copy = fn_a.slice(0);
+    return function() {
+      for (var i = 0; i < copy.length; i += 1) {
+        copy[i].call(this);
+      }
+    };
+  }
+
+  function getContextAlias(prefix) {
+    if (prefix) prefix += ' ';
+    return function (name, config, args) {
+      var queue = Array.prototype.slice.call(arguments, 0);
+      var cName = '';
+      var obj = {};
+      // shift arguments if the first one is a string
+      if (typeof queue[0] == 'string') {
+        if (name) { cName += prefix; }
+        cName += queue.shift();
+      }
+      if (typeof queue[0] === 'object') {
+        obj = queue.shift();
+      }
+
+      obj.before = obj.setup || obj.before || dummy;
+      obj.after = obj.teardown || obj.after || dummy;
+      var beforeQueue;
+      var afterQueue;
+      var extensions = merge({}, obj || {});
+
+      return function(outerName, before, after, ext) {
+        // the root context gets no outerName or a configuration object
+        // as its first argument
+        var prefix = outerName;
+        var is_root = !!(outerName == undefined || typeof outerName == 'object');
+        if (is_root) {
+          tr = (tr && unique) ? tr : new Test.Unit.Runner({}, outerName || {});
+          prefix = '';
+        }
+        // shift arguments if the second one is a
+        // configuration object
+        beforeQueue = before ? before.push(obj.before) && before : [obj.before];
+        afterQueue = after ? after.push(obj.after) && after : [obj.after];
+        runQueue(queue, [prefix, cName].join(' ').replace(/^\s+/, ''), beforeQueue, afterQueue, merge(extensions, ext));
+        if (is_root) {
+          return tr;
+        }
+        return false; // do not add to the tests queue
+      };
+    };
+  };
+
+  function merge(sub, sup) {
+    for (var i in sup) {
+      if (i.search(/^(before|after|setup|teardown)$/) != -1) continue;
+      if (sup.hasOwnProperty(i)) {
+        sub[i] = sup[i];
+      }
+    }
+    return sub;
+  }
+
+
+  function getShouldAlias(connector) {
+    return function (name, fn) {
+      return function(prefix, before, after, extensions) {
+        var beforeBatch = makeBatch(before);
+        var afterBatch = makeBatch(after);
+        var unit = new Test.Unit.Testcase([prefix, name].join(' ' + connector + ' '), fn, beforeBatch, afterBatch);
+        merge(unit, extensions);
+        return unit;
+      };
+    };
+  }
+
+  function setShouldAlias(name, host) {
+    var connector = name;
+    if (typeof host == 'string') {
+      connector = host;
+      host = arguments[2];
+    }
+    host = host || window;
+    host[name] = getShouldAlias(connector);
+    return jShoulda;
+  }
+
+  function setContextAlias(name, host) {
+    var prefix = '';
+    if (typeof host == 'string') {
+      prefix = host;
+      host = arguments[2];
+    }
+    host = host || window;
+    host[name] = getContextAlias(prefix);
+    return jShoulda;
+  }
+
+  function useStyle(name) {
+    var style, i;
+    if (name in styles) {
+      style = styles[name];
+      if ('context' in style) {
+        for (i = 0; i < style.context.length; i += 2) {
+          setContextAlias(style.context[i], style.context[i+1]);
+        }
+      }
+      if ('should' in style) {
+        for (i = 0; i < style.should.length; i += 2) {
+          setShouldAlias(style.should[i], style.should[i+1]);
+        }
+      }
+      if (style.unify) unifyRunners();
+    }
+    else throw { name: 'UndefinedStyle', message: 'There is not "'+name+'" style defined' };
+    return jShoulda;
+  }
+
+  function defineStyle(name, opts, aliases) {
+    styles[name] = opts;
+    for (var i = 2; i < arguments.length; i += 1) {
+      styles[arguments[i]] = opts;
+    }
+    return jShoulda;
+  }
+
+  function unifyRunners (options) {
+    if (options) {
+      tr = options instanceof Test.Unit.Runner ? options : new Test.Unit.Runner({}, options || {});
+    }
+    unique = true;
+    return jShoulda;
+  }
+
+  return {
+    setShouldAlias : setShouldAlias,
+    setContextAlias : setContextAlias,
+    unifyRunners : unifyRunners,
+    useStyle : useStyle,
+    defineStyle: defineStyle
+  };
+
+}();
+
+jShoulda
+  .defineStyle('describe', {
+    context: [ 'describe', '' ],
+    should: [ 'it', '' ],
+    unify: false
+  }, 'it')
+  .defineStyle('context', {
+    context : [ 'context', '' ],
+    should : [ 'should', 'should' ],
+    unify : false
+  }, 'should')
+  .useStyle('should');

data/vendor/jshoulda/jshoulda/test/basic_test.html

@@ -0,0 +1,42 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+
+  <title>jShoulda Demo Test</title>
+  
+  <script src="../assets/jsunittest.js" type="text/javascript"></script>
+  <script src="../assets/jshoulda.js" type="text/javascript"></script>
+  <link rel="stylesheet" href="../assets/unittest.css" type="text/css" media="screen" />
+  
+  
+</head>
+
+<body>
+
+<h1>jShoulda Demo Test</h1>
+
+<div id="testlog"></div>
+
+<script type="text/javascript" charset="utf-8">
+function trim(s) {
+  return s.replace(/^\s+|\s+$/g, '');
+}
+context("trim",
+  should("remove blanks from the start of the string", function() {
+    this.assertEqual('hello', trim('  hello'));
+    this.assertEqual('hello mamuso', trim('   hello mamuso'));
+  }),
+  should("remove blanks from the end of the string", function() {
+    this.assertEqual('hello', trim('hello   '));
+  }),
+  should("remove blanks from both the start and the end of the string", function() {
+    this.assertEqual('hello', trim('  hello   '));
+  })
+)();
+</script>
+
+</body>
+</html>

data/vendor/jshoulda/lib/jstest.rb

@@ -0,0 +1,382 @@
+require 'rake/tasklib'
+require 'thread'
+require 'webrick'
+require 'fileutils'
+include FileUtils
+
+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 '#{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
+
+class KonquerorBrowser < Browser
+  @@configDir = File.join((ENV['HOME'] || ''), '.kde', 'share', 'config')
+  @@globalConfig = File.join(@@configDir, 'kdeglobals')
+  @@konquerorConfig = File.join(@@configDir, 'konquerorrc')
+
+  def supported?
+    linux?
+  end
+
+  # Forces KDE's default browser to be Konqueror during the tests, and forces
+  # Konqueror to open external URL requests in new tabs instead of a new
+  # window.
+  def setup
+    cd @@configDir, :verbose => false do
+      copy @@globalConfig, "#{@@globalConfig}.bak", :preserve => true, :verbose => false
+      copy @@konquerorConfig, "#{@@konquerorConfig}.bak", :preserve => true, :verbose => false
+      # Too lazy to write it in Ruby...  Is sed dependency so bad?
+      system "sed -ri /^BrowserApplication=/d  '#{@@globalConfig}'"
+      system "sed -ri /^KonquerorTabforExternalURL=/s:false:true: '#{@@konquerorConfig}'"
+    end
+  end
+
+  def teardown
+    cd @@configDir, :verbose => false do
+      copy "#{@@globalConfig}.bak", @@globalConfig, :preserve => true, :verbose => false
+      copy "#{@@konquerorConfig}.bak", @@konquerorConfig, :preserve => true, :verbose => false
+    end
+  end
+  
+  def visit(url)
+    system("kfmclient openURL #{url}")
+  end
+  
+  def to_s
+    "Konqueror"
+  end
+end
+
+class OperaBrowser < Browser
+  def initialize(path='c:\Program Files\Opera\Opera.exe')
+    @path = path
+  end
+  
+  def setup
+    if windows?
+      puts %{
+        MAJOR ANNOYANCE on Windows.
+        You have to shut down Opera manually after each test
+        for the script to proceed.
+        Any suggestions on fixing this is GREATLY appreciated!
+        Thank you for your understanding.
+      }
+    end
+  end
+  
+  def visit(url)
+    applescript('tell application "Opera" to GetURL "' + url + '"') if macos? 
+    system("#{@path} #{url}") if windows? 
+    system("opera #{url}")  if linux?
+  end
+
+  def to_s
+    "Opera"
+  end
+end
+
+# shut up, webrick :-)
+class ::WEBrick::HTTPServer
+  def access_log(config, req, res)
+    # nop
+  end
+end
+
+class ::WEBrick::BasicLog
+  def log(level, data)
+    # nop
+  end
+end
+
+class WEBrick::HTTPResponse
+  alias send send_response
+  def send_response(socket)
+    send(socket) unless fail_silently?
+  end
+  
+  def fail_silently?
+    @fail_silently
+  end
+  
+  def fail_silently
+    @fail_silently = true
+  end
+end
+
+class WEBrick::HTTPRequest
+  def to_json
+    headers = []
+    each { |k, v| headers.push "#{k.inspect}: #{v.inspect}" }
+    headers = "{" << headers.join(', ') << "}"
+    %({ "headers": #{headers}, "body": #{body.inspect}, "method": #{request_method.inspect} })
+  end
+end
+
+class WEBrick::HTTPServlet::AbstractServlet
+  def prevent_caching(res)
+    res['ETag'] = nil
+    res['Last-Modified'] = Time.now + 100**4
+    res['Cache-Control'] = 'no-store, no-cache, must-revalidate, post-check=0, pre-check=0'
+    res['Pragma'] = 'no-cache'
+    res['Expires'] = Time.now - 100**4
+  end
+end
+
+class BasicServlet < WEBrick::HTTPServlet::AbstractServlet
+  def do_GET(req, res)
+    prevent_caching(res)
+    res['Content-Type'] = "text/plain"
+    
+    req.query.each do |k, v|
+      res[k] = v unless k == 'responseBody'
+    end
+    res.body = req.query["responseBody"]
+    
+    raise WEBrick::HTTPStatus::OK
+  end
+  
+  def do_POST(req, res)
+    do_GET(req, res)
+  end
+end
+
+class SlowServlet < BasicServlet
+  def do_GET(req, res)
+    sleep(2)
+    super
+  end
+end
+
+class DownServlet < BasicServlet
+  def do_GET(req, res)
+    res.fail_silently
+  end
+end
+
+class InspectionServlet < BasicServlet
+  def do_GET(req, res)
+    prevent_caching(res)
+    res['Content-Type'] = "application/json"
+    res.body = req.to_json
+    raise WEBrick::HTTPStatus::OK
+  end
+end
+
+class NonCachingFileHandler < WEBrick::HTTPServlet::FileHandler
+  def do_GET(req, res)
+    super
+    set_default_content_type(res, req.path)
+    prevent_caching(res)
+  end
+  
+  def set_default_content_type(res, path)
+    res['Content-Type'] = case path
+      when /\.js$/   then 'text/javascript'
+      when /\.html$/ then 'text/html'
+      when /\.css$/  then 'text/css'
+      else 'text/plain'
+    end
+  end
+end
+
+class JavaScriptTestTask < ::Rake::TaskLib
+
+  def initialize(name=:test, port=4711)
+    @name = name
+    @tests = []
+    @browsers = []
+    @port = port
+    @queue = Queue.new
+
+    @server = WEBrick::HTTPServer.new(:Port => @port) # TODO: make port configurable
+    @server.mount_proc("/results") do |req, res|
+      @queue.push({
+        :tests => req.query['tests'].to_i,
+        :assertions => req.query['assertions'].to_i,
+        :failures => req.query['failures'].to_i,
+        :errors => req.query['errors'].to_i
+      })
+      res.body = "OK"
+    end
+    @server.mount("/response", BasicServlet)
+    @server.mount("/slow", SlowServlet)
+    @server.mount("/down", DownServlet)
+    @server.mount("/inspect", InspectionServlet)
+    yield self if block_given?
+    define
+  end
+
+  def define
+    task @name do
+      trap("INT") { @server.shutdown; exit }
+      t = Thread.new { @server.start }
+      
+      # run all combinations of browsers and tests
+      @browsers.each do |browser|
+        if browser.supported?
+          t0 = Time.now
+          results = {:tests => 0, :assertions => 0, :failures => 0, :errors => 0}
+          errors = []
+          failures = []
+          browser.setup
+          puts "\nStarted tests in #{browser}"
+          @tests.each do |test|
+            params = "resultsURL=http://localhost:#{@port}/results&t=" + ("%.6f" % Time.now.to_f)
+            if test.is_a?(Hash)
+              params << "&tests=#{test[:testcases]}" if test[:testcases]
+              test = test[:url]
+            end
+            browser.visit("http://localhost:#{@port}#{test}?#{params}")
+ 
+            result = @queue.pop
+            result.each { |k, v| results[k] += v }
+            value = "."
+            
+            if result[:failures] > 0
+              value = "F"
+              failures.push(test)
+            end
+            
+            if result[:errors] > 0
+              value = "E"
+              errors.push(test)
+            end
+            
+            print value
+          end
+          
+          puts "\nFinished in #{(Time.now - t0).round.to_s} seconds."
+          puts "  Failures: #{failures.join(', ')}" unless failures.empty?
+          puts "  Errors:   #{errors.join(', ')}" unless errors.empty?
+          puts "#{results[:tests]} tests, #{results[:assertions]} assertions, #{results[:failures]} failures, #{results[:errors]} errors"
+          browser.teardown
+        else
+          puts "\nSkipping #{browser}, not supported on this OS"
+        end
+      end
+
+      @server.shutdown
+      t.join
+    end
+  end
+
+  def mount(path, dir=nil)
+    dir = Dir.pwd + path unless dir
+
+    # don't cache anything in our tests
+    @server.mount(path, NonCachingFileHandler, dir)
+  end
+
+  # test should be specified as a url or as a hash of the form
+  # {:url => "url", :testcases => "testFoo,testBar"}
+  def run(test)
+    @tests<<test
+  end
+
+  def browser(browser)
+    browser =
+      case(browser)
+        when :firefox
+          FirefoxBrowser.new
+        when :safari
+          SafariBrowser.new
+        when :ie
+          IEBrowser.new
+        when :konqueror
+          KonquerorBrowser.new
+        when :opera
+          OperaBrowser.new
+        else
+          browser
+      end
+
+    @browsers<<browser
+  end
+end