0.15.0

.eslintrc

@@ -118,6 +118,7 @@ rules:
 
   # http://eslint.org/docs/rules/#nodejs
   callback-return: 2
+  global-require: 2
   handle-callback-err:
     - 2
     - ^(e|err|error)$

.travis.yml

@@ -2,5 +2,5 @@ language: node_js
 node_js:
   - "5.0"
   - "4.2"
-  - "0.10"
+  - "0.12"
 after_script: "cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js"

docs/dumb-inject.md

@@ -0,0 +1,64 @@
+<!-- WARNING: Generated documentation. Edit docs and examples in the rule and examples file ('rules/dumb-inject.js', 'examples/dumb-inject.js'). -->
+
+# dumb-inject - unittest `inject` functions should only consist of assignments from injected values to describe block variables
+
+`inject` functions in unittests should only contain a sorted mapping of injected values to values in the `describe` block with matching names.
+This way the dependency injection setup is separated from the other setup logic, improving readability of the test.
+
+## Examples
+
+The following patterns are considered problems;
+
+    /*eslint angular/dumb-inject: 2*/
+
+    // invalid
+    describe(function() {
+        var $httpBackend;
+        var $rootScope;
+
+        beforeEach(inject(function(_$httpBackend_, _$rootScope_) {
+            $httpBackend = _$httpBackend_;
+            $rootScope = _$rootScope_;
+
+            $httpBackend.whenGET('/data').respond([]);
+        }));
+    }); // error: inject functions may only consist of assignments in the form myService = _myService_
+
+    // invalid
+    describe(function() {
+        var $httpBackend;
+        var $rootScope;
+
+        beforeEach(inject(function(_$httpBackend_, _$rootScope_) {
+            $rootScope = _$rootScope_;
+            $httpBackend = _$httpBackend_;
+        }));
+    }); // error: '$httpBackend' must be sorted before '$rootScope'
+
+The following patterns are **not** considered problems;
+
+    /*eslint angular/dumb-inject: 2*/
+
+    // valid
+    describe(function() {
+        var $httpBackend;
+        var $rootScope;
+
+        beforeEach(inject(function(_$httpBackend_, _$rootScope_) {
+            $httpBackend = _$httpBackend_;
+            $rootScope = _$rootScope_;
+        }));
+
+        beforeEach(function() {
+            $httpBackend.whenGET('/data').respond([]);
+        });
+    });
+
+## Version
+
+This rule was introduced in eslint-plugin-angular 0.15.0
+
+## Links
+
+* [Rule source](../rules/dumb-inject.js)
+* [Example source](../examples/dumb-inject.js)

docs/no-cookiestore.md

@@ -12,10 +12,10 @@ The following patterns are considered problems;
     /*eslint angular/no-cookiestore: 2*/
 
     // invalid
-    $cookieStore.put('favoriteMeal', 'pizza'); // error: Since Angular 1.4, the $cookieStore service is depreacted. Please use now the $cookies service.
+    $cookieStore.put('favoriteMeal', 'pizza'); // error: Since Angular 1.4, the $cookieStore service is deprecated. Please use now the $cookies service.
 
     // invalid
-    $cookieStore.get('favoriteMeal'); // error: Since Angular 1.4, the $cookieStore service is depreacted. Please use now the $cookies service.
+    $cookieStore.get('favoriteMeal'); // error: Since Angular 1.4, the $cookieStore service is deprecated. Please use now the $cookies service.
 
 The following patterns are **not** considered problems;
 

docs/no-digest.md

@@ -2,9 +2,13 @@
 
 # no-digest - use `$apply()` instead of `$digest()`
 
-DEPRECATED! The scope's $digest() method shouldn't be used.
+**This rule is deprecated and will be removed in future versions. Explanation: There is no reason to forbid the use of `$digest()` in general.**
+
+The scope's $digest() method shouldn't be used.
 You should prefer the $apply method.
 
+The `watchers-execution` rule can be configured to enforce the use of `$apply()` or `$digest()`.
+
 ## Version
 
 This rule was introduced in eslint-plugin-angular 0.1.0

docs/no-directive-replace.md

@@ -0,0 +1,74 @@
+<!-- WARNING: Generated documentation. Edit docs and examples in the rule and examples file ('rules/no-directive-replace.js', 'examples/no-directive-replace.js'). -->
+
+# no-directive-replace - disallow the deprecated directive replace property
+
+This rule disallows the replace attribute in a directive definition object.
+The replace property of a directive definition object is deprecated since angular 1.3 ([latest angular docs](https://docs.angularjs.org/api/ng/service/$compile).
+
+The option `ignoreReplaceFalse` let you ignore directive definitions with replace set to false.
+
+## Examples
+
+The following patterns are considered problems with default config;
+
+    /*eslint angular/no-directive-replace: 2*/
+
+    // invalid
+    angular.module('myModule').directive('helloWorld', function() {
+        return {
+            template: '<h2>Hello World!</h2>',
+            replace: true
+        };
+    }); // error: Directive definition property replace is deprecated.
+
+    // invalid
+    angular.module('myModule').directive('helloWorld', function() {
+        var directiveDefinition = {};
+        directiveDefinition.templateUrl = 'helloWorld.html';
+        directiveDefinition.replace = true;
+        return directiveDefinition;
+    }); // error: Directive definition property replace is deprecated.
+
+The following patterns are **not** considered problems with default config;
+
+    /*eslint angular/no-directive-replace: 2*/
+
+    // valid
+    angular.module('myModule').directive('helloWorld', function() {
+        return {
+            template: '<h2>Hello World!</h2>'
+        };
+    });
+
+The following patterns are **not** considered problems when configured `{"ignoreReplaceFalse":true}`:
+
+    /*eslint angular/no-directive-replace: [2,{"ignoreReplaceFalse":true}]*/
+
+    // valid
+    angular.module('myModule').directive('helloWorld', function() {
+        return {
+            template: '<h2>Hello World!</h2>',
+            replace: false
+        };
+    });
+
+The following patterns are considered problems when configured `{"ignoreReplaceFalse":false}`:
+
+    /*eslint angular/no-directive-replace: [2,{"ignoreReplaceFalse":false}]*/
+
+    // invalid
+    angular.module('myModule').directive('helloWorld', function() {
+        return {
+            template: '<h2>Hello World!</h2>',
+            replace: true
+        };
+    }); // error: Directive definition property replace is deprecated.
+
+## Version
+
+This rule was introduced in eslint-plugin-angular 0.15.0
+
+## Links
+
+* [Rule source](../rules/no-directive-replace.js)
+* [Example source](../examples/no-directive-replace.js)

docs/no-run-logic.md

@@ -0,0 +1,60 @@
+<!-- WARNING: Generated documentation. Edit docs and examples in the rule and examples file ('rules/no-run-logic.js', 'examples/no-run-logic.js'). -->
+
+# no-run-logic - keep run functions clean and simple
+
+Initialization logic should be moved into a factory or service. This improves testability.
+
+**Styleguide Reference**
+
+* [y171 by johnpapa - Run Blocks](https://github.com/johnpapa/angular-styleguide#style-y171)
+
+## Examples
+
+The following patterns are considered problems with default config;
+
+    /*eslint angular/no-run-logic: 2*/
+
+    // invalid
+    angular.module('app').run(function($window) {
+        $window.addEventListener('deviceready', deviceready);
+
+        function deviceready() {}
+    }); // error: The run function may only contain call expressions
+
+The following patterns are **not** considered problems with default config;
+
+    /*eslint angular/no-run-logic: 2*/
+
+    // valid
+    angular.module('app').run(function(KITTENS, kittenService, startup) {
+        kittenService.prefetchData(KITTENS);
+        startup('foo', true, 1);
+    });
+
+The following patterns are considered problems when configured `{"allowParams":false}`:
+
+    /*eslint angular/no-run-logic: [2,{"allowParams":false}]*/
+
+    // invalid
+    angular.module('app').run(function(startup) {
+        startup('foo', true, 1);
+    }); // error: Run function call expressions may not take any arguments
+
+The following patterns are **not** considered problems when configured `{"allowParams":false}`:
+
+    /*eslint angular/no-run-logic: [2,{"allowParams":false}]*/
+
+    // valid
+    angular.module('app').run(function(kittenService, startup) {
+        kittenService.prefetchData();
+        startup();
+    });
+
+## Version
+
+This rule was introduced in eslint-plugin-angular 0.15.0
+
+## Links
+
+* [Rule source](../rules/no-run-logic.js)
+* [Example source](../examples/no-run-logic.js)

docs/typecheck-array.md

@@ -13,6 +13,9 @@ The following patterns are considered problems;
     // invalid
     Object.prototype.toString.call(someArray) === '[object Array]'; // error: You should use the angular.isArray method
 
+    // invalid
+    Array.isArray(someArray) // error: You should use the angular.isArray method
+
 The following patterns are **not** considered problems;
 
     /*eslint angular/typecheck-array: 2*/

docs/typecheck-regexp.md

@@ -2,7 +2,9 @@
 
 # typecheck-regexp - use `angular.isRegexp` instead of other comparisons
 
-DEPRECATED! You should use the angular.isRegexp method instead of the default JavaScript implementation (toString.call(/^A/) === "[object RegExp]").
+**This rule is deprecated and will be removed in future versions. Explanation: `angular.isRegexp` is no built-in angular method.**
+
+You should use the angular.isRegexp method instead of the default JavaScript implementation (toString.call(/^A/) === "[object RegExp]").
 
 ## Version
 

examples/dumb-inject.js

@@ -0,0 +1,38 @@
+// example - valid: true
+describe(function() {
+    var $httpBackend;
+    var $rootScope;
+
+    beforeEach(inject(function(_$httpBackend_, _$rootScope_) {
+        $httpBackend = _$httpBackend_;
+        $rootScope = _$rootScope_;
+    }));
+
+    beforeEach(function() {
+        $httpBackend.whenGET('/data').respond([]);
+    });
+});
+
+// example - valid: false, errorMessage: "inject functions may only consist of assignments in the form myService = _myService_"
+describe(function() {
+    var $httpBackend;
+    var $rootScope;
+
+    beforeEach(inject(function(_$httpBackend_, _$rootScope_) {
+        $httpBackend = _$httpBackend_;
+        $rootScope = _$rootScope_;
+
+        $httpBackend.whenGET('/data').respond([]);
+    }));
+});
+
+// example - valid: false, errorMessage: "'$httpBackend' must be sorted before '$rootScope'"
+describe(function() {
+    var $httpBackend;
+    var $rootScope;
+
+    beforeEach(inject(function(_$httpBackend_, _$rootScope_) {
+        $rootScope = _$rootScope_;
+        $httpBackend = _$httpBackend_;
+    }));
+});

examples/no-cookiestore.js

@@ -4,8 +4,8 @@ $cookies.put('favoriteMeal', 'pizza');
 // example - valid: true
 $cookies.get('favoriteMeal');
 
-// example - valid: false, errorMessage: "Since Angular 1.4, the $cookieStore service is depreacted. Please use now the $cookies service."
+// example - valid: false, errorMessage: "Since Angular 1.4, the $cookieStore service is deprecated. Please use now the $cookies service."
 $cookieStore.put('favoriteMeal', 'pizza');
 
-// example - valid: false, errorMessage: "Since Angular 1.4, the $cookieStore service is depreacted. Please use now the $cookies service."
+// example - valid: false, errorMessage: "Since Angular 1.4, the $cookieStore service is deprecated. Please use now the $cookies service."
 $cookieStore.get('favoriteMeal');

examples/no-directive-replace.js

@@ -0,0 +1,40 @@
+// example - valid: true
+angular.module('myModule').directive('helloWorld', function() {
+    return {
+        template: '<h2>Hello World!</h2>'
+    };
+});
+
+// example - valid: true,  options: [{"ignoreReplaceFalse": true}]
+angular.module('myModule').directive('helloWorld', function() {
+    return {
+        template: '<h2>Hello World!</h2>',
+        replace: false
+    };
+});
+
+// example - valid: false, errorMessage: "Directive definition property replace is deprecated."
+angular.module('myModule').directive('helloWorld', function() {
+    return {
+        template: '<h2>Hello World!</h2>',
+        replace: true
+    };
+});
+
+// example - valid: false, errorMessage: "Directive definition property replace is deprecated."
+angular.module('myModule').directive('helloWorld', function() {
+    var directiveDefinition = {};
+    directiveDefinition.templateUrl = 'helloWorld.html';
+    directiveDefinition.replace = true;
+    return directiveDefinition;
+});
+
+// example - valid: false,  options: [{"ignoreReplaceFalse": false}], errorMessage: "Directive definition property replace is deprecated."
+angular.module('myModule').directive('helloWorld', function() {
+    return {
+        template: '<h2>Hello World!</h2>',
+        replace: true
+    };
+});
+
+

examples/no-run-logic.js

@@ -0,0 +1,23 @@
+// example - valid: true
+angular.module('app').run(function(KITTENS, kittenService, startup) {
+    kittenService.prefetchData(KITTENS);
+    startup('foo', true, 1);
+});
+
+// example - valid: true, options: [{allowParams: false}]
+angular.module('app').run(function(kittenService, startup) {
+    kittenService.prefetchData();
+    startup();
+});
+
+// example - valid: false, errorMessage: "The run function may only contain call expressions"
+angular.module('app').run(function($window) {
+    $window.addEventListener('deviceready', deviceready);
+
+    function deviceready() {}
+});
+
+// example - valid: false, options: [{allowParams: false}], errorMessage: "Run function call expressions may not take any arguments"
+angular.module('app').run(function(startup) {
+    startup('foo', true, 1);
+});

examples/typecheck-array.js

@@ -3,3 +3,6 @@ angular.isArray(someArray);
 
 // example - valid: false, errorMessage: "You should use the angular.isArray method"
 Object.prototype.toString.call(someArray) === '[object Array]';
+
+// example - valid: false, errorMessage: "You should use the angular.isArray method"
+Array.isArray(someArray)