From 772ddb983b06058ecfae46700641927183820a36 Mon Sep 17 00:00:00 2001 From: Igor Minar Date: Wed, 7 Mar 2012 16:17:23 -0800 Subject: docs(directive, module): add various missing docs and fix existing docs --- ...ular.module.ng.$compileProvider.directive.ngdoc | 27 +++++++++++----------- 1 file changed, 13 insertions(+), 14 deletions(-) (limited to 'docs/content/api/angular.module.ng.$compileProvider.directive.ngdoc') diff --git a/docs/content/api/angular.module.ng.$compileProvider.directive.ngdoc b/docs/content/api/angular.module.ng.$compileProvider.directive.ngdoc index 356414fb..b7acf680 100644 --- a/docs/content/api/angular.module.ng.$compileProvider.directive.ngdoc +++ b/docs/content/api/angular.module.ng.$compileProvider.directive.ngdoc @@ -241,7 +241,6 @@ The full skeleton of the directive is shown here: transclude: false, restrict: 'A', scope: false, - local: {}, compile: function compile(tElement, tAttrs, transclude) { return { pre: function preLink(scope, iElement, iAttrs, controller) { ... }, @@ -319,35 +318,35 @@ compiler}. The attributes are: * `{}` (object hash) - then a new 'isolate' scope is created. The 'isolate' scope differs from normal scope that it does not prototypically inherit from the parent scope. This is useful when creating reusable components, which should not accidentally read or modify data in - parent scope.
+ parent scope.
The 'isolate' scope takes an object hash which defines a set of local scope properties derived from the parent scope. These local properties are useful for aliasing values for templates. Locals definition is a hash of normalized element attribute name to their corresponding binding strategy. Valid binding strategies are: * `attribute` - one time read of element attribute value and save it to widget scope.
- Given `` and widget definition of `locals: {myAttr:'attribute'}`, + Given `` and widget definition of `scope: {myAttr:'attribute'}`, then widget scope property `myAttr` will be `"abc"`. * `evaluate` - one time evaluation of expression stored in the attribute.
Given - `` and widget definition of `locals: {myAttr:'evaluate'}`, and + `` and widget definition of `scope: {myAttr:'evaluate'}`, and parent scope `{name:'angular'}` then widget scope property `myAttr` will be `"angular"`. * `bind` - Set up one way binding from the element attribute to the widget scope.
- Given `` and widget definition of `locals: {myAttr:'bind'}`, + Given `` and widget definition of `scope: {myAttr:'bind'}`, and parent scope `{name:'angular'}` then widget scope property `myAttr` will be `"angular"`, but any changes in the parent scope will be reflected in the widget scope. * `accessor` - Set up getter/setter function for the expression in the widget element attribute to the widget scope.
Given `` and widget definition - of `locals: {myAttr:'prop'}`, and parent scope `{name:'angular'}` then widget scope + of `scope: {myAttr:'prop'}`, and parent scope `{name:'angular'}` then widget scope property `myAttr` will be a function such that `myAttr()` will return `"angular"` and `myAttr('new value')` will update the parent scope `name` property. This is useful for treating the element as a data-model for reading/writing. - * `expression` - Treat element attribute as an expression to be executed in form of an event. + * `expression` - Treat element attribute as an expression to be executed on the parent scope.
- Given `` and widget definition of `locals: + Given `` and widget definition of `scope: {myAttr:'expression'}`, and parent scope `{doSomething:function() {}}` then calling the widget scope function `myAttr` will execute the expression against the parent scope. @@ -371,7 +370,7 @@ compiler}. The attributes are: * `inject` (object hash) - Specifies a way to inject bindings into a controller. Injection - definition is a hash of normalized element attribute name to their corresponding binding + definition is a hash of normalized element attribute names to their corresponding binding strategy. Valid binding strategies are: * `attribute` - inject attribute value.
@@ -421,10 +420,10 @@ compiler}. The attributes are: transclusion function which is pre-bound to the correct scope. In a typical setup the widget creates an `isolate` scope, but the transclusion is not a child, but a sibling of the `isolate` scope. This makes it possible for the widget to have private state, and the transclusion to - be bound to the pre-`isolate` scope. + be bound to the parent (pre-`isolate`) scope. * `true` - transclude the content of the directive. - * `element` - transclude the whole element including any directives defined at lower priority. + * `'element'` - transclude the whole element including any directives defined at lower priority. * `compile`: This is the compile function described in the section below. @@ -569,11 +568,11 @@ This will not render properly, unless we do some scope magic. The first issue we have to solve is that the dialog box template expect `title` to be defined, but the place of instantiation would like to bind to `username`. Furthermore the buttons expect `onOk` as well as `onCancel` functions to be present in the scope. This limits the usefulness of the -widget. To solve the mapping issue we use the `locals` to create local variables which the -template expects as follows +widget. To solve the mapping issue we use the `locals` to create local variables which the template +expects as follows: 
-  locals: {
+  scope: {
     title: 'bind',   // set up title to accept data-binding
     onOk: 'exp',     // create a delegate onOk function
     onCancel: 'exp', // create a delegate onCancel function
-- 
cgit v1.2.3