angularjs-rails 1.2.0.rc1 → 1.2.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed6236e90a9d0a7901ae13e8d166f7961ea3886b
-  data.tar.gz: 9450ef622e231fd2c738891e274247d5a50bc609
+  metadata.gz: 60c24156d821e8f99fe877451cabfdb3da9a3840
+  data.tar.gz: da2c799f76324b0b429dc3b3f9122a3223ef9ec5
 SHA512:
-  metadata.gz: 05f7c565521b38ed210f8a4e972e21e331d8ecede171cae3e48fa5fa08b75362d64808bc4c45ebe6077a604f137228849eb56c5d8736c87344f292eeab297e8f
-  data.tar.gz: c83a6a5e51c031fd91ea82658357a85966ac1eafe9097203195473487f92b89ca81216a42ab41711bc049b539277defc79f8121103bdb08dab8450b8194a1b7f
+  metadata.gz: cd335cd66257312b2975b59ff0e5d3f3e3cf4f58dd32ed144878d8f996634613431b7b1a6799195415368d1c69fe7df9b4440f422284868d114817e697a5aefd
+  data.tar.gz: 65630c189cbf97e07f998e8db828927cb40338dc667de06ad27900fc4b79a8886f264e6dc53d7dc330aa688469f6bfcc0315a06f98e028d998755b848df07434

data/README.md

@@ -1,4 +1,4 @@
-# angularjs-rails
+# angularjs-rails <a href="http://badge.fury.io/rb/angularjs-rails"><img src="https://badge.fury.io/rb/angularjs-rails@2x.png" alt="Gem Version" height="18"></a>
 
 angularjs-rails wraps the [Angular.js](http://angularjs.org) library for use in Rails 3.1 and above. Assets will minify automatically during production.
 
@@ -30,4 +30,4 @@ And similarly, for optional Angular assets:
 
 Every attempt is made to mirror the currently shipping Angular.js version number wherever possible.
 
-The major, minor, and patch version numbers will always represent the Angular.js version.
+The major, minor, and patch version numbers will always represent the Angular.js version.

data/lib/angularjs-rails/version.rb

@@ -1,5 +1,5 @@
 module AngularJS
   module Rails
-    VERSION = "1.2.0.rc1"
+    VERSION = "1.2.0.rc2"
   end
 end

data/vendor/assets/javascripts/angular-animate.js

@@ -1,5 +1,5 @@
 /**
- * @license AngularJS v1.2.0rc1
+ * @license AngularJS v1.2.0-rc.2
  * (c) 2010-2012 Google, Inc. http://angularjs.org
  * License: MIT
  */
@@ -10,20 +10,15 @@
  * @name ngAnimate
  * @description
  *
- * ngAnimate
- * =========
+ * # ngAnimate
  *
- * The ngAnimate module is an optional module that comes packed with AngularJS that can be included within an AngularJS
- * application to provide support for CSS and JavaScript animation hooks.
+ * `ngAnimate` is an optional module that provides CSS and JavaScript animation hooks.
  *
- * To make use of animations with AngularJS, the `angular-animate.js` JavaScript file must be included into your application
- * and the `ngAnimate` module must be included as a dependency.
+ * {@installModule animate}
  *
- * <pre>
- * angular.module('App', ['ngAnimate']);
- * </pre>
+ * # Usage
  *
- * Then, to see animations in action, all that is required is to define the appropriate CSS classes
+ * To see animations in action, all that is required is to define the appropriate CSS classes
  * or to register a JavaScript animation via the $animation service. The directives that support animation automatically are:
  * `ngRepeat`, `ngInclude`, `ngSwitch`, `ngShow`, `ngHide` and `ngView`. Custom directives can take advantage of animation
  * by using the `$animate` service.
@@ -53,7 +48,7 @@
  *   -o-transition:0.5s linear all;
  *   transition:0.5s linear all;
  * }
- * 
+ *
  * .slide.ng-enter { }        /&#42; starting animations for enter &#42;/
  * .slide.ng-enter-active { } /&#42; terminal animations for enter &#42;/
  * .slide.ng-leave { }        /&#42; starting animations for leave &#42;/
@@ -197,11 +192,13 @@ angular.module('ngAnimate', ['ng'])
    * @name ngAnimate.$animateProvider
    * @description
    *
-   * The $AnimationProvider provider allows developers to register and access custom JavaScript animations directly inside
+   * The `$AnimationProvider` allows developers to register and access custom JavaScript animations directly inside
    * of a module. When an animation is triggered, the $animate service will query the $animation function to find any
    * animations that match the provided name value.
    *
-   * Please visit the {@link ngAnimate ngAnimate} module overview page learn more about how to use animations in your application.
+   * Requires the {@link ngAnimate `ngAnimate`} module to be installed.
+   *
+   * Please visit the {@link ngAnimate `ngAnimate`} module overview page learn more about how to use animations in your application.
    *
    */
   .config(['$provide', '$animateProvider', function($provide, $animateProvider) {
@@ -211,8 +208,8 @@ angular.module('ngAnimate', ['ng'])
 
     var NG_ANIMATE_STATE = '$$ngAnimateState';
     var rootAnimateState = {running:true};
-    $provide.decorator('$animate', ['$delegate', '$injector', '$sniffer', '$rootElement', '$timeout',
-                            function($delegate,   $injector,   $sniffer,   $rootElement,   $timeout) {
+    $provide.decorator('$animate', ['$delegate', '$injector', '$sniffer', '$rootElement', '$timeout', '$rootScope',
+                            function($delegate,   $injector,   $sniffer,   $rootElement,   $timeout,   $rootScope) {
         
       $rootElement.data(NG_ANIMATE_STATE, rootAnimateState);
 
@@ -255,7 +252,9 @@ angular.module('ngAnimate', ['ng'])
        * The `$animate` service is used behind the scenes with pre-existing directives and animation with these directives
        * will work out of the box without any extra configuration.
        *
-       * Please visit the {@link ngAnimate ngAnimate} module overview page learn more about how to use animations in your application.
+       * Requires the {@link ngAnimate `ngAnimate`} module to be installed.
+       *
+       * Please visit the {@link ngAnimate `ngAnimate`} module overview page learn more about how to use animations in your application.
        *
        */
       return {
@@ -275,8 +274,8 @@ angular.module('ngAnimate', ['ng'])
          * |----------------------------------------------------------------------------------------------|-----------------------------------------------|
          * | 1. $animate.enter(...) is called                                                             | class="my-animation"                          |
          * | 2. element is inserted into the parent element or beside the after element                   | class="my-animation"                          |
-         * | 3. the .ng-enter class is added to the element                                               | class="my-animation ng-enter"                 |
-         * | 4. $animate runs any JavaScript-defined animations on the element                            | class="my-animation ng-enter"                 |
+         * | 3. $animate runs any JavaScript-defined animations on the element                            | class="my-animation"                          |
+         * | 4. the .ng-enter class is added to the element                                               | class="my-animation ng-enter"                 |
          * | 5. $animate scans the element styles to get the CSS transition/animation duration and delay  | class="my-animation ng-enter"                 |
          * | 6. the .ng-enter-active class is added (this triggers the CSS transition/animation)          | class="my-animation ng-enter ng-enter-active" |
          * | 7. $animate waits for X milliseconds for the animation to complete                           | class="my-animation ng-enter ng-enter-active" |
@@ -290,7 +289,11 @@ angular.module('ngAnimate', ['ng'])
         */
         enter : function(element, parent, after, done) {
           $delegate.enter(element, parent, after);
-          performAnimation('enter', 'ng-enter', element, parent, after, done);
+          $rootScope.$$postDigest(function() {
+            performAnimation('enter', 'ng-enter', element, parent, after, function() {
+              done && $timeout(done, 0, false);
+            });
+          });
         },
 
         /**
@@ -308,8 +311,8 @@ angular.module('ngAnimate', ['ng'])
          * | Animation Step                                                                               | What the element class attribute looks like  |
          * |----------------------------------------------------------------------------------------------|----------------------------------------------|
          * | 1. $animate.leave(...) is called                                                             | class="my-animation"                         |
-         * | 2. the .ng-leave class is added to the element                                               | class="my-animation ng-leave"                |
-         * | 3. $animate runs any JavaScript-defined animations on the element                            | class="my-animation ng-leave"                |
+         * | 2. $animate runs any JavaScript-defined animations on the element                            | class="my-animation"                         |
+         * | 3. the .ng-leave class is added to the element                                               | class="my-animation ng-leave"                |
          * | 4. $animate scans the element styles to get the CSS transition/animation duration and delay  | class="my-animation ng-leave"                |
          * | 5. the .ng-leave-active class is added (this triggers the CSS transition/animation)          | class="my-animation ng-leave ng-leave-active |
          * | 6. $animate waits for X milliseconds for the animation to complete                           | class="my-animation ng-leave ng-leave-active |
@@ -321,8 +324,10 @@ angular.module('ngAnimate', ['ng'])
          * @param {function()=} done callback function that will be called once the animation is complete
         */
         leave : function(element, done) {
-          performAnimation('leave', 'ng-leave', element, null, null, function() {
-            $delegate.leave(element, done);
+          $rootScope.$$postDigest(function() {
+            performAnimation('leave', 'ng-leave', element, null, null, function() {
+              $delegate.leave(element, done);
+            });
           });
         },
 
@@ -343,8 +348,8 @@ angular.module('ngAnimate', ['ng'])
          * |----------------------------------------------------------------------------------------------|---------------------------------------------|
          * | 1. $animate.move(...) is called                                                              | class="my-animation"                        |
          * | 2. element is moved into the parent element or beside the after element                      | class="my-animation"                        |
-         * | 3. the .ng-move class is added to the element                                                | class="my-animation ng-move"                |
-         * | 4. $animate runs any JavaScript-defined animations on the element                            | class="my-animation ng-move"                |
+         * | 3. $animate runs any JavaScript-defined animations on the element                            | class="my-animation"                        |
+         * | 4. the .ng-move class is added to the element                                                | class="my-animation ng-move"                |
          * | 5. $animate scans the element styles to get the CSS transition/animation duration and delay  | class="my-animation ng-move"                |
          * | 6. the .ng-move-active class is added (this triggers the CSS transition/animation)           | class="my-animation ng-move ng-move-active" |
          * | 7. $animate waits for X milliseconds for the animation to complete                           | class="my-animation ng-move ng-move-active" |
@@ -358,7 +363,11 @@ angular.module('ngAnimate', ['ng'])
         */
         move : function(element, parent, after, done) {
           $delegate.move(element, parent, after);
-          performAnimation('move', 'ng-move', element, null, null, done);
+          $rootScope.$$postDigest(function() {
+            performAnimation('move', 'ng-move', element, null, null, function() {
+              done && $timeout(done, 0, false);
+            });
+          });
         },
 
         /**
@@ -369,15 +378,16 @@ angular.module('ngAnimate', ['ng'])
          * @description
          * Triggers a custom animation event based off the className variable and then attaches the className value to the element as a CSS class.
          * Unlike the other animation methods, the animate service will suffix the className value with {@type -add} in order to provide
-         * the animate service the setup and active CSS classes in order to trigger the animation.
+         * the animate service the setup and active CSS classes in order to trigger the animation (this will be skipped if no CSS transitions
+         * or keyframes are defined on the -add CSS class).
          *
          * Below is a breakdown of each step that occurs during addClass animation:
          *
          * | Animation Step                                                                                 | What the element class attribute looks like |
          * |------------------------------------------------------------------------------------------------|---------------------------------------------|
          * | 1. $animate.addClass(element, 'super') is called                                               | class=""                                    |
-         * | 2. the .super-add class is added to the element                                                | class="super-add"                           |
-         * | 3. $animate runs any JavaScript-defined animations on the element                              | class="super-add"                           |
+         * | 2. $animate runs any JavaScript-defined animations on the element                              | class=""                                    |
+         * | 3. the .super-add class is added to the element                                                | class="super-add"                           |
          * | 4. $animate scans the element styles to get the CSS transition/animation duration and delay    | class="super-add"                           |
          * | 5. the .super-add-active class is added (this triggers the CSS transition/animation)           | class="super-add super-add-active"          |
          * | 6. $animate waits for X milliseconds for the animation to complete                             | class="super-add super-add-active"          |
@@ -403,15 +413,16 @@ angular.module('ngAnimate', ['ng'])
          * @description
          * Triggers a custom animation event based off the className variable and then removes the CSS class provided by the className value
          * from the element. Unlike the other animation methods, the animate service will suffix the className value with {@type -remove} in
-         * order to provide the animate service the setup and active CSS classes in order to trigger the animation.
+         * order to provide the animate service the setup and active CSS classes in order to trigger the animation (this will be skipped if
+         * no CSS transitions or keyframes are defined on the -remove CSS class).
          *
          * Below is a breakdown of each step that occurs during removeClass animation:
          *
          * | Animation Step                                                                                | What the element class attribute looks like     |
          * |-----------------------------------------------------------------------------------------------|-------------------------------------------------|
          * | 1. $animate.removeClass(element, 'super') is called                                           | class="super"                                   |
-         * | 2. the .super-remove class is added to the element                                            | class="super super-remove"                      |
-         * | 3. $animate runs any JavaScript-defined animations on the element                             | class="super super-remove"                      |
+         * | 2. $animate runs any JavaScript-defined animations on the element                             | class="super"                                   |
+         * | 3. the .super-remove class is added to the element                                            | class="super super-remove"                      |
          * | 4. $animate scans the element styles to get the CSS transition/animation duration and delay   | class="super super-remove"                      |
          * | 5. the .super-remove-active class is added (this triggers the CSS transition/animation)       | class="super super-remove super-remove-active"  |
          * | 6. $animate waits for X milliseconds for the animation to complete                            | class="super super-remove super-remove-active"  |
@@ -496,15 +507,6 @@ angular.module('ngAnimate', ['ng'])
           done:done
         });
 
-        var baseClassName = className;
-        if(event == 'addClass') {
-          className = suffixClasses(className, '-add');
-        } else if(event == 'removeClass') {
-          className = suffixClasses(className, '-remove');
-        }
-
-        element.addClass(className);
-
         forEach(animations, function(animation, index) {
           var fn = function() {
             progress(index);
@@ -512,7 +514,7 @@ angular.module('ngAnimate', ['ng'])
 
           if(animation.start) {
             if(event == 'addClass' || event == 'removeClass') {
-              animation.endFn = animation.start(element, baseClassName, fn);
+              animation.endFn = animation.start(element, className, fn);
             } else {
               animation.endFn = animation.start(element, fn);
             }
@@ -540,7 +542,6 @@ angular.module('ngAnimate', ['ng'])
         function done() {
           if(!done.hasBeenRun) {
             done.hasBeenRun = true;
-            element.removeClass(className);
             element.removeData(NG_ANIMATE_STATE);
             (onComplete || noop)();
           }
@@ -551,94 +552,125 @@ angular.module('ngAnimate', ['ng'])
     $animateProvider.register('', ['$window','$sniffer', '$timeout', function($window, $sniffer, $timeout) {
       var noop = angular.noop;
       var forEach = angular.forEach;
+
+      //one day all browsers will have these properties
+      var w3cAnimationProp = 'animation';
+      var w3cTransitionProp = 'transition';
+
+      //but some still use vendor-prefixed styles
+      var vendorAnimationProp = $sniffer.vendorPrefix + 'Animation';
+      var vendorTransitionProp = $sniffer.vendorPrefix + 'Transition';
+
+      var durationKey = 'Duration',
+          delayKey = 'Delay',
+          propertyKey = 'Property',
+          animationIterationCountKey = 'IterationCount',
+          ELEMENT_NODE = 1;
+
       function animate(element, className, done) {
         if (!($sniffer.transitions || $sniffer.animations)) {
           done();
-        } else {
-          var activeClassName = '';
-          $timeout(startAnimation, 1, false);
-
-          //this acts as the cancellation function in case
-          //a new animation is triggered while another animation
-          //is still going on (otherwise the active className
-          //would still hang around until the timer is complete).
-          return onEnd;
+          return;
         }
-
-        function parseMaxTime(str) {
-          var total = 0, values = angular.isString(str) ? str.split(/\s*,\s*/) : [];
-          forEach(values, function(value) {
-            total = Math.max(parseFloat(value) || 0, total);
+        else if(['ng-enter','ng-leave','ng-move'].indexOf(className) == -1) {
+          var existingDuration = 0;
+          forEach(element, function(element) {
+            if (element.nodeType == ELEMENT_NODE) {
+              var elementStyles = $window.getComputedStyle(element) || {};
+              existingDuration = Math.max(parseMaxTime(elementStyles[w3cTransitionProp + durationKey]),
+                                          parseMaxTime(elementStyles[vendorTransitionProp + durationKey]),
+                                          existingDuration);
+            }
           });
-          return total;
+          if(existingDuration > 0) {
+            done();
+            return;
+          }
         }
 
-        function startAnimation() {
-          var duration = 0;
-          forEach(className.split(' '), function(klass, i) {
-            activeClassName += (i > 0 ? ' ' : '') + klass + '-active';
-          });
-
-          element.addClass(activeClassName);
+        element.addClass(className);
 
-          //one day all browsers will have these properties
-          var w3cAnimationProp = 'animation';
-          var w3cTransitionProp = 'transition';
+        //we want all the styles defined before and after
+        var duration = 0;
+        forEach(element, function(element) {
+          if (element.nodeType == ELEMENT_NODE) {
+            var elementStyles = $window.getComputedStyle(element) || {};
 
-          //but some still use vendor-prefixed styles
-          var vendorAnimationProp = $sniffer.vendorPrefix + 'Animation';
-          var vendorTransitionProp = $sniffer.vendorPrefix + 'Transition';
+            var transitionDelay     = Math.max(parseMaxTime(elementStyles[w3cTransitionProp     + delayKey]),
+                                               parseMaxTime(elementStyles[vendorTransitionProp  + delayKey]));
 
-          var durationKey = 'Duration',
-              delayKey = 'Delay',
-              animationIterationCountKey = 'IterationCount';
+            var animationDelay      = Math.max(parseMaxTime(elementStyles[w3cAnimationProp      + delayKey]),
+                                               parseMaxTime(elementStyles[vendorAnimationProp   + delayKey]));
 
-          //we want all the styles defined before and after
-          var ELEMENT_NODE = 1;
-          forEach(element, function(element) {
-            if (element.nodeType == ELEMENT_NODE) {
-              var elementStyles = $window.getComputedStyle(element) || {};
+            var transitionDuration  = Math.max(parseMaxTime(elementStyles[w3cTransitionProp     + durationKey]),
+                                               parseMaxTime(elementStyles[vendorTransitionProp  + durationKey]));
 
-              var transitionDelay     = Math.max(parseMaxTime(elementStyles[w3cTransitionProp     + delayKey]),
-                                                 parseMaxTime(elementStyles[vendorTransitionProp  + delayKey]));
+            var animationDuration   = Math.max(parseMaxTime(elementStyles[w3cAnimationProp      + durationKey]),
+                                               parseMaxTime(elementStyles[vendorAnimationProp   + durationKey]));
 
-              var animationDelay      = Math.max(parseMaxTime(elementStyles[w3cAnimationProp      + delayKey]),
-                                                 parseMaxTime(elementStyles[vendorAnimationProp   + delayKey]));
+            if(animationDuration > 0) {
+              animationDuration *= Math.max(parseInt(elementStyles[w3cAnimationProp   + animationIterationCountKey]) || 0,
+                                           parseInt(elementStyles[vendorAnimationProp + animationIterationCountKey]) || 0,
+                                           1);
+            }
 
-              var transitionDuration  = Math.max(parseMaxTime(elementStyles[w3cTransitionProp     + durationKey]),
-                                                 parseMaxTime(elementStyles[vendorTransitionProp  + durationKey]));
+            duration = Math.max(animationDelay  + animationDuration,
+                                transitionDelay + transitionDuration,
+                                duration);
+          }
+        });
 
-              var animationDuration   = Math.max(parseMaxTime(elementStyles[w3cAnimationProp      + durationKey]),
-                                                 parseMaxTime(elementStyles[vendorAnimationProp   + durationKey]));
+        /* there is no point in performing a reflow if the animation
+           timeout is empty (this would cause a flicker bug normally
+           in the page */
+        if(duration > 0) {
+          var node = element[0];
 
-              if(animationDuration > 0) {
-                animationDuration *= Math.max(parseInt(elementStyles[w3cAnimationProp   + animationIterationCountKey]) || 0,
-                                             parseInt(elementStyles[vendorAnimationProp + animationIterationCountKey]) || 0,
-                                             1);
-              }
+          //temporarily disable the transition so that the enter styles
+          //don't animate twice (this is here to avoid a bug in Chrome/FF).
+          node.style[w3cTransitionProp + propertyKey] = 'none';
+          node.style[vendorTransitionProp + propertyKey] = 'none';
 
-              duration = Math.max(animationDelay  + animationDuration,
-                                  transitionDelay + transitionDuration,
-                                  duration);
-            }
+          var activeClassName = '';
+          forEach(className.split(' '), function(klass, i) {
+            activeClassName += (i > 0 ? ' ' : '') + klass + '-active';
           });
 
+          //this triggers a reflow which allows for the transition animation to kick in
+          element.prop('clientWidth');
+          node.style[w3cTransitionProp + propertyKey] = '';
+          node.style[vendorTransitionProp + propertyKey] = '';
+          element.addClass(activeClassName);
+
           $timeout(done, duration * 1000, false);
-        }
 
-        //this will automatically be called by $animate so
-        //there is no need to attach this internally to the
-        //timeout done method
-        function onEnd(cancelled) {
-          element.removeClass(activeClassName);
+          //this will automatically be called by $animate so
+          //there is no need to attach this internally to the
+          //timeout done method
+          return function onEnd(cancelled) {
+            element.removeClass(className);
+            element.removeClass(activeClassName);
 
-          //only when the animation is cancelled is the done()
-          //function not called for this animation therefore
-          //this must be also called
-          if(cancelled) {
-            done();
+            //only when the animation is cancelled is the done()
+            //function not called for this animation therefore
+            //this must be also called
+            if(cancelled) {
+              done();
+            }
           }
         }
+        else {
+          element.removeClass(className);
+          done();
+        }
+
+        function parseMaxTime(str) {
+          var total = 0, values = angular.isString(str) ? str.split(/\s*,\s*/) : [];
+          forEach(values, function(value) {
+            total = Math.max(parseFloat(value) || 0, total);
+          });
+          return total;
+        }
       }
 
       return {
@@ -659,18 +691,17 @@ angular.module('ngAnimate', ['ng'])
         }
       };
 
+      function suffixClasses(classes, suffix) {
+        var className = '';
+        classes = angular.isArray(classes) ? classes : classes.split(/\s+/);
+        forEach(classes, function(klass, i) {
+          if(klass && klass.length > 0) {
+            className += (i > 0 ? ' ' : '') + klass + suffix;
+          }
+        });
+        return className;
+      }
     }]);
-
-    function suffixClasses(classes, suffix) {
-      var className = '';
-      classes = angular.isArray(classes) ? classes : classes.split(/\s+/);
-      forEach(classes, function(klass, i) {
-        if(klass && klass.length > 0) {
-          className += (i > 0 ? ' ' : '') + klass + suffix;
-        }
-      });
-      return className;
-    }
   }]);