Ticket #627: bootstrapRefactor.patch

src/text/Text.js

@@ -1 @@
-dj_deprecated("dojo.text.Text is being replaced by dojo.string");
+dojo.deprecated("dojo.text.Text is being replaced by dojo.string");
 dojo.require("dojo.string");
 
 dojo.text = dojo.string;

src/text/Builder.js

@@ -1 +1 @@
 dojo.provide("dojo.text.Builder");
 dojo.require("dojo.string.Builder");
 
-dj_deprecated("dojo.text.Builder is deprecated, use dojo.string.Builder instead");
+dojo.deprecated("dojo.text.Builder is deprecated, use dojo.string.Builder instead");
 
 dojo.text.Builder = dojo.string.Builder;

src/text/String.js

@@ -1 @@
-dj_deprecated("dojo.text.String is being replaced by dojo.string");
+dojo.deprecated("dojo.text.String is being replaced by dojo.string");
 dojo.require("dojo.string");
 
 dojo.text = dojo.string;

src/hostenv_rhino.js

@@ -10 +10 @@
 @*/
 
 // TODO: not sure what we gain from the next line, anyone?
-//if (typeof loadClass == 'undefined') { dj_throw("attempt to use Rhino host environment when no 'loadClass' global"); }
+//if (typeof loadClass == 'undefined') { dojo.raise("attempt to use Rhino host environment when no 'loadClass' global"); }
 
 dojo.render.name = dojo.hostenv.name_ = 'rhino';
 dojo.hostenv.getVersion = function() {return version()};
@@ -101 +101 @@
 // do it by using java java.lang.Exception
 function dj_rhino_current_script_via_java(depth) {
     var optLevel = Packages.org.mozilla.javascript.Context.getCurrentContext().getOptimizationLevel();  
-    if (optLevel == -1) dj_unimplemented("getCurrentScriptURI (determine current script path for rhino when interpreter mode)", '');
+    if (optLevel == -1) dojo.unimplemented("getCurrentScriptURI (determine current script path for rhino when interpreter mode)", '');
     var caw = new java.io.CharArrayWriter();
     var pw = new java.io.PrintWriter(caw);
     var exc = new java.lang.Exception();

src/hostenv_jsc.js

@@ -9 +9 @@
 // See the Rotor source code jscript/engine/globalobject.cs for what globals
 // are available.
 if((typeof ScriptEngineMajorVersion != 'function')||(ScriptEngineMajorVersion() < 7)){
-        dj_throw("attempt to use JScript .NET host environment with inappropriate ScriptEngine"); 
+        dojo.raise("attempt to use JScript .NET host environment with inappropriate ScriptEngine"); 
 }
 
 // for more than you wanted to know about why this import is required even if
@@ -19 +19 @@
 
 dojo.hostenv.getText = function(uri){
         if(!System.IO.File.Exists(uri)){
-                // dj_throw("No such file '" + uri + "'");
+                // dojo.raise("No such file '" + uri + "'");
                 return 0;
         }
         var reader = new System.IO.StreamReader(uri);
@@ -30 +30 @@
 dojo.hostenv.loadUri = function(uri){
         var contents = this.getText(uri);
         if(!contents){
-                dj_throw("got no back contents from uri '" + uri + "': " + contents);
+                dojo.raise("got no back contents from uri '" + uri + "': " + contents);
         }
         // TODO: in JScript .NET, eval will not affect the symbol table of the current code?
         var value = dj_eval(contents);

src/browser_debug.js

@@ -1 +1 @@
 dojo.hostenv.loadedUris.push("../src/bootstrap1.js");
+dojo.hostenv.loadedUris.push("../src/bootstrap2.js");
 dojo.hostenv.loadedUris.push("../src/hostenv_browser.js");
-dojo.hostenv.loadedUris.push("../src/bootstrap2.js");
 
 function removeComments(contents){
         contents = new String((!contents) ? "" : contents);
@@ -14 +14 @@
 dojo.hostenv.getRequiresAndProvides = function(contents){
         // FIXME: should probably memoize this!
         if(!contents){ return []; }
+        
 
         // check to see if we need to load anything else first. Ugg.
         var deps = [];
         var tmp;
         RegExp.lastIndex = 0;
-        var testExp = /dojo.(hostenv.loadModule|hosetnv.require|require|requireIf|hostenv.conditionalLoadModule|hostenv.startPackage|hostenv.provide|provide)\([\w\W]*?\)/mg;
+        var testExp = /dojo.(hostenv.loadModule|hosetnv.require|require|requireIf|hostenv.conditionalLoadModule|hostenv.startPackage|provide)\([\w\W]*?\)/mg;
         while((tmp = testExp.exec(contents)) != null){
                 deps.push(tmp[0]);
         }
@@ -34 +35 @@
         var deps = [];
         var tmp;
         RegExp.lastIndex = 0;
-        var testExp = /dojo.(requireAfterIf|requireAfter)\([\w\W]*?\)/mg;
+        var testExp = /dojo.(requireAfterIf|requireIf)\([\w\W]*?\)/mg;
         while((tmp = testExp.exec(contents)) != null){
                 deps.push(tmp[0]);
         }

src/bootstrap2.js

@@ -1 +1 @@
 /*
- * bootstrap2.js - runs after the hostenv_*.js file.
+ * bootstrap2.js - runs before the hostenv_*.js file. Contains all of the package loading methods.
  */
 
+//Additional properties for dojo.hostenv
+var _addHostEnv = {
+        pkgFileName: "__package__",
+
+        // for recursion protection
+        loading_modules_: {},
+        loaded_modules_: {},
+        addedToLoadingCount: [],
+        removedFromLoadingCount: [],
+
+        inFlightCount: 0,
+
+        // FIXME: it should be possible to pull module prefixes in from djConfig
+        modulePrefixes_: {
+                dojo: {name: "dojo", value: "src"}
+        },
+
+
+        setModulePrefix: function(module, prefix){
+                this.modulePrefixes_[module] = {name: module, value: prefix};
+        },
+
+        getModulePrefix: function(module){
+                var mp = this.modulePrefixes_;
+                if((mp[module])&&(mp[module]["name"])){
+                        return mp[module].value;
+                }
+                return module;
+        },
+
+        getTextStack: [],
+        loadUriStack: [],
+        loadedUris: [],
+
+        //WARNING: This variable is referenced by packages outside of bootstrap: FloatingPane.js and undo/browser.js
+        post_load_: false,
+        
+        //Egad! Lots of test files push on this directly instead of using dojo.addOnLoad.
+        modulesLoadedListeners: [],
+}
+
+//Add all of these properties to dojo.hostenv
+for(var param in _addHostEnv){
+        dojo.hostenv[param] = _addHostEnv[param];
+}
+                              
+/**
+ * Loads and interprets the script located at relpath, which is relative to the
+ * script root directory.  If the script is found but its interpretation causes
+ * a runtime exception, that exception is not caught by us, so the caller will
+ * see it.  We return a true value if and only if the script is found.
+ *
+ * For now, we do not have an implementation of a true search path.  We
+ * consider only the single base script uri, as returned by getBaseScriptUri().
+ *
+ * @param relpath A relative path to a script (no leading '/', and typically
+ * ending in '.js').
+ * @param module A module whose existance to check for after loading a path.
+ * Can be used to determine success or failure of the load.
+ */
+dojo.hostenv.loadPath = function(relpath, module /*optional*/, cb /*optional*/){
+        if((relpath.charAt(0) == '/')||(relpath.match(/^\w+:/))){
+                dojo.raise("relpath '" + relpath + "'; must be relative");
+        }
+        var uri = this.getBaseScriptUri() + relpath;
+        if(djConfig.cacheBust && dojo.render.html.capable) { uri += "?" + String(djConfig.cacheBust).replace(/\W+/g,""); }
+        try{
+                return ((!module) ? this.loadUri(uri, cb) : this.loadUriAndCheck(uri, module, cb));
+        }catch(e){
+                dojo.debug(e);
+                return false;
+        }
+}
+
+/**
+ * Reads the contents of the URI, and evaluates the contents.
+ * Returns true if it succeeded. Returns false if the URI reading failed.
+ * Throws if the evaluation throws.
+ * The result of the eval is not available to the caller.
+ */
+dojo.hostenv.loadUri = function(uri, cb){
+        if(this.loadedUris[uri]){
+                return;
+        }
+        var contents = this.getText(uri, null, true);
+        if(contents == null){ return 0; }
+        this.loadedUris[uri] = true;
+        var value = dj_eval(contents);
+        return 1;
+}
+
+// FIXME: probably need to add logging to this method
+dojo.hostenv.loadUriAndCheck = function(uri, module, cb){
+        var ok = true;
+        try{
+                ok = this.loadUri(uri, cb);
+        }catch(e){
+                dojo.debug("failed loading ", uri, " with error: ", e);
+        }
+        return ((ok)&&(this.findModule(module, false))) ? true : false;
+}
+
+dojo.loaded = function(){ }
+
+dojo.hostenv.loaded = function(){
+        this.post_load_ = true;
+        var mll = this.modulesLoadedListeners;
+        for(var x=0; x<mll.length; x++){
+                mll[x]();
+        }
+        dojo.loaded();
+}
+
 /*
+Call styles:
+        dojo.addOnLoad(functionPointer)
+        dojo.addOnLoad(object, "functionName")
+*/
+dojo.addOnLoad = function(obj, fcnName) {
+        if(arguments.length == 1) {
+                dojo.hostenv.modulesLoadedListeners.push(obj);
+        } else if(arguments.length > 1) {
+                dojo.hostenv.modulesLoadedListeners.push(function() {
+                        obj[fcnName]();
+                });
+        }
+}
+
+dojo.hostenv.modulesLoaded = function(){
+        if(this.post_load_){ return; }
+        if((this.loadUriStack.length==0)&&(this.getTextStack.length==0)){
+                if(this.inFlightCount > 0){ 
+                        dojo.debug("files still in flight!");
+                        return;
+                }
+                if(typeof setTimeout == "object"){
+                        setTimeout("dojo.hostenv.loaded();", 0);
+                }else{
+                        dojo.hostenv.loaded();
+                }
+        }
+}
+
+dojo.hostenv.moduleLoaded = function(modulename){
+        var modref = dojo.evalObjPath((modulename.split(".").slice(0, -1)).join('.'));
+        this.loaded_modules_[(new String(modulename)).toLowerCase()] = modref;
+}
+
+/**
+* loadModule("A.B") first checks to see if symbol A.B is defined. 
+* If it is, it is simply returned (nothing to do).
+*
+* If it is not defined, it will look for "A/B.js" in the script root directory,
+* followed by "A.js".
+*
+* It throws if it cannot find a file to load, or if the symbol A.B is not
+* defined after loading.
+*
+* It returns the object A.B.
+*
+* This does nothing about importing symbols into the current package.
+* It is presumed that the caller will take care of that. For example, to import
+* all symbols:
+*
+*    with (dojo.hostenv.loadModule("A.B")) {
+*       ...
+*    }
+*
+* And to import just the leaf symbol:
+*
+*    var B = dojo.hostenv.loadModule("A.B");
+*    ...
+*
+* dj_load is an alias for dojo.hostenv.loadModule
+*/
+dojo.hostenv._global_omit_module_check = false;
+dojo.hostenv.loadModule = function(modulename, exact_only, omit_module_check){
+        if(!modulename){ return; }
+        omit_module_check = this._global_omit_module_check || omit_module_check;
+        var module = this.findModule(modulename, false);
+        if(module){
+                return module;
+        }
+
+        // protect against infinite recursion from mutual dependencies
+        if(dj_undef(modulename, this.loading_modules_)){
+                this.addedToLoadingCount.push(modulename);
+        }
+        this.loading_modules_[modulename] = 1;
+
+        // convert periods to slashes
+        var relpath = modulename.replace(/\./g, '/') + '.js';
+
+        var syms = modulename.split(".");
+        var nsyms = modulename.split(".");
+        for (var i = syms.length - 1; i > 0; i--) {
+                var parentModule = syms.slice(0, i).join(".");
+                var parentModulePath = this.getModulePrefix(parentModule);
+                if (parentModulePath != parentModule) {
+                        syms.splice(0, i, parentModulePath);
+                        break;
+                }
+        }
+        var last = syms[syms.length - 1];
+        // figure out if we're looking for a full package, if so, we want to do
+        // things slightly diffrently
+        if(last=="*"){
+                modulename = (nsyms.slice(0, -1)).join('.');
+
+                while(syms.length){
+                        syms.pop();
+                        syms.push(this.pkgFileName);
+                        relpath = syms.join("/") + '.js';
+                        if(relpath.charAt(0)=="/"){
+                                relpath = relpath.slice(1);
+                        }
+                        ok = this.loadPath(relpath, ((!omit_module_check) ? modulename : null));
+                        if(ok){ break; }
+                        syms.pop();
+                }
+        }else{
+                relpath = syms.join("/") + '.js';
+                modulename = nsyms.join('.');
+                var ok = this.loadPath(relpath, ((!omit_module_check) ? modulename : null));
+                if((!ok)&&(!exact_only)){
+                        syms.pop();
+                        while(syms.length){
+                                relpath = syms.join('/') + '.js';
+                                ok = this.loadPath(relpath, ((!omit_module_check) ? modulename : null));
+                                if(ok){ break; }
+                                syms.pop();
+                                relpath = syms.join('/') + '/'+this.pkgFileName+'.js';
+                                if(relpath.charAt(0)=="/"){
+                                        relpath = relpath.slice(1);
+                                }
+                                ok = this.loadPath(relpath, ((!omit_module_check) ? modulename : null));
+                                if(ok){ break; }
+                        }
+                }
+
+                if((!ok)&&(!omit_module_check)){
+                        dojo.raise("Could not load '" + modulename + "'; last tried '" + relpath + "'");
+                }
+        }
+
+        // check that the symbol was defined
+        if(!omit_module_check){
+                // pass in false so we can give better error
+                module = this.findModule(modulename, false);
+                if(!module){
+                        dojo.raise("symbol '" + modulename + "' is not defined after loading '" + relpath + "'"); 
+                }
+        }
+
+        return module;
+}
+
+/**
+* startPackage("A.B") follows the path, and at each level creates a new empty
+* object or uses what already exists. It returns the result.
+*/
+dojo.hostenv.startPackage = function(packname){
+        var syms = packname.split(/\./);
+        if(syms[syms.length-1]=="*"){
+                syms.pop();
+        }
+        return dojo.evalObjPath(syms.join("."), true);
+}
+
+/**
+ * findModule("A.B") returns the object A.B if it exists, otherwise null.
+ * @param modulename A string like 'A.B'.
+ * @param must_exist Optional, defualt false. throw instead of returning null
+ * if the module does not currently exist.
+ */
+dojo.hostenv.findModule = function(modulename, must_exist){
+        // check cache
+        /*
+        if(!dj_undef(modulename, this.modules_)){
+                return this.modules_[modulename];
+        }
+        */
+
+        var lmn = (new String(modulename)).toLowerCase();
+
+        if(this.loaded_modules_[lmn]){
+                return this.loaded_modules_[lmn];
+        }
+
+        // see if symbol is defined anyway
+        var module = dojo.evalObjPath(modulename);
+        if((modulename)&&(typeof module != 'undefined')&&(module)){
+                this.loaded_modules_[lmn] = module;
+                return module;
+        }
+
+        if(must_exist){
+                dojo.raise("no loaded module named '" + modulename + "'");
+        }
+        return null;
+}
+
+//Start of old bootstrap2:
+
+/*
  * This method taks a "map" of arrays which one can use to optionally load dojo
  * modules. The map is indexed by the possible dojo.hostenv.name_ values, with
  * two additional values: "default" and "common". The items in the "default"
@@ -35 +339 @@
         }
 }
 
-dojo.hostenv.require = dojo.hostenv.loadModule;
 dojo.require = function(){
         dojo.hostenv.loadModule.apply(dojo.hostenv, arguments);
 }
-dojo.requireAfter = dojo.require;
 
 dojo.requireIf = function(){
         if((arguments[0] === true)||(arguments[0]=="common")||(arguments[0] && dojo.render[arguments[0]].capable)){
@@ -49 +351 @@
         }
 }
 
+//Would like to remove requireAfterIf, but would too many widgets
+//outside of dojo use it? Since the dojo widgets used to, and outside
+//widgets may have done copy/paste from them to start the widget.
 dojo.requireAfterIf = dojo.requireIf;
-dojo.conditionalRequire = dojo.requireIf;
 
-dojo.requireAll = function() {
-        for(var i = 0; i < arguments.length; i++) { dojo.require(arguments[i]); }
-}
-
-dojo.kwCompoundRequire = function(){
-        dojo.hostenv.conditionalLoadModule.apply(dojo.hostenv, arguments);
-}
-
-dojo.hostenv.provide = dojo.hostenv.startPackage;
 dojo.provide = function(){
         return dojo.hostenv.startPackage.apply(dojo.hostenv, arguments);
 }
@@ -69 +364 @@
         return dojo.hostenv.setModulePrefix(module, prefix);
 }
 
-// stub
-dojo.profile = { start: function(){}, end: function(){}, stop: function(){}, dump: function(){} };
-
 // determine if an object supports a given method
 // useful for longer api chains where you have to test each object in the chain
 dojo.exists = function(obj, name){

src/lang/Lang.js

@@ -1 +1 @@
 dojo.require("dojo.lang");
-dj_deprecated("dojo.lang.Lang is deprecated, use dojo.lang instead");
+dojo.deprecated("dojo.lang.Lang is deprecated, use dojo.lang instead");

src/hostenv_wsh.js

@@ -13 +13 @@
 
 // make sure we are in right environment
 if(typeof WScript == 'undefined'){
-        dj_throw("attempt to use WSH host environment when no WScript global");
+        dojo.raise("attempt to use WSH host environment when no WScript global");
 }
 
 dojo.hostenv.println = WScript.Echo;

src/reflect/__package__.js

@@ -1 @@
-dj_deprecated("dojo.reflect is merged into dojo.lang (dojo.lang[type]).  Will be removed by 0.4");
+dojo.deprecated("dojo.reflect is merged into dojo.lang (dojo.lang[type]).  Will be removed by 0.4");
 dojo.hostenv.conditionalLoadModule({
         common: ["dojo.reflect.reflection"]
 });

src/reflect/reflection.js

@@ -1 @@
-dj_deprecated("dojo.reflect is merged into dojo.lang (dojo.lang[type]).  Will be removed by 0.4");
+dojo.deprecated("dojo.reflect is merged into dojo.lang (dojo.lang[type]).  Will be removed by 0.4");
 dojo.provide("dojo.reflect");
 
 /*****************************************************************

src/graphics/htmlEffects.js

@@ -1 +1 @@
 dojo.provide("dojo.graphics.htmlEffects");
 dojo.require("dojo.fx.*");
 
-dj_deprecated("dojo.graphics.htmlEffects is deprecated, use dojo.fx.html instead");
+dojo.deprecated("dojo.graphics.htmlEffects is deprecated, use dojo.fx.html instead");
 
 dojo.graphics.htmlEffects = dojo.fx.html;

src/hostenv_browser.js

@@ -34 +34 @@
                 }
         }
 
-        if(((djConfig["baseScriptUri"] == "")||(djConfig["baseRelativePath"] == "")) &&(document && document.getElementsByTagName)){
-                var scripts = document.getElementsByTagName("script");
-                var rePkg = /(__package__|dojo|bootstrap1)\.js([\?\.]|$)/i;
-                for(var i = 0; i < scripts.length; i++) {
-                        var src = scripts[i].getAttribute("src");
-                        if(!src) { continue; }
-                        var m = src.match(rePkg);
-                        if(m) {
-                                root = src.substring(0, m.index);
-                                if(src.indexOf("bootstrap1") > -1) { root += "../"; }
-                                if(!this["djConfig"]) { djConfig = {}; }
-                                if(djConfig["baseScriptUri"] == "") { djConfig["baseScriptUri"] = root; }
-                                if(djConfig["baseRelativePath"] == "") { djConfig["baseRelativePath"] = root; }
-                                break;
-                        }
-                }
-        }
-
         // fill in the rendering support information in dojo.render.*
         var dr = dojo.render;
         var drh = dojo.render.html;
@@ -373 +355 @@
 // breaking when it's not included
 dojo.hostenv.writeIncludes = function(){}
 
-dojo.hostenv.byId = dojo.byId = function(id, doc){
+dojo.byId = function(id, doc){
         if(id && (typeof id == "string" || id instanceof String)){
                 if(!doc){ doc = document; }
                 return doc.getElementById(id);
         }
         return id; // assume it's a node
 }
-
-dojo.hostenv.byIdArray = dojo.byIdArray = function(){
-        var ids = [];
-        for(var i = 0; i < arguments.length; i++){
-                if((arguments[i] instanceof Array)||(typeof arguments[i] == "array")){
-                        for(var j = 0; j < arguments[i].length; j++){
-                                ids = ids.concat(dojo.hostenv.byIdArray(arguments[i][j]));
-                        }
-                }else{
-                        ids.push(dojo.hostenv.byId(arguments[i]));
-                }
-        }
-        return ids;
-}

src/bootstrap1.js

@@ -122 +122 @@
         throw Error(message);
 }
 
-dj_throw = dj_rethrow = function(m, e){
-        dojo.deprecated("dj_throw and dj_rethrow deprecated, use dojo.raise instead");
-        dojo.raise(m, e);
-}
+//Stub functions so things don't break.
+dojo.debug = function(){}
+dojo.debugShallow = function(obj){}
+dojo.profile = { start: function(){}, end: function(){}, stop: function(){}, dump: function(){} };
 
 /**
- * Produce a line of debug output. 
- * Does nothing unless djConfig.isDebug is true.
- * varargs, joined with ''.
- * Caller should not supply a trailing "\n".
- */
-dojo.debug = function(){
-        if (!djConfig.isDebug) { return; }
-        var args = arguments;
-        if(dj_undef("println", dojo.hostenv)){
-                dojo.raise("dojo.debug not available (yet?)");
-        }
-        var isJUM = dj_global["jum"] && !dj_global["jum"].isBrowser;
-        var s = [(isJUM ? "": "DEBUG: ")];
-        for(var i=0;i<args.length;++i){
-                if(!false && args[i] instanceof Error){
-                        var msg = "[" + args[i].name + ": " + dojo.errorToString(args[i]) +
-                                (args[i].fileName ? ", file: " + args[i].fileName : "") +
-                                (args[i].lineNumber ? ", line: " + args[i].lineNumber : "") + "]";
-                } else {
-                        try {
-                                var msg = String(args[i]);
-                        } catch(e) {
-                                if(dojo.render.html.ie) {
-                                        var msg = "[ActiveXObject]";
-                                } else {
-                                        var msg = "[unknown]";
-                                }
-                        }
-                }
-                s.push(msg);
-        }
-        if(isJUM){ // this seems to be the only way to get JUM to "play nice"
-                jum.debug(s.join(" "));
-        }else{
-                dojo.hostenv.println(s.join(" "));
-        }
-}
-
-/**
- * this is really hacky for now - just 
- * display the properties of the object
-**/
-
-dojo.debugShallow = function(obj){
-        if (!djConfig.isDebug) { return; }
-        dojo.debug('------------------------------------------------------------');
-        dojo.debug('Object: '+obj);
-        var props = [];
-        for(var prop in obj){
-                try {
-                        props.push(prop + ': ' + obj[prop]);
-                } catch(E) {
-                        props.push(prop + ': ERROR - ' + E.message);
-                }
-        }
-        props.sort();
-        for(var i = 0; i < props.length; i++) {
-                dojo.debug(props[i]);
-        }
-        dojo.debug('------------------------------------------------------------');
-}
-
-var dj_debug = dojo.debug;
-
-/**
  * We put eval() in this separate function to keep down the size of the trapped
  * evaluation context.
  *
@@ -208 +143 @@
  * Convenience for throwing an exception because some function is not
  * implemented.
  */
-dj_unimplemented = dojo.unimplemented = function(funcname, extra){
+dojo.unimplemented = function(funcname, extra){
         // FIXME: need to move this away from dj_*
         var mess = "'" + funcname + "' not implemented";
         if((!dj_undef(extra))&&(extra)){ mess += " " + extra; }
@@ -218 +153 @@
 /**
  * Convenience for informing of deprecated behaviour.
  */
-dj_deprecated = dojo.deprecated = function(behaviour, extra, removal){
+dojo.deprecated = function(behaviour, extra, removal){
         var mess = "DEPRECATED: " + behaviour;
         if(extra){ mess += " " + extra; }
         if(removal){ mess += " -- will be removed in version: " + removal; }
@@ -226 +161 @@
 }
 
 /**
- * Convenience for informing of experimental code.
- */
-dojo.experimental = function(packageName, extra){
-        var mess = "EXPERIMENTAL: " + packageName;
-        mess += " -- Not yet ready for use.  APIs subject to change without notice.";
-        if(extra){ mess += " " + extra; }
-        dojo.debug(mess);
-}
-
-/**
  * Does inheritance
  */
 dojo.inherits = function(subclass, superclass){
@@ -249 +174 @@
         subclass['super'] = superclass.prototype;
 }
 
-dj_inherits = function(subclass, superclass){
-        dojo.deprecated("dj_inherits deprecated, use dojo.inherits instead");
-        dojo.inherits(subclass, superclass);
-}
-
 // an object that authors use determine what host we are running under
 dojo.render = (function(){
 
@@ -321 +241 @@
                 }
         }
 
-        var djc = djConfig;
-        function _def(obj, name, def){
-                return (dj_undef(name, obj) ? def : obj[name]);
-        }
-
         return {