newjs 1.5.1 → 1.7.0

data/vendor/jshoulda/Rakefile

@@ -0,0 +1,120 @@
+require 'rubygems'
+begin
+  require 'rake'
+rescue LoadError
+  puts 'This script should only be accessed via the "rake" command.'
+  puts 'Installation: gem install rake -y'
+  exit
+end
+require 'rake'
+require 'rake/clean'
+require 'rake/packagetask'
+
+$:.unshift File.dirname(__FILE__) + "/lib"
+
+APP_VERSION  = '1.2.1'
+APP_NAME     = 'jshoulda'
+RUBYFORGE_PROJECT = APP_NAME
+APP_TEMPLATE = "#{APP_NAME}.js.erb"
+APP_FILE_NAME= "#{APP_NAME}.js"
+
+APP_ROOT     = File.expand_path(File.dirname(__FILE__))
+APP_SRC_DIR  = File.join(APP_ROOT, 'src')
+APP_DIST_DIR = File.join(APP_ROOT, 'dist')
+APP_PKG_DIR  = File.join(APP_ROOT, 'pkg')
+
+
+unless ENV['rakefile_just_config']
+  
+  
+CLEAN.include [ "#{APP_DIST_DIR}/#{APP_NAME}.js", "#{APP_DIST_DIR}/#{APP_NAME}-#{APP_VERSION}.js" ]
+
+task :default => [:dist, :package, :clean_package_source]
+
+desc "Builds the distribution"
+task :dist do
+  $:.unshift File.join(APP_ROOT, 'lib')
+  require 'protodoc'
+  require 'fileutils'
+  FileUtils.mkdir_p APP_DIST_DIR
+
+  Dir.chdir(APP_SRC_DIR) do
+    File.open(File.join(APP_DIST_DIR, APP_FILE_NAME), 'w+') do |dist|
+      dist << Protodoc::Preprocessor.new(APP_TEMPLATE)
+    end
+  end
+  Dir.chdir(APP_DIST_DIR) do
+    FileUtils.copy_file APP_FILE_NAME, "#{APP_NAME}-#{APP_VERSION}.js"
+  end
+end
+
+Rake::PackageTask.new(APP_NAME, APP_VERSION) do |package|
+  package.need_tar_gz = true
+  package.package_dir = APP_PKG_DIR
+  package.package_files.include(
+    '[A-Z]*',
+    'config/*.sample',
+    "dist/#{APP_FILE_NAME}",
+    'lib/**',
+    'src/**',
+    'script/**',
+    'tasks/**',
+    'test/**',
+    'website/**'
+  )
+end
+
+desc "Builds the distribution, runs the JavaScript unit + functional tests and collects their results."
+task :test => [:dist, :test_units, :test_functionals]
+
+require 'jstest'
+desc "Runs all the JavaScript unit tests and collects the results"
+JavaScriptTestTask.new(:test_units, 4711) do |t|
+  testcases        = ENV['TESTCASES']
+  tests_to_run     = ENV['TESTS']    && ENV['TESTS'].split(',')
+  browsers_to_test = ENV['BROWSERS'] && ENV['BROWSERS'].split(',')
+
+  t.mount("/dist")
+  t.mount("/src")
+  t.mount("/test")
+
+  Dir["test/unit/*_test.html"].sort.each do |test_file|
+    tests = testcases ? { :url => "/#{test_file}", :testcases => testcases } : "/#{test_file}"
+    test_filename = test_file[/.*\/(.+?)\.html/, 1]
+    t.run(tests) unless tests_to_run && !tests_to_run.include?(test_filename)
+  end
+
+  %w( safari firefox ie konqueror opera ).each do |browser|
+    t.browser(browser.to_sym) unless browsers_to_test && !browsers_to_test.include?(browser)
+  end
+end
+
+desc "Runs all the JavaScript functional tests and collects the results"
+JavaScriptTestTask.new(:test_functionals, 4712) do |t|
+  testcases        = ENV['TESTCASES']
+  tests_to_run     = ENV['TESTS']    && ENV['TESTS'].split(',')
+  browsers_to_test = ENV['BROWSERS'] && ENV['BROWSERS'].split(',')
+
+  t.mount("/dist")
+  t.mount("/src")
+  t.mount("/test")
+
+  Dir["test/functional/*_test.html"].sort.each do |test_file|
+    tests = testcases ? { :url => "/#{test_file}", :testcases => testcases } : "/#{test_file}"
+    test_filename = test_file[/.*\/(.+?)\.html/, 1]
+    t.run(tests) unless tests_to_run && !tests_to_run.include?(test_filename)
+  end
+
+  %w( safari firefox ie konqueror opera ).each do |browser|
+    t.browser(browser.to_sym) unless browsers_to_test && !browsers_to_test.include?(browser)
+  end
+end
+
+
+task :clean_package_source do
+  rm_rf File.join(APP_PKG_DIR, "#{APP_NAME}-#{APP_VERSION}")
+end
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }
+
+end

data/vendor/jshoulda/config/javascript_test_autotest.yml.sample

@@ -0,0 +1,15 @@
+# This file has been copied here by the javascript_test_autotest plugin.
+# Comment/uncomment the browsers you wish to autotest with.
+# Same schema as per selenium-on-rails plugin, which is nice.
+browsers:
+  # Windows
+  # firefox: 'c:\Program Files\Mozilla Firefox\firefox.exe'
+  # ie: 'c:\Program Files\Internet Explorer\iexplore.exe'
+
+  # Mac OS X
+  # firefox: '/Applications/Firefox.app/Contents/MacOS/firefox-bin'
+  safari: '/Applications/Safari.app/Contents/MacOS/Safari'
+
+  # Unix
+  # ?
+  # ?

data/vendor/jshoulda/dist/jshoulda-0.0.1.js

@@ -0,0 +1,62 @@
+/*  Jshoulda, version 0.0.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 context, should;
+(function() {
+  // the test runner
+  var tr;
+
+  function dummy() {
+  };
+
+  function runQueue(queue, name, before, after) {
+    var i, tests;
+    for (i = 0; i < queue.length; i += 1) {
+      tests = queue[i](name, before, after);
+      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);
+      }
+    };
+  }
+
+  context = function(name, obj) {
+    obj.before = obj.before || dummy;
+    obj.after = obj.after || dummy;
+    var queue = Array.prototype.slice.call(arguments, 2);
+    var beforeQueue;
+    var afterQueue;
+    tr = tr || new JsUnitTest.Unit.Runner({}, {testLog: 'testlog'});
+    return function(outerName, before, after) {
+      beforeQueue = before ? before.push(obj.before) && before : [obj.before];
+      afterQueue = after ? after.push(obj.after) && after : [obj.after];
+      runQueue(queue, [outerName, name].join(' '), beforeQueue, afterQueue);
+      return false; // do not add to the tests queue
+    };
+  };
+
+  should = function(name, fn) {
+    return function(prefix, before, after) {
+      var beforeBatch = makeBatch(before);
+      var afterBatch = makeBatch(after);
+      return new JsUnitTest.Unit.Testcase([prefix, name].join(' should '), fn, beforeBatch, afterBatch);
+    };
+  };
+
+
+})();

data/vendor/jshoulda/dist/jshoulda-0.0.2.js

@@ -0,0 +1,72 @@
+/*  Jshoulda, version 0.0.2
+ *  (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 context, should;
+(function() {
+  // the test runner
+  var tr;
+
+  function dummy() {
+  };
+
+  function runQueue(queue, name, before, after) {
+    var i, tests;
+    for (i = 0; i < queue.length; i += 1) {
+      tests = queue[i](name, before, after);
+      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);
+      }
+    };
+  }
+
+  context = function(name, obj) {
+    obj.before = obj.setup || obj.before || dummy;
+    obj.after = obj.teardown || obj.after || dummy;
+    var queue = Array.prototype.slice.call(arguments, 2);
+    var beforeQueue;
+    var afterQueue;
+    return function(outerName, before, after) {
+      // 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 = new JsUnitTest.Unit.Runner({}, outerName || {});
+        prefix = '';
+      }
+      beforeQueue = before ? before.push(obj.before) && before : [obj.before];
+      afterQueue = after ? after.push(obj.after) && after : [obj.after];
+      runQueue(queue, [prefix, name].join(' '), beforeQueue, afterQueue);
+      if (is_root) {
+        return tr;
+      }
+      return false; // do not add to the tests queue
+    };
+  };
+
+  should = function(name, fn) {
+    return function(prefix, before, after) {
+      var beforeBatch = makeBatch(before);
+      var afterBatch = makeBatch(after);
+      return new Test.Unit.Testcase([prefix, name].join(' should '), fn, beforeBatch, afterBatch);
+    };
+  };
+
+
+})();

data/vendor/jshoulda/dist/jshoulda-0.0.3.js

@@ -0,0 +1,72 @@
+/*  jShoulda, version 0.0.3
+ *  (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 context, should;
+(function() {
+  // the test runner
+  var tr;
+
+  function dummy() {
+  };
+
+  function runQueue(queue, name, before, after) {
+    var i, tests;
+    for (i = 0; i < queue.length; i += 1) {
+      tests = queue[i](name, before, after);
+      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);
+      }
+    };
+  }
+
+  context = function(name, obj) {
+    obj.before = obj.setup || obj.before || dummy;
+    obj.after = obj.teardown || obj.after || dummy;
+    var queue = Array.prototype.slice.call(arguments, 2);
+    var beforeQueue;
+    var afterQueue;
+    return function(outerName, before, after) {
+      // 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 = new Test.Unit.Runner({}, outerName || {});
+        prefix = '';
+      }
+      beforeQueue = before ? before.push(obj.before) && before : [obj.before];
+      afterQueue = after ? after.push(obj.after) && after : [obj.after];
+      runQueue(queue, [prefix, name].join(' '), beforeQueue, afterQueue);
+      if (is_root) {
+        return tr;
+      }
+      return false; // do not add to the tests queue
+    };
+  };
+
+  should = function(name, fn) {
+    return function(prefix, before, after) {
+      var beforeBatch = makeBatch(before);
+      var afterBatch = makeBatch(after);
+      return new Test.Unit.Testcase([prefix, name].join(' should '), fn, beforeBatch, afterBatch);
+    };
+  };
+
+
+})();

data/vendor/jshoulda/dist/jshoulda-1.0.1.js

@@ -0,0 +1,74 @@
+/*  jShoulda, version 1.0.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 context, should;
+(function() {
+  // the test runner
+  var tr;
+
+  function dummy() {
+  };
+
+  function runQueue(queue, name, before, after) {
+    var i, tests;
+    for (i = 0; i < queue.length; i += 1) {
+      tests = queue[i](name, before, after);
+      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);
+      }
+    };
+  }
+
+  context = function(name, obj) {
+    obj.before = obj.setup || obj.before || dummy;
+    obj.after = obj.teardown || obj.after || dummy;
+    var queue = Array.prototype.slice.call(arguments, 2);
+    var beforeQueue;
+    var afterQueue;
+    return function(outerName, before, after) {
+      // 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 = new Test.Unit.Runner({}, outerName || {});
+        prefix = '';
+      }
+      beforeQueue = before ? before.push(obj.before) && before : [obj.before];
+      afterQueue = after ? after.push(obj.after) && after : [obj.after];
+      runQueue(queue, [prefix, name].join(' '), beforeQueue, afterQueue);
+      if (is_root) {
+        return tr;
+      }
+      return false; // do not add to the tests queue
+    };
+  };
+
+  should = function(name, fn) {
+    return function(prefix, before, after) {
+      var beforeBatch = makeBatch(before);
+      var afterBatch = makeBatch(after);
+      return new Test.Unit.Testcase([prefix, name].join(' ' + should.connector + ' '), fn, beforeBatch, afterBatch);
+    };
+  };
+
+  should.connector = 'should';
+
+
+})();

data/vendor/jshoulda/dist/jshoulda-1.0.js

@@ -0,0 +1,72 @@
+/*  jShoulda, version 1.0
+ *  (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 context, should;
+(function() {
+  // the test runner
+  var tr;
+
+  function dummy() {
+  };
+
+  function runQueue(queue, name, before, after) {
+    var i, tests;
+    for (i = 0; i < queue.length; i += 1) {
+      tests = queue[i](name, before, after);
+      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);
+      }
+    };
+  }
+
+  context = function(name, obj) {
+    obj.before = obj.setup || obj.before || dummy;
+    obj.after = obj.teardown || obj.after || dummy;
+    var queue = Array.prototype.slice.call(arguments, 2);
+    var beforeQueue;
+    var afterQueue;
+    return function(outerName, before, after) {
+      // 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 = new Test.Unit.Runner({}, outerName || {});
+        prefix = '';
+      }
+      beforeQueue = before ? before.push(obj.before) && before : [obj.before];
+      afterQueue = after ? after.push(obj.after) && after : [obj.after];
+      runQueue(queue, [prefix, name].join(' '), beforeQueue, afterQueue);
+      if (is_root) {
+        return tr;
+      }
+      return false; // do not add to the tests queue
+    };
+  };
+
+  should = function(name, fn) {
+    return function(prefix, before, after) {
+      var beforeBatch = makeBatch(before);
+      var afterBatch = makeBatch(after);
+      return new Test.Unit.Testcase([prefix, name].join(' should '), fn, beforeBatch, afterBatch);
+    };
+  };
+
+
+})();