FLUID-5212: Draft, highly inefficient implementation of "new demands …

…blocks". Opt-in by adding "fluid.applyGradeLinkage" to gradeNames

src/framework/core/js/Fluid.js

@@ -631,11 +631,11 @@ var fluid = fluid || fluid_1_5;
      * can be found
      */
     fluid.contains = function (obj, value) {
-        return obj ? fluid.find(obj, function (thisValue) {
+        return obj ? (fluid.isArrayable(obj) ? $.inArray(value, obj) !== -1 : fluid.find(obj, function (thisValue) {
             if (value === thisValue) {
                 return true;
             }
-        }) : undefined;
+        })) : undefined;
     };
 
     /**

src/framework/core/js/FluidIoC.js

@@ -396,6 +396,43 @@ var fluid_1_5 = fluid_1_5 || {};
         return shadow && shadow.path !== "" ? null : returnedPath;
     };
 
+    fluid.defaults("fluid.gradeLinkageRecord", {
+        gradeNames: ["autoInit", "fluid.littleComponent"]
+    });
+
+    /** A "tag component" to opt in to the grade linkage system (FLUID-5212) which is currently very expensive - 
+      * this will become the default once we have a better implementation and have stabilised requirements
+      */
+    fluid.defaults("fluid.applyGradeLinkage", { });
+
+    fluid.gradeLinkageIndexer = function (defaults) {
+        if (defaults.contextGrades && defaults.resultGrades) {
+            return ["*"];
+        }
+    };
+
+    fluid.getLinkedGrades = function (gradeNames) {
+        var togo = [];
+        var gradeLinkages = fluid.indexDefaults("gradeLinkages", {
+            gradeNames: "fluid.gradeLinkageRecord",
+            indexFunc: fluid.gradeLinkageIndexer
+        });
+        fluid.each(gradeLinkages["*"], function (defaultsName) {
+            var defaults = fluid.defaults(defaultsName);
+            var exclude = fluid.find(fluid.makeArray(defaults.contextGrades),
+                function (grade) {
+                    if (!fluid.contains(gradeNames, grade)) {
+                        return true;
+                    }
+                }
+            );
+            if (!exclude) {
+                togo.push.apply(togo, fluid.makeArray(defaults.resultGrades));
+            }
+        });
+        return togo;
+    };
+
     fluid.expandDynamicGrades = function (that, dynamicGrades) {
         var resolved = [];
         fluid.each(dynamicGrades, function (dynamicGrade) {
@@ -429,6 +466,15 @@ var fluid_1_5 = fluid_1_5 || {};
         }, []);
         dynamicGrades.push.apply(dynamicGrades, furtherResolved);
         furtherResolved = fluid.expandDynamicGrades(that, furtherResolved);
+        var allGrades = fluid.makeArray(gradeNames).concat(furtherResolved);
+        if (fluid.contains(allGrades, "fluid.applyGradeLinkage")) {
+            var linkedGrades = fluid.getLinkedGrades(allGrades);
+            fluid.remove_if(linkedGrades, function (gradeName) {
+                return fluid.contains(allGrades, gradeName);
+            });
+            furtherResolved = furtherResolved.concat(linkedGrades);
+        }
+
         resolved.push.apply(resolved, furtherResolved);
         return furtherResolved;
     };

src/tests/framework-tests/core/js/FluidIoCTests.js

@@ -3654,5 +3654,48 @@ fluid.registerNamespace("fluid.tests");
         jqUnit.assertValue("Invoker is resolved correctly", component.method);
         component.method();
     });
+
+    /** FLUID-5212 dynamic grade linkage aka "new demands blocks" **/
+
+    fluid.defaults("fluid.tests.gradeLinkageComponent", {
+        gradeNames: ["autoInit", "fluid.littleComponent", "fluid.applyGradeLinkage"]
+    });
+
+    fluid.defaults("fluid.tests.gradeLinkageRecord", {
+        gradeNames: ["autoInit", "fluid.gradeLinkageRecord"],
+        contextGrades: ["fluid.tests.contributedGrade1"],
+        resultGrades: "fluid.tests.contributedGrade2"
+    });
+
+    fluid.defaults("fluid.tests.fluid5212root", {
+        gradeNames: ["autoInit", "fluid.littleComponent"],
+        distributeOptions: {
+            source: "{that}.options.contributedGradeNames",
+            target: "{that subcomponent}.options.gradeNames"
+        },
+        components: {
+            subcomponent: {
+                type: "fluid.tests.gradeLinkageComponent"
+            }
+        },
+        contributedGradeNames: ["fluid.tests.contributedGrade1"]
+    });
+
+    fluid.defaults("fluid.tests.contributedGrade1", {
+        gradeNames: ["autoInit", "fluid.littleComponent"]
+    });
+
+    fluid.defaults("fluid.tests.contributedGrade2", {
+        gradeNames: ["autoInit", "fluid.littleComponent"]
+    });
+
+    jqUnit.test("Test dynamic grade linkage.", function () {
+        jqUnit.expect(2);
+        var component = fluid.tests.fluid5212root();
+        fluid.each(["fluid.tests.contributedGrade1", "fluid.tests.contributedGrade2"], function (gradeName) {
+            jqUnit.assertTrue("Grade is correctly applied",
+                $.inArray(gradeName, component.subcomponent.options.gradeNames) >= 0);
+        });
+    });
 
 })(jQuery);