newjs 1.5.1 → 1.7.0

data/vendor/jsunittest/src/prototype/event.js

@@ -0,0 +1,72 @@
+JsUnitTest.Event = {};
+// written by Dean Edwards, 2005
+// with input from Tino Zijdel, Matthias Miller, Diego Perini
+// namespaced by Dr Nic Williams 2008
+
+// http://dean.edwards.name/weblog/2005/10/add-event/
+// http://dean.edwards.name/weblog/2005/10/add-event2/
+JsUnitTest.Event.addEvent = function(element, type, handler) {
+	if (element.addEventListener) {
+		element.addEventListener(type, handler, false);
+	} else {
+		// assign each event handler a unique ID
+		if (!handler.$$guid) handler.$$guid = JsUnitTest.Event.addEvent.guid++;
+		// create a hash table of event types for the element
+		if (!element.events) element.events = {};
+		// create a hash table of event handlers for each element/event pair
+		var handlers = element.events[type];
+		if (!handlers) {
+			handlers = element.events[type] = {};
+			// store the existing event handler (if there is one)
+			if (element["on" + type]) {
+				handlers[0] = element["on" + type];
+			}
+		}
+		// store the event handler in the hash table
+		handlers[handler.$$guid] = handler;
+		// assign a global event handler to do all the work
+		element["on" + type] = this.handleEvent;
+	}
+};
+// a counter used to create unique IDs
+JsUnitTest.Event.addEvent.guid = 1;
+
+JsUnitTest.Event.removeEvent = function(element, type, handler) {
+	if (element.removeEventListener) {
+		element.removeEventListener(type, handler, false);
+	} else {
+		// delete the event handler from the hash table
+		if (element.events && element.events[type]) {
+			delete element.events[type][handler.$$guid];
+		}
+	}
+};
+
+JsUnitTest.Event.handleEvent = function(event) {
+	var returnValue = true;
+	// grab the event object (IE uses a global event object)
+	event = event || JsUnitTest.Event.fixEvent(((this.ownerDocument || this.document || this).parentWindow || window).event);
+	// get a reference to the hash table of event handlers
+	var handlers = this.events[event.type];
+	// execute each event handler
+	for (var i in handlers) {
+		this.$$handleEvent = handlers[i];
+		if (this.$$handleEvent(event) === false) {
+			returnValue = false;
+		}
+	}
+	return returnValue;
+};
+
+JsUnitTest.Event.fixEvent = function(event) {
+	// add W3C standard event methods
+	event.preventDefault = this.fixEvent.preventDefault;
+	event.stopPropagation = this.fixEvent.stopPropagation;
+	return event;
+};
+JsUnitTest.Event.fixEvent.preventDefault = function() {
+	this.returnValue = false;
+};
+JsUnitTest.Event.fixEvent.stopPropagation = function() {
+	this.cancelBubble = true;
+};

data/vendor/jsunittest/src/prototype/template.js

@@ -0,0 +1,33 @@
+JsUnitTest.Template = function(template, pattern) {
+  this.template = template; //template.toString();
+  this.pattern = pattern || JsUnitTest.Template.Pattern;
+};
+
+JsUnitTest.Template.prototype.evaluate = function(object) {
+  if (typeof object.toTemplateReplacements == "function")
+    object = object.toTemplateReplacements();
+
+  return JsUnitTest.gsub(this.template, this.pattern, function(match) {
+    if (object == null) return '';
+
+    var before = match[1] || '';
+    if (before == '\\') return match[2];
+
+    var ctx = object, expr = match[3];
+    var pattern = /^([^.[]+|\[((?:.*?[^\\])?)\])(\.|\[|$)/;
+    match = pattern.exec(expr);
+    if (match == null) return before;
+
+    while (match != null) {
+      var comp = (match[1].indexOf('[]') === 0) ? match[2].gsub('\\\\]', ']') : match[1];
+      ctx = ctx[comp];
+      if (null == ctx || '' == match[3]) break;
+      expr = expr.substring('[' == match[3] ? match[1].length : match[0].length);
+      match = pattern.exec(expr);
+    }
+
+    return before + JsUnitTest.String.interpret(ctx);
+  });
+}
+
+JsUnitTest.Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;

data/vendor/jsunittest/src/runner.js

@@ -0,0 +1,120 @@
+JsUnitTest.Unit.Runner = function(testcases) {
+  var argumentOptions = arguments[1] || {};
+  var options = this.options = {};
+  options.testLog = ('testLog' in argumentOptions) ? argumentOptions.testLog : 'testlog';
+  options.resultsURL = this.queryParams.resultsURL;
+  options.testLog = JsUnitTest.$(options.testLog);
+  
+  this.tests = this.getTests(testcases);
+  this.currentTest = 0;
+  this.logger = new JsUnitTest.Unit.Logger(options.testLog);
+  
+  var self = this;
+  JsUnitTest.Event.addEvent(window, "load", function() {
+    setTimeout(function() {
+      self.runTests();
+    }, 0.1);
+  });
+};
+
+JsUnitTest.Unit.Runner.prototype.queryParams = JsUnitTest.toQueryParams();
+
+JsUnitTest.Unit.Runner.prototype.portNumber = function() {
+  if (window.location.search.length > 0) {
+    var matches = window.location.search.match(/\:(\d{3,5})\//);
+    if (matches) {
+      return parseInt(matches[1]);
+    }
+  }
+  return null;
+};
+
+JsUnitTest.Unit.Runner.prototype.getTests = function(testcases) {
+  var tests = [], options = this.options;
+  if (this.queryParams.tests) tests = this.queryParams.tests.split(',');
+  else if (options.tests) tests = options.tests;
+  else if (options.test) tests = [option.test];
+  else {
+    for (testname in testcases) {
+      if (testname.match(/^test/)) tests.push(testname);
+    }
+  }
+  var results = [];
+  for (var i=0; i < tests.length; i++) {
+    var test = tests[i];
+    if (testcases[test])
+      results.push(
+        new JsUnitTest.Unit.Testcase(test, testcases[test], testcases.setup, testcases.teardown)
+      );
+  };
+  return results;
+};
+
+JsUnitTest.Unit.Runner.prototype.getResult = function() {
+  var results = {
+    tests: this.tests.length,
+    assertions: 0,
+    failures: 0,
+    errors: 0,
+    warnings: 0
+  };
+  
+  for (var i=0; i < this.tests.length; i++) {
+    var test = this.tests[i];
+    results.assertions += test.assertions;
+    results.failures   += test.failures;
+    results.errors     += test.errors;
+    results.warnings   += test.warnings;
+  };
+  return results;
+};
+
+JsUnitTest.Unit.Runner.prototype.postResults = function() {
+  if (this.options.resultsURL) {
+    // new Ajax.Request(this.options.resultsURL, 
+    //   { method: 'get', parameters: this.getResult(), asynchronous: false });
+    var results = this.getResult();
+    var url = this.options.resultsURL + "?";
+    url += "tests="+ this.tests.length + "&";
+    url += "assertions="+ results.assertions + "&";
+    url += "warnings="  + results.warnings + "&";
+    url += "failures="  + results.failures + "&";
+    url += "errors="    + results.errors;
+    JsUnitTest.ajax({
+      url: url,
+      type: 'GET'      
+    })
+  }
+};
+
+JsUnitTest.Unit.Runner.prototype.runTests = function() {
+  var test = this.tests[this.currentTest], actions;
+  
+  if (!test) return this.finish();
+  if (!test.isWaiting) this.logger.start(test.name);
+  test.run();
+  var self = this;
+  if(test.isWaiting) {
+    this.logger.message("Waiting for " + test.timeToWait + "ms");
+    // setTimeout(this.runTests.bind(this), test.timeToWait || 1000);
+    setTimeout(function() {
+      self.runTests();
+    }, test.timeToWait || 1000);
+    return;
+  }
+  
+  this.logger.finish(test.status(), test.summary());
+  if (actions = test.actions) this.logger.appendActionButtons(actions);
+  this.currentTest++;
+  // tail recursive, hopefully the browser will skip the stackframe
+  this.runTests();
+};
+
+JsUnitTest.Unit.Runner.prototype.finish = function() {
+  this.postResults();
+  this.logger.summary(this.summary());
+};
+
+JsUnitTest.Unit.Runner.prototype.summary = function() {
+  return new JsUnitTest.Template('#{tests} tests, #{assertions} assertions, #{failures} failures, #{errors} errors, #{warnings} warnings').evaluate(this.getResult());
+};

data/vendor/jsunittest/src/test_case.js

@@ -0,0 +1,106 @@
+JsUnitTest.Unit.Testcase = function(name, test, setup, teardown) {
+  this.name           = name;
+  this.test           = test     || function() {};
+  this.setup          = setup    || function() {};
+  this.teardown       = teardown || function() {};
+  this.messages       = [];
+  this.actions        = {};
+};
+// import JsUnitTest.Unit.Assertions
+
+for (method in JsUnitTest.Unit.Assertions) {
+  JsUnitTest.Unit.Testcase.prototype[method] = JsUnitTest.Unit.Assertions[method];
+}
+
+JsUnitTest.Unit.Testcase.prototype.isWaiting         = false;
+JsUnitTest.Unit.Testcase.prototype.timeToWait        = 1000;
+JsUnitTest.Unit.Testcase.prototype.assertions        = 0;
+JsUnitTest.Unit.Testcase.prototype.failures          = 0;
+JsUnitTest.Unit.Testcase.prototype.errors            = 0;
+JsUnitTest.Unit.Testcase.prototype.warnings          = 0;
+JsUnitTest.Unit.Testcase.prototype.isRunningFromRake = window.location.port;
+
+// JsUnitTest.Unit.Testcase.prototype.isRunningFromRake = window.location.port == 4711;
+
+JsUnitTest.Unit.Testcase.prototype.wait = function(time, nextPart) {
+  this.isWaiting = true;
+  this.test = nextPart;
+  this.timeToWait = time;
+};
+
+JsUnitTest.Unit.Testcase.prototype.run = function(rethrow) {
+  try {
+    try {
+      if (!this.isWaiting) this.setup();
+      this.isWaiting = false;
+      this.test();
+    } finally {
+      if(!this.isWaiting) {
+        this.teardown();
+      }
+    }
+  }
+  catch(e) { 
+    if (rethrow) throw e;
+    this.error(e, this); 
+  }
+};
+
+JsUnitTest.Unit.Testcase.prototype.summary = function() {
+  var msg = '#{assertions} assertions, #{failures} failures, #{errors} errors, #{warnings} warnings\n';
+  return new JsUnitTest.Template(msg).evaluate(this) + 
+    this.messages.join("\n");
+};
+
+JsUnitTest.Unit.Testcase.prototype.pass = function() {
+  this.assertions++;
+};
+
+JsUnitTest.Unit.Testcase.prototype.fail = function(message) {
+  this.failures++;
+  var line = "";
+  try {
+    throw new Error("stack");
+  } catch(e){
+    line = (/\.html:(\d+)/.exec(e.stack || '') || ['',''])[1];
+  }
+  this.messages.push("Failure: " + message + (line ? " Line #" + line : ""));
+};
+
+JsUnitTest.Unit.Testcase.prototype.warning = function(message) {
+  this.warnings++;
+  var line = "";
+  try {
+    throw new Error("stack");
+  } catch(e){
+    line = (/\.html:(\d+)/.exec(e.stack || '') || ['',''])[1];
+  }
+  this.messages.push("Warning: " + message + (line ? " Line #" + line : ""));
+};
+JsUnitTest.Unit.Testcase.prototype.warn = JsUnitTest.Unit.Testcase.prototype.warning;
+
+JsUnitTest.Unit.Testcase.prototype.info = function(message) {
+  this.messages.push("Info: " + message);
+};
+
+JsUnitTest.Unit.Testcase.prototype.error = function(error, test) {
+  this.errors++;
+  this.actions['retry with throw'] = function() { test.run(true) };
+  this.messages.push(error.name + ": "+ error.message + "(" + JsUnitTest.inspect(error) + ")");
+};
+
+JsUnitTest.Unit.Testcase.prototype.status = function() {
+  if (this.failures > 0) return 'failed';
+  if (this.errors > 0) return 'error';
+  if (this.warnings > 0) return 'warning';
+  return 'passed';
+};
+
+JsUnitTest.Unit.Testcase.prototype.benchmark = function(operation, iterations) {
+  var startAt = new Date();
+  (iterations || 1).times(operation);
+  var timeTaken = ((new Date())-startAt);
+  this.info((arguments[2] || 'Operation') + ' finished ' + 
+     iterations + ' iterations in ' + (timeTaken/1000)+'s' );
+  return timeTaken;
+};

data/vendor/jsunittest/tasks/deploy.rake

@@ -0,0 +1,29 @@
+desc 'Package and upload the release to rubyforge.'
+task :release => [:clean, :dist, :package] do |t|
+  require 'rubyforge'
+  version = APP_VERSION
+  name    = APP_NAME
+  rubyforge_name = RUBYFORGE_PROJECT
+  v = ENV["VERSION"] or abort "Must supply VERSION=x.y.z"
+  abort "Versions don't match #{v} vs #{version}" if v != version
+  pkg = "pkg/#{name}-#{version}"
+
+  if $DEBUG then
+    puts "release_id = rf.add_release #{rubyforge_name.inspect}, #{name.inspect}, #{version.inspect}, \"#{pkg}.tgz\""
+    puts "rf.add_file #{rubyforge_name.inspect}, #{name.inspect}, release_id, \"#{pkg}.gem\""
+  end
+
+  rf = RubyForge.new
+  puts "Logging in"
+  rf.login
+
+  c = rf.userconfig
+  c["release_notes"] = APP_DESCRIPTION if Object.const_defined?("APP_DESCRIPTION")
+  c["release_changes"] = APP_CHANGES   if Object.const_defined?("APP_CHANGES")
+  c["preformatted"] = true
+
+  files = ["#{pkg}.tar.gz", "dist/#{name}-#{version}.js"].compact
+
+  puts "Releasing #{name} v. #{version}"
+  rf.add_release rubyforge_name, name, version, *files
+end

data/vendor/jsunittest/tasks/environment.rake

@@ -0,0 +1,7 @@
+task :ruby_env do
+  RUBY_APP = if RUBY_PLATFORM =~ /java/
+    "jruby"
+  else
+    "ruby"
+  end unless defined? RUBY_APP
+end

data/vendor/jsunittest/tasks/javascript_test_autotest_tasks.rake

@@ -0,0 +1,44 @@
+TEST_CHANGES_SINCE = Time.now - 600
+
+namespace :test do
+  namespace :recent do
+    desc "Open recently modified files into browser"
+    task :javascript do
+      require 'rubygems'
+      gem 'activesupport'
+      require 'active_support'
+
+      since = TEST_CHANGES_SINCE
+      touched = FileList[
+        'test/unit/*_test.html', 
+        'src/*.js'].select { |path| File.mtime(path) > since }
+      next if touched.blank?
+      
+      gem 'newjs'
+      require 'newjs'
+      require 'newjs/autotest'
+      
+      touched.each do |file|
+        if file =~ /\/([^\/]+)\.js$/
+          file = "test/unit/#{$1}_test.html"
+        end
+        file = "#{APP_ROOT}/#{file}"
+        unless File.exists?(file)
+          puts "Notice: Test file does not exist: #{file}"
+          next
+        end
+        browsers = JavascriptTestAutotest::Config.get :browsers
+        if browsers.blank?
+          puts "WARNING: No browsers setup in config/javascript_test_autotest.yml"
+          next
+        end
+        browsers.each_pair do |name, path|
+          browser = JavascriptTestAutotest::Browser.browser(name, path)
+          browser.setup
+          browser.visit(file)
+          browser.teardown          
+        end
+      end
+    end
+  end
+end

data/vendor/jsunittest/tasks/tmbundle.rake

@@ -0,0 +1,24 @@
+namespace :bundle do
+  bundle_git_repo = "git://github.com/drnic/javascript-unittest-tmbundle.git"
+  bundle_dir = "website/tmbundle"
+  bundle_name = 'JavaScript\ Unit\ Testing.tmbundle'
+  bundle_clone_dir = "#{bundle_dir}/#{bundle_name}"
+  desc "Import TM bundle into website/ and compress"
+  task :import => [:setup, :fetch, :compress]
+
+  task :setup do
+    FileUtils.mkdir_p bundle_dir
+  end
+
+  task :fetch do
+    puts cmd = "git clone #{bundle_git_repo} #{bundle_clone_dir}"
+    `#{cmd}`
+  end
+  
+  task :compress do
+    chdir(bundle_dir) do
+      sh %{tar zcvf #{bundle_name}.tar.gz #{bundle_name} }
+    end    
+    `rm -rf #{bundle_clone_dir}`
+  end
+end

data/vendor/jsunittest/tasks/website.rake

@@ -0,0 +1,53 @@
+require 'yaml'
+
+def website_config
+  unless @website_config
+    begin
+      @website_config = YAML.load(File.read(File.expand_path(File.dirname(__FILE__) + "/../config/website.yml")))
+    rescue
+      puts <<-EOS
+To upload your website to a host, you need to configure
+config/website.yml. See config/website.yml.sample for 
+an example.
+EOS
+      exit
+    end
+  end
+  @website_config
+end
+
+desc 'Generate website files + associated packages + bundles'
+task :website_build => [:ruby_env, :dist, :website_package, "bundle:import", :website_generate]
+
+task :website_generate => :ruby_env do
+  (Dir['website/**/*.txt'] - Dir['website/version*.txt']).each do |txt|
+    sh %{ #{RUBY_APP} script/txt2html #{txt} > #{txt.gsub(/txt$/,'html')} }
+  end
+end
+
+task :website_package do
+  website_package = "#{APP_NAME}-getting-started"
+  website_package_src = "website/dist/#{website_package}"
+  FileUtils.mkdir_p "#{website_package_src}/assets", :verbose => true
+  FileUtils.copy_file "dist/#{APP_FILE_NAME}",       "website/dist/#{APP_FILE_NAME}"
+  FileUtils.copy_file "dist/#{APP_FILE_NAME}",       "website/dist/#{APP_NAME}-#{APP_VERSION}.js"
+
+  FileUtils.copy_file "dist/#{APP_FILE_NAME}",        "#{website_package_src}/assets/#{APP_FILE_NAME}"
+  FileUtils.copy_file "test/assets/unittest.css",     "#{website_package_src}/assets/unittest.css"
+  FileUtils.copy_file "test/assets/example_test.html","#{website_package_src}/example_test.html"
+  chdir(website_package_src) do
+    sh %{tar zcvf ../#{website_package}.tar.gz .}
+    sh %{zip -r ../#{website_package}.zip .}
+  end
+end
+
+desc 'Upload website files to rubyforge'
+task :website_upload do
+  host        = website_config["host"] # "#{rubyforge_username}@rubyforge.org"
+  remote_dir  = website_config["remote_dir"] # "/var/www/gforge-projects/#{PATH}/"
+  local_dir   = 'website'
+  sh %{rsync -aCv #{local_dir}/ #{host}:#{remote_dir}}
+end
+
+desc 'Generate and upload website files'
+task :website => [:website_build, :website_upload]