Changeset 7988

Timestamp:

04/07/07 15:51:40 (20 months ago)

Author:

sjmiles

Message:

First draft of new connect/event stuff. Refs #2641

Location:

dojo/trunk

Files:

• tests/_base.js (modified) (1 diff)
• tests/_base/connect.js (added)
• tests/_base/declare.js (modified) (1 diff)
• _base.js (modified) (1 diff)
• _base/connect.js (added)
• _base/declare.js (modified) (5 diffs)
• _base/event.js (added)
• _base/lang.js (modified) (4 diffs)
• _base/_loader/bootstrap.js (modified) (3 diffs)

dojo/trunk/tests/_base.js

@@ -119 +119 @@
         dojo.require("tests._base.lang");
         dojo.require("tests._base.declare");
+        dojo.require("tests._base.connect");
         dojo.require("tests._base.Deferred");
         dojo.require("tests._base.json");

dojo/trunk/tests/_base/declare.js

@@ -161 +161 @@
                                         },
                                         baz: function(arg1, arg2){
-                                                this.inherited("bar", arguments);
+                                                //this.inherited("baz", arguments);
+                                                this.inherited("bar", arguments, tests._base.declare.tmp15.prototype.bar);
                                         }
                                 }

dojo/trunk/_base.js

@@ -1 +1 @@
 dojo.require("dojo._base.lang");
 dojo.require("dojo._base.declare");
+dojo.require("dojo._base.connect");
 dojo.require("dojo._base.Deferred");
 dojo.require("dojo._base.json");
 dojo.require("dojo._base.array");
 // dojo.requireIf(dojo.isBrowser, "dojo._base.browserConnect");
-// dojo.requireIf(dojo, "dojo._base.connect");
+dojo.requireIf(dojo.isBrowser, "dojo._base.event");
 dojo.requireIf(dojo.isBrowser, "dojo._base.html");
 dojo.requireIf(dojo.isBrowser, "dojo._base.NodeList");

dojo/trunk/_base/declare.js

@@ -27 +27 @@
         //              prototype extension. 
         //
-        //              All "superclass(es)" must be Functions (not mere Objects).
+        //              All superclasses (including mixins) must be Functions (not simple Objects).
         //
         //              Mixin ancestors provide a type of multiple inheritance.
-        //              The prototypical properties of mixin ancestors are copied 
-        //              to the subclass. 
+        //      
+        //              Prototypes of mixin ancestors are copied to the new class.
         //
-        //              name of the class ("className" argument) is stored in
-        //              "declaredClass" property
-        // 
-        //              Aliased as "dojo.declare"
+        //              "className" is cached in "declaredClass" property of the new class.
         //
         // usage:
@@ -87 +84 @@
         ctor.mixins = mixins;
         // copy the mixin prototype to the new prototype
-        dojo.forEach(mixins, function(i){
-                dojo.extend(ctor, i.prototype);
-        });
-        /*
-        for(var i=0,l=mixins.length; i<l; i++){
-                dojo.extend(ctor, mixins[i].prototype);
+        for(var i=0,m;(m=mixins[i]);i++){
+                dojo.extend(ctor, m.prototype);
         }
-        */
         //
         // V. Finalize constructor
@@ -111 +103 @@
         //
         // VI. Create named reference
-        // with(dojo.getProp(className, true)){obj[prop] = ctor;}
-        var pcn = className.split("."); var oname = pcn.pop(); pcn = pcn.join(".");
-        var prt = (pcn.length) ? dojo.getObject(pcn, true) : dojo.global();
-        prt[oname] = ctor;
-        return ctor; // Function
+        return dojo.setObject(className, ctor); // Function
 }
 
@@ -125 +113 @@
                 // initialize any mixins
                 if(c.mixins){
-                        // FIXME: why mp?
-                        for(var i=0, m, mp; (m=c.mixins[i])&&(mp=m.prototype); i++){
-                                (mp.initializer||m).apply(this, arguments);
+                        for(var i=0, m, f; (m=c.mixins[i]); i++){
+                                // avoid the constructor on 'declared' mixins
+                                (f=("initializer" in m ? m.initializer : m))&&(f.apply(this, arguments));
                         }
                 }
@@ -140 +128 @@
         _findInherited: function(name, callee){
                 var p = this.constructor.prototype;
-                var lp;
-                if(this[name] !== callee){
-                        while(p && (p[name] !== callee)){ 
-                                lp = p;
-                                p = p.constructor.superclass;
+                if (this[name]!==callee){
+                        while(p && (p[name]!==callee)){ 
+                                p = p.constructor.superclass; 
                         }
-                        p = lp;
                 }
-                while(p && (p[name] === callee)){ 
-                        p = p.constructor.superclass;
+                if ((!p)||(p[name]!==callee)){
+                        throw(this.toString() + ': name argument ("' + name + '") to inherited does not match callee (declare.js)');
                 }
-                return (p)&&(p[name]);          
+                while(p && (p[name]===callee)){ 
+                        p = p.constructor.superclass; 
+                }
+                return (p)&&(p[name]);  
         },
         inherited: function(name, args, callee){

dojo/trunk/_base/lang.js

@@ -5 +5 @@
 dojo.isString = function(/*anything*/ it){
         // summary:     Return true if it is a String.
-
-        return (typeof it == "string" || it instanceof String);
+        return (typeof it == "string" || it instanceof String); // Boolean
 }
 
 dojo.isArray = function(/*anything*/ it){
         // summary: Return true of it is an Array
-
         return (it && it instanceof Array || typeof it == "array" || ((typeof dojo["NodeList"] != "undefined") && (it instanceof dojo.NodeList))); // Boolean
 }
@@ -72 +70 @@
         }
         // IE doesn't recognize custom toStrings in for..in
-        if(     dojo.isIE && 
+        if(dojo.isIE && 
                 (typeof(props["toString"]) == "function") && 
                 (props["toString"] != obj["toString"]) && 
@@ -101 +99 @@
 }
 
-dojo.hitch = function(/*Object*/thisObject, /*Function|String*/method /*, ...*/){
+dojo._hitchArgs = function(scope, method /*,...*/){
+        var pre = [];
+        for(var x=2; x<arguments.length; x++){
+                pre.push(arguments[x]);
+        }
+        var named = dojo.isString(method);
+        return function(){
+                // arrayify arguments
+                var args = [];
+                for(var x=0; x<arguments.length; x++){
+                        args.push(arguments[x]);
+                }
+                // locate our method
+                var f = (named ? (scope||dojo.global())[method] : method);
+                // invoke with collected args
+                return (f)&&(f.apply(scope||this, pre.concat(args))); // Any
+        } // Function
+}
+
+dojo.hitch = function(/*Object*/scope, /*Function|String*/method /*,...*/){
         // summary: 
-        //              Returns a function that will only ever execute in the a given scope
-        //              (thisObject). This allows for easy use of object member functions
+        //              Returns a function that will only ever execute in the a given scope. 
+        //              This allows for easy use of object member functions
         //              in callbacks and other places in which the "this" keyword may
-        //              otherwise not reference the expected scope. Any number of default
-        //              positional arguments may be passed as parameters beyond "method".
+        //              otherwise not reference the expected scope. 
+        //              Any number of default positional arguments may be passed as parameters 
+        //              beyond "method".
         //              Each of these values will be used to "placehold" (similar to curry)
-        //              for the hitched function. Note that the order of arguments may be
-        //              reversed in a future version.
-        // thisObject: the scope to run the method in
+        //              for the hitched function. 
+        // scope: 
+        //              The scope to run the method in
         // method:
-        //              a function to be "bound" to thisObject or the name of the method in
-        //              thisObject to be used as the basis for the binding
+        //              A function to be hitched to scope, or the name of the method in
+        //              scope to be hitched.
         // usage:
         //              dojo.hitch(foo, "bar")(); // runs foo.bar() in the scope of foo
         //              dojo.hitch(foo, myFunction); // returns a function that runs myFunction in the scope of foo
-
-        // FIXME:
-        //              should this be extended to "fixate" arguments in a manner similar
-        //              to dojo.curry, but without the default execution of curry()?
-        var args = [];
-        for(var x=2; x<arguments.length; x++){
-                args.push(arguments[x]);
+        if(arguments.length > 2){
+                return dojo._hitchArgs.apply(dojo, arguments);
+        }else if(dojo.isString(method)){
+                scope = scope || dojo.global();
+                return function(){ return scope[method].apply(scope, arguments||[]); }
+        }else{
+                return (!scope ? method : function(){ return method.apply(scope, arguments||[]); });
         }
-        var fcn = ((dojo.isString(method)) ? (thisObject||dojo.global())[method] : method) || function(){};
-        return function(){
-                var ta = args.concat([]); // make a copy
-                for(var x=0; x<arguments.length; x++){
-                        ta.push(arguments[x]);
-                }
-                return fcn.apply((thisObject||this), ta); // Function
-        };
 }
 
@@ -152 +162 @@
         //              whatever the execution context eventually becomes. This is the
         //              functional equivalent of calling:
-        //                      dojo.hitch(null, funcName, ...);
+        //              dojo.hitch(null, funcName, ...);
         var args = [ null ];
         for(var x=0; x<arguments.length; x++){

dojo/trunk/_base/_loader/bootstrap.js

@@ -99 +99 @@
 }
 
-dojo.getObject = function(/*String*/name, /*Boolean*/create, /*Object*/obj){
-        // summary: 
-        //              gets an object from a dot-separated string, such as "A.B.C"
+dojo._getProp = function(/*Array*/parts, /*Boolean*/create, /*Object*/context){
+        var obj=context||dojo.global();
+        for(var i=0, p; obj&&(p=parts[i]); i++){
+                obj = (p in obj ? obj[p] : (create ? obj[p]={} : undefined));
+        }
+        return obj; // Any
+}
+
+dojo.setObject = function(/*String*/name, /*Any*/value, /*Object*/context){
+        // summary: 
+        //              Set a property from a dot-separated string, such as "A.B.C"
         //      description: 
-        //              useful for longer api chains where you have to test each object in
-        //              the chain
+        //              Useful for longer api chains where you have to test each object in
+        //              the chain, or when you have an object reference in string format.
+        //              Objects are created as needed along 'path'.
         //      name:   
-        //              Path to an object, in the form "A.B.C".
-        //      obj:
+        //              Path to a property, in the form "A.B.C".
+        //      context:
+        //              Optional. Object to use as root of path. Defaults to
+        //              'dojo.global()'. Null may be passed.
+        var parts=name.split("."), p=parts.pop(), obj=dojo._getProp(parts, true, context);
+        return (obj && p ? (obj[p]=value) : undefined); // Any
+}
+
+dojo.getObject = function(/*String*/name, /*Boolean*/create, /*Object*/context){
+        // summary: 
+        //              Get a property from a dot-separated string, such as "A.B.C"
+        //      description: 
+        //              Useful for longer api chains where you have to test each object in
+        //              the chain, or when you have an object reference in string format.
+        //      name:   
+        //              Path to an property, in the form "A.B.C".
+        //      context:
         //              Optional. Object to use as root of path. Defaults to
         //              'dojo.global()'. Null may be passed.
@@ -113 +137 @@
         //              Optional. If true, Objects will be created at any point along the
         //              'path' that is undefined.
-        var tprop, tobj = obj||dojo.global();
-        var parts=name.split("."), i=0, lobj, tmp, tname;
-        do{
-                lobj = tobj;
-                tname = parts[i];
-                tmp = tobj[parts[i]];
-                if((create)&&(!tmp)){
-                        tmp = tobj[parts[i]] = {};
-                }
-                tobj = tmp;
-                i++;
-        }while(i<parts.length && tobj);
-        return tobj; // Object
+        return dojo._getProp(name.split("."), create, context); // Any
 }
 
@@ -139 +151 @@
         //              Optional. Object to use as root of path. Defaults to
         //              'dojo.global()'. Null may be passed.
-        return (!!dojo.getObject(name, false, obj)); // Boolean
+        return Boolean(dojo.getObject(name, false, obj)); // Boolean
 }