| /* |
| Copyright (c) 2004-2006, The Dojo Foundation |
| All Rights Reserved. |
| |
| Licensed under the Academic Free License version 2.1 or above OR the |
| modified BSD license. For more information on Dojo licensing, see: |
| |
| http://dojotoolkit.org/community/licensing.shtml |
| */ |
| |
| dojo.provide("dojo.ns"); |
| |
| dojo.ns = { |
| // summary: private object that implements widget namespace management |
| namespaces: {}, |
| failed: {}, |
| loading: {}, |
| loaded: {}, |
| register: function(/*String*/name, /*String*/module, /*Function?*/resolver, /*Boolean?*/noOverride){ |
| // summary: creates and registers a dojo.ns.Ns object |
| if(!noOverride || !this.namespaces[name]){ |
| this.namespaces[name] = new dojo.ns.Ns(name, module, resolver); |
| } |
| }, |
| allow: function(/*String*/name){ |
| // summary: Returns false if 'name' is filtered by configuration or has failed to load, true otherwise |
| if(this.failed[name]){return false;} // Boolean |
| if((djConfig.excludeNamespace)&&(dojo.lang.inArray(djConfig.excludeNamespace, name))){return false;} // Boolean |
| // If the namespace is "dojo", or the user has not specified allowed namespaces return true. |
| // Otherwise, if the user has specifically allowed this namespace, return true, otherwise false. |
| return((name==this.dojo)||(!djConfig.includeNamespace)||(dojo.lang.inArray(djConfig.includeNamespace, name))); // Boolean |
| }, |
| get: function(/*String*/name){ |
| // summary |
| // Return Ns object registered to 'name', if any |
| return this.namespaces[name]; // Ns |
| }, |
| require: function(/*String*/name){ |
| // summary |
| // Try to ensure that 'name' is registered, loading a namespace manifest if necessary |
| var ns = this.namespaces[name]; |
| if((ns)&&(this.loaded[name])){return ns;} // Ns |
| if(!this.allow(name)){return false;} // Boolean |
| if(this.loading[name]){ |
| // FIXME: do we really ever have re-entrancy situation? this would appear to be really bad |
| // original code did not throw an exception, although that seems the only course |
| // adding debug output here to track if this occurs. |
| dojo.debug('dojo.namespace.require: re-entrant request to load namespace "' + name + '" must fail.'); |
| return false; // Boolean |
| } |
| // workaround so we don't break the build system |
| var req = dojo.require; |
| this.loading[name] = true; |
| try { |
| //dojo namespace file is always in the Dojo namespaces folder, not any custom folder |
| if(name=="dojo"){ |
| req("dojo.namespaces.dojo"); |
| }else{ |
| // if no registered module prefix, use ../<name> by convention |
| if(!dojo.hostenv.moduleHasPrefix(name)){ |
| dojo.registerModulePath(name, "../" + name); |
| } |
| req([name, 'manifest'].join('.'), false, true); |
| } |
| if(!this.namespaces[name]){ |
| this.failed[name] = true; //only look for a namespace once |
| } |
| }finally{ |
| this.loading[name]=false; |
| } |
| return this.namespaces[name]; // Ns |
| } |
| } |
| |
| dojo.ns.Ns = function(/*String*/name, /*String*/module, /*Function?*/resolver){ |
| // summary: this object simply encapsulates namespace data |
| this.name = name; |
| this.module = module; |
| this.resolver = resolver; |
| this._loaded = [ ]; |
| this._failed = [ ]; |
| } |
| |
| dojo.ns.Ns.prototype.resolve = function(/*String*/name, /*String*/domain, /*Boolean?*/omitModuleCheck){ |
| //summary: map component with 'name' and 'domain' to a module via namespace resolver, if specified |
| if(!this.resolver || djConfig["skipAutoRequire"]){return false;} // Boolean |
| var fullName = this.resolver(name, domain); |
| //only load a widget once. This is a quicker check than dojo.require does |
| if((fullName)&&(!this._loaded[fullName])&&(!this._failed[fullName])){ |
| //workaround so we don't break the build system |
| var req = dojo.require; |
| req(fullName, false, true); //omit the module check, we'll do it ourselves. |
| if(dojo.hostenv.findModule(fullName, false)){ |
| this._loaded[fullName] = true; |
| }else{ |
| if(!omitModuleCheck){dojo.raise("dojo.ns.Ns.resolve: module '" + fullName + "' not found after loading via namespace '" + this.name + "'");} |
| this._failed[fullName] = true; |
| } |
| } |
| return Boolean(this._loaded[fullName]); // Boolean |
| } |
| |
| dojo.registerNamespace = function(/*String*/name, /*String*/module, /*Function?*/resolver){ |
| // summary: maps a module name to a namespace for widgets, and optionally maps widget names to modules for auto-loading |
| // description: An unregistered namespace is mapped to an eponymous module. |
| // For example, namespace acme is mapped to module acme, and widgets are |
| // assumed to belong to acme.widget. If you want to use a different widget |
| // module, use dojo.registerNamespace. |
| dojo.ns.register.apply(dojo.ns, arguments); |
| } |
| |
| dojo.registerNamespaceResolver = function(/*String*/name, /*Function*/resolver){ |
| // summary: a resolver function maps widget names to modules, so the |
| // widget manager can auto-load needed widget implementations |
| // |
| // description: The resolver provides information to allow Dojo |
| // to load widget modules on demand. When a widget is created, |
| // a namespace resolver can tell Dojo what module to require |
| // to ensure that the widget implementation code is loaded. |
| // |
| // name: will always be lower-case. |
| // |
| // example: |
| // dojo.registerNamespaceResolver("acme", |
| // function(name){ |
| // return "acme.widget."+dojo.string.capitalize(name); |
| // } |
| // ); |
| var n = dojo.ns.namespaces[name]; |
| if(n){ |
| n.resolver = resolver; |
| } |
| } |
| |
| dojo.registerNamespaceManifest = function(/*String*/module, /*String*/path, /*String*/name, /*String*/widgetModule, /*Function?*/resolver){ |
| // summary: convenience function to register a module path, a namespace, and optionally a resolver all at once. |
| dojo.registerModulePath(name, path); |
| dojo.registerNamespace(name, widgetModule, resolver); |
| } |
| |
| // NOTE: rather put this in dojo.widget.Widget, but that fubars debugAtAllCosts |
| dojo.registerNamespace("dojo", "dojo.widget"); |