gabrielg-xultestrunner 0.2.5 → 0.2.6

data/README

@@ -1,7 +1,7 @@
 XULTestRunner
 =============
 
-This is a XUL based test runner for running the quasi-scriptaculous-unittest.js-based tests that Conflagration and WaterTower use.
+This is a XUL based test runner for running the quasi-scriptaculous-unittest.js-based tests that Conflagration and WaterTower and XPCOMCore use.
 
 Yes, it is a XUL app in a RubyGem, yes I am in touch with this.
 

data/Rakefile

@@ -11,6 +11,8 @@ begin
     s.homepage = "http://github.com/gabrielg/xultestrunner"
     s.description = "XUL based test runner for running your JS unit tests."
     s.authors = ["Gabriel Gironda"]
+    # FIXME - weird hack around jeweler ignoring the submoduled in xpcomcore.
+    s.files = (s.files + FileList["xulapp/chrome/content/vendor/**/*"]).uniq
   end
   
   application_ini_path = (Pathname(__FILE__).parent + "xulapp/application.ini").expand_path

data/VERSION

@@ -1 +1 @@
-0.2.5
+0.2.6

data/xulapp/application.ini

@@ -1,7 +1,7 @@
 [App]
 Name=XULTestRunner
-Version=0.2.5
-BuildID=49c734f4-e677-4078-bf50-499f33b8e58f
+Version=0.2.6
+BuildID=f5199da3-fe6b-49ae-9911-7ddfda0ee953
 ID=XULTestRunner@conflagrationjs.org
 Vendor=Conflagration JS
 

data/xulapp/chrome/content/vendor/xpcomcore/README

@@ -0,0 +1,31 @@
+XPCOMCore
+=========
+
+A standard library like Ruby's, only for JavaScript (with XPCOM access).
+
+Installation
+============
+
+Check out / submodule in / whatever the code to a place of your choosing. Then load it from an XPCOM component like so:
+
+    COMPONENTS = [];
+    var loader = Components.classes["@mozilla.org/moz/jssubscript-loader;1"].getService(Components.interfaces.mozIJSSubScriptLoader);
+    // We use the /app resource here because of yet another weird firefox issue where the /xultestrunner resource
+    // isn't working as the XPCOM component gets registered.
+    loader.loadSubScript("resource://app/chrome/content/vendor/xpcomcore/bootstrap.js");
+    loader.loadSubScript("resource://xpcomcore/loader.js");
+
+Make sure that if you're registering your own component, you add it to the COMPONENTS array and build NSGetModule that way, kind of like so:
+
+    COMPONENTS.push(MYXPCOMComponent);  
+    NSGetModule = function(compMgr, fileSpec) {
+      return XPCOMUtils.generateModule(COMPONENTS);
+    };
+    
+Then, whenever you want to make use of XPCOMCore (say, from a XUL window), load the resource in like so:
+
+    <script type="text/javascript" src="resource://xpcomcore/loader.js" />
+    
+Then you'll have access to methods such as load() and require() and whatever else is defined in Kernel.
+
+- Gabriel Gironda

data/xulapp/chrome/content/vendor/xpcomcore/Rakefile

@@ -0,0 +1,7 @@
+task :test do
+  require 'pathname'
+  ENV['XPCOMCORE'] = (Pathname(__FILE__).parent + "bootstrap.js").expand_path.to_s
+  exec("xultest", "-testDir", (Pathname(__FILE__).parent + "test/").expand_path.to_s)
+end
+
+task :default => :test

data/xulapp/chrome/content/vendor/xpcomcore/bootstrap.js

@@ -0,0 +1,108 @@
+(function(backStage) {
+  if (typeof(COMPONENTS) == 'undefined') {
+    throw("Please define a COMPONENTS array before loading XPCOMCore.");
+  };
+  
+  var requiredMinGeckoVersion = '1.9.0'; // RequiredMinGeckoVersion - Do not remove this comment.
+  var xpcomCoreVersion = '0.1.0'; // XPCOMCoreVersion - Do not remove this comment.
+  
+  var checkGeckoVersion = function() {
+    var versionComparator = Components.classes["@mozilla.org/xpcom/version-comparator;1"].getService(Components.interfaces.nsIVersionComparator);
+    var appInfo = Components.classes["@mozilla.org/xre/app-info;1"].getService(Components.interfaces.nsIXULAppInfo);
+    if (versionComparator.compare(appInfo.platformVersion, requiredMinGeckoVersion) < 0) {
+      throw("Gecko version '" + appInfo.platformVersion + "' is unable to use XPCOMCore.");
+    }
+  };
+  
+  var setupXPCOMCore = function() {
+    Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+    
+    var ioService = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
+    var resProt = ioService.getProtocolHandler("resource").QueryInterface(Components.interfaces.nsIResProtocolHandler);
+    // FIXME IN GENERAL - refactor all this shit code
+    
+    var ourFileURIString = function() {
+      // FIXME - Great. All this is a dance around the fact line #289 of mozJSSubScriptLoader.cpp in mozilla 1.9.1
+      // thinks that the best way to delimit script files is with a fucking ASCII arrow YOU FUCKS
+      var thisFile = (new Error).stack.split("\n")[2].split("@")[1].split(" -> ").slice(-1)[0].split(/:[0-9]/)[0];
+      return thisFile;
+    };
+    
+    var ourFileURI = function() {
+      return ioService.newURI(ourFileURIString(), null, null).QueryInterface(Components.interfaces.nsIURL);
+    };
+    
+    // FIXME - hilariously non-cross-platform
+    var ourLibDir = function() {
+      var fileURI = ourFileURI();
+      if (fileURI.scheme == "resource") {
+        var thisDir = ioService.newURI(resProt.resolveURI(fileURI), null, null).QueryInterface(Components.interfaces.nsIURL).directory;
+      } else {
+        // Assumes we're a file:// URI
+        var thisDir = fileURI.directory;
+      }
+      return thisDir + "lib/";
+    };
+
+    // FIXME - hilariously non-cross-platform
+    var setupResourceSubstition = function() {
+      resProt.setSubstitution("xpcomcore", ioService.newURI("file://" + ourLibDir(), null, null));
+    };
+    
+    setupResourceSubstition();
+    var libDirectory = ourLibDir();
+
+    // Private XPCOMCoreMCP method. This is the jank that finally sets up our resouce substition 
+    // and loads Kernel methods into the given scope and .
+    var loadKernel = function(scope) {
+
+      // Copy properties from Kernel to the scope as getters as part of the kernel loading
+      // TODO - skip non-function properties
+      for (p in scope.Kernel) {
+        scope.__defineGetter__(p, function() { return scope.Kernel[p] });
+      }
+    };
+    
+    // XPCOMCoreMCP is a singleton
+    var xpcomCoreInstance = null;
+    var XPCOMCoreMCP = function() { 
+      if (xpcomCoreInstance) { return xpcomCoreInstance; }
+      xpcomCoreInstance = this.wrappedJSObject = this;
+      
+    };
+    
+    XPCOMCoreMCP.prototype = {
+      classDescription: "XPCOMCore Core Object",
+      contractID: "@conflagrationjs.org/xpcomcore/core;1",
+      classID: Components.ID("{f562f600-9c25-11de-8a39-0800200c9a66}"),
+      QueryInterface: XPCOMUtils.generateQI(),
+      _xpcom_categories: [{category: "JavaScript global property", entry: "XPCOMCoreMCP"}],
+      
+      get version() { return new String(xpcomCoreVersion); },
+      get libRoot() { return new String(libDirectory); },
+      
+      loadInto: function(loadScope) {
+        if (!loadScope || loadScope.XPCOMCoreLoaded) {
+          return false;
+        } else {
+          loadKernel(loadScope);
+          loadScope.XPCOMCoreLoaded = true;
+          return true;
+        }
+      }
+    };
+    
+    backStage.XPCOMCoreMCP = XPCOMCoreMCP;
+    // Make sure we actually register the component or everything blows up
+    COMPONENTS.push(XPCOMCoreMCP);
+
+  };
+  
+  try {
+    checkGeckoVersion();
+    setupXPCOMCore();
+  } catch (e) {
+    dump("Couldn't register XPCOMCore: " + e + "\n");
+  }
+
+})(this);

data/xulapp/chrome/content/vendor/xpcomcore/lib/kernel.js

@@ -0,0 +1,77 @@
+// Convenience shortcuts
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cr = Components.results;
+const Cu = Components.utils;
+
+// Taking some inspiration from Ruby here...
+const $LOAD_PATH = [XPCOMCore.libRoot];
+const $LOADED_FEATURES = ["kernel.js"];
+
+const $FILE = function() {
+  var ioService = Cc["@mozilla.org/network/io-service;1"].getService(Ci.nsIIOService);
+  var thisFile = (new Error).stack.split("\n")[2].split("@")[1].split(" -> ").slice(-1)[0].split(/:[0-9]/)[0];
+  var thisFileURI = ioService.newURI(thisFile, null, null);
+  
+  if (thisFileURI.scheme == "resource") {
+    var resProt = ioService.getProtocolHandler("resource").QueryInterface(Components.interfaces.nsIResProtocolHandler);
+    return ioService.newURI(resProt.resolveURI(thisFileURI), null, null).QueryInterface(Ci.nsIURL).path;
+  } else if (thisFileURI.scheme == "file") {
+    return thisFileURI.QueryInterface(Ci.nsIURL).path;
+  } else {
+    // FIXME - throw an appropriate exception here.
+    return null;
+  }
+}
+
+// FIXME - better exceptions.
+const LoadError = {name: "LoadError", message: "Could not load file"};
+
+const Kernel = {
+  
+  print: function(str) {
+    dump(str);
+  },
+  
+  puts: function(str) {
+    print(str + "\n");
+  },
+
+  load: function(featurePath) {
+    var loader = Cc["@mozilla.org/moz/jssubscript-loader;1"].getService(Ci.mozIJSSubScriptLoader);
+    var foundFile = null;
+    // FIXME - so this is kinda shitty. We have an empty entry here so we default to just trying to load 
+    // from an absolute path
+    var loadPath = $LOAD_PATH.concat([""]);
+    var loadPathLength = loadPath.length;
+    // FIXME - mozilla bug here. if i use foreach on array it ignores the granted security privileges
+    for (var i = 0; i < loadPathLength; i++) {
+      var potentialFile = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsILocalFile);
+      potentialFile.initWithPath(loadPath[i] + "/" + featurePath);
+      if (potentialFile.exists()) { 
+        foundFile = potentialFile; 
+        break;
+      }
+    };
+    if (foundFile) {
+      foundFile.normalize();
+      loader.loadSubScript("file://" + encodeURI(foundFile.path));
+      $LOADED_FEATURES.push(featurePath)  
+    } else {
+      throw(LoadError);
+    }
+  },
+  
+  require: function(feature) {
+    var jsFeature = feature + ".js";
+    if ($LOADED_FEATURES.indexOf(jsFeature) == -1) {
+      load(jsFeature);
+      return true;
+    } else {
+      return false;
+    }
+  }
+}
+
+// FIXME - i just puked in my mouth a little.
+for (p in Kernel) { eval('var ' + p + ' = Kernel[p];'); }

data/xulapp/chrome/content/vendor/xpcomcore/lib/loader.js

@@ -0,0 +1,16 @@
+// FIXME - If we're still backstage, load differently. Need a better way to check for being backstage.
+// FIXME - wow, this is all so seedy.
+var _coreObj = null;
+if (this.toString() == "[object BackstagePass]" && typeof(XPCOMCore) == 'undefined') {
+  _coreObj = new this.XPCOMCoreMCP();
+} else if (this.XPCOMCoreMCP && typeof(XPCOMCore) == 'undefined') {
+  var privileges = 'UniversalXPConnect UniversalBrowserRead UniversalBrowserWrite ' +
+                   'UniversalPreferencesRead UniversalPreferencesWrite CapabilityPreferencesAccess UniversalFileRead';
+  netscape.security.PrivilegeManager.enablePrivilege(privileges);
+  _coreObj = this.XPCOMCoreMCP.wrappedJSObject;
+};
+
+const XPCOMCore = _coreObj;
+
+var loader = Components.classes["@mozilla.org/moz/jssubscript-loader;1"].getService(Components.interfaces.mozIJSSubScriptLoader);
+loader.loadSubScript("resource://xpcomcore/kernel.js");

data/xulapp/chrome/content/vendor/xpcomcore/test/kernel_test.js

@@ -0,0 +1,7 @@
+XULTestCase.create("Kernel Test", function(setup, teardown, test) {
+  
+  test("it would be swell if i wrote a test", function(){
+    this.assert(false);
+  });
+  
+});

data/xultestrunner.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{xultestrunner}
-  s.version = "0.2.5"
+  s.version = "0.2.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Gabriel Gironda"]
-  s.date = %q{2009-09-08}
+  s.date = %q{2009-09-10}
   s.default_executable = %q{xultest}
   s.description = %q{XUL based test runner for running your JS unit tests.}
   s.email = %q{contact@gironda.org}
@@ -38,6 +38,12 @@ Gem::Specification.new do |s|
      "xulapp/chrome/content/vendor/scriptaculous/LICENSE",
      "xulapp/chrome/content/vendor/scriptaculous/test.css",
      "xulapp/chrome/content/vendor/scriptaculous/unittest.js",
+     "xulapp/chrome/content/vendor/xpcomcore/README",
+     "xulapp/chrome/content/vendor/xpcomcore/Rakefile",
+     "xulapp/chrome/content/vendor/xpcomcore/bootstrap.js",
+     "xulapp/chrome/content/vendor/xpcomcore/lib/kernel.js",
+     "xulapp/chrome/content/vendor/xpcomcore/lib/loader.js",
+     "xulapp/chrome/content/vendor/xpcomcore/test/kernel_test.js",
      "xulapp/components/bootstrap.js",
      "xulapp/defaults/preferences/prefs.js",
      "xultestrunner.gemspec"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: gabrielg-xultestrunner
 version: !ruby/object:Gem::Version 
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors: 
 - Gabriel Gironda
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-08 00:00:00 -07:00
+date: 2009-09-10 00:00:00 -07:00
 default_executable: xultest
 dependencies: []
 
@@ -42,11 +42,18 @@ files:
 - xulapp/chrome/content/vendor/scriptaculous/LICENSE
 - xulapp/chrome/content/vendor/scriptaculous/test.css
 - xulapp/chrome/content/vendor/scriptaculous/unittest.js
+- xulapp/chrome/content/vendor/xpcomcore/README
+- xulapp/chrome/content/vendor/xpcomcore/Rakefile
+- xulapp/chrome/content/vendor/xpcomcore/bootstrap.js
+- xulapp/chrome/content/vendor/xpcomcore/lib/kernel.js
+- xulapp/chrome/content/vendor/xpcomcore/lib/loader.js
+- xulapp/chrome/content/vendor/xpcomcore/test/kernel_test.js
 - xulapp/components/bootstrap.js
 - xulapp/defaults/preferences/prefs.js
 - xultestrunner.gemspec
 has_rdoc: false
 homepage: http://github.com/gabrielg/xultestrunner
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --charset=UTF-8
@@ -67,7 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: XUL based test runner for running your JS unit tests.