Adding docs and cleanup

Author: chadhietala

index.js renamed to ember-cli-index.js

@@ -0,0 +1,7 @@
+# No Attrs
+
+**TL;DR** Use `_` to prefix things that are local and leave passed items as the bare name.
+
+In the runup to Ember 2.0, several blog articles were written about using `this.attrs` but they have never been documented as a public API. Typically people use attrs to denote things as "passed" and bare names as local. This is useful and some iteration of Ember will have this built into the programming model, but for now we should not use `attrs`.
+
+In JavaScript we typically prefix "private" things in JavaScript with `_`. If you want to create this notion in a component, we can leverage this long standing convention. Things that are local are technically private as component's scope is isolated so marking them with `_` semantically makes sense. Passed items can use the bare name, as they are effectively public/protected methods and properties.

guides/mixins.md renamed to guides/rules/mixins.md

@@ -0,0 +1,56 @@
+# No Observers
+
+**TL;DR: Use a computed property or lifecycle hooks**
+
+Observers suffer from several issues when building applications at scale. These issues are:
+
+- Eagerly computed
+- Have no notion of a caller
+- Data consistency
+
+To unroll what this means consider the example below.
+
+```
+Compontent.extend({
+  firstName: 'Chad',
+  lastName: 'Hietala',
+  fullName: undefined,
+  fullDidChange: observer('firstName', 'lastName', function() {
+    this.set('fullName',`${this.get('firstName')} ${this.get('lastName')}`);
+  })
+});
+```
+
+In the above example we have an observer that is watching the `firstName` and `lastName` properties in our component. When either of them change the observer will fire, setting `fullName` to the new value. Vast majority of the time this leads to `fullName` being computed more often than it needs to be. There is also an unexpected eventual consistency problem here. Consider we do the following.
+
+```
+this.set('firstName', 'Stefan');
+<---------------------------------------- For a period here `fullName` is Stefan Hietala
+this.set('lastName', 'Penner');
+<---------------------------------------- Now `fullName` is Stefan Penner
+```
+
+Sense observers eagerly compute we have this period in time where we have computed a `fullName` that is not what actually care about.  When we introduce many observers into an application this problem compounds on it's self.
+
+In contrast a computed property is lazily computed and memoized. This means that `firstName` and `lastName` can freely mutate and only when we do `this.get('fullName');` will the function body of the computed property will run. This gives us a clear caller in terms of why the body of why `fullName` was recomputed.
+
+```
+Compontent.extend({
+  firstName: 'Chad',
+  lastName: 'Hietala',
+  fullName: computed('firstName', 'lastName', function() {
+    return `${this.get('firstName')} ${this.get('lastName')}`;
+  })
+});
+```
+
+Since computed properties are lazy we don't have the same data consistency problems with observers.
+
+```
+this.get('fullName'); <------------------ Computed property is computed to `Chad Hietala`
+this.set('firstName', 'Stefan'); <------- Computed property does not recompute
+this.set('lastName', 'Penner'); <-------- Computed property does not recompute
+this.get('fullName'); <------------------ Computed property is computed to `Stefan Penner`
+```
+
+For more info please watch this video: [Observer Tip Jar](https://www.youtube.com/watch?v=vvZEddrClAQ)

guides/rules/no-action-cp.md

@@ -1,172 +1,18 @@
-const FrameworkObjects = ['Component', 'Route', 'Service', 'Helper'];
-const FrameworkHooks = ['init', 'didReceiveAttrs'];
-
-export default function(context) {
-  let services = [];
-  let errors = [];
-  let members = [];
-
-  function isUsingAttrsSnapShots(node) {
-    if (node.key.name === 'didReceiveAttrs' && node.value.params.length > 0) {
-      node.value.params.forEach((param) => {
-        errors.push([param, 'Do not use the previous and new versions of attrs. If you need to do a comparsion on re-render stash the last value and compare the new value.']);
-      })
-    }
-  }
-
-  function isCPMissingDependentKey(node) {
-    if (isCP(node)) {
-      if (node.value.arguments.length === 1 && node.value.arguments[0].type === 'FunctionExpression') {
-        errors.push([node.value.arguments[0], 'Missing dependent key. If you are working around a value being shared acrossed instances use `init`']);
-      }
-    }
-  }
-
-  function isCP(node) {
-    return node.value.type === 'CallExpression' && node.value.callee.property.name === 'computed';
-  }
-
-  function isAttrs(node) {
-    if (node.property.name === 'attrs' && node.object.type === 'ThisExpression') {
-      errors.push([node.property, 'Do not use this.attrs.']);
-    }
-  }
-
-  function isFrameWorkObject(node) {
-    return node.object.type === 'Identifier' && FrameworkObjects.indexOf(node.object.name) === -1;
-  }
-
-  function isExtendingFrameworkObject(node) {
-    if (isExtend(node) && isFrameWorkObject(node)) {
-      errors.push([node, 'Do not create subclasses. Please use more compositional patterns described here.']);
-    }
-  }
-
-  function isExtend(node) {
-    return node.property.name === 'extend';
-  }
-
-  function isGetMethod(node) {
-    return node.property.name === 'get' && node.object.type === 'ThisExpression';
-  }
-
-  function isService(node) {
-    return services.indexOf(node.value) > -1
-  }
-
-  function isFrameworkHook() {
-    return FrameworkHooks.indexOf(context.getScope().block.parent.key.name) > -1;
-  }
-
-  function isEagerLazyInjection(node) {
-    if (isGetMethod(node) && isService(node.parent.arguments[0]) && isFrameworkHook()) {
-      errors.push([node.parent.arguments[0], 'Do not pull on lazy injections in framework hooks. If you need a service eagerly please inject it through an initializer.']);
-    }
-  }
-
-  function isMixin(node) {
-    if (isExtend(node)) {
-      if (node.parent.arguments.length > 1) {
-        node.parent.arguments.filter((arg) => {
-          return arg.type === 'Identifier'
-        }).forEach((arg) => {
-          errors.push([arg, 'Do not use Mixins. Please use more compositional patterns described here.']);
-        });
-      }
-    }
-  }
-
-  function collectInjectedProperties(node) {
-    if (node.value.type === 'CallExpression' && node.value.callee.property.name === 'service') {
-      services.push(node.key.name);
-    }
-  }
-
-  function isInjectedService(node) {
-  	return node.value.callee && node.value.callee.property.name === 'service';
-  }
-
-  function emptyArgs(node) {
-    return node.arguments.length === 0;
-  }
-
-  function isMissingInjectionName(node) {
-    if (isInjectedService(node) && emptyArgs(node.value)) {
-      errors.push([node.value.callee.property, 'Provide the name as a service to avoid reflection on the property name.'])
-    }
-  }
-
-  function isSettingInCPGetter(node) {
-    if (node.parent) {
-     // console.log(node.parent.parent.parent)
-    }
-  }
-
-  function isSendAction(node) {
-
-  }
-
-  function findMethod() {
-    let scope = context.getScope().block;
-    let top = true;
-    let methodName;
-
-    while (top) {
-      if (scope.parent.type === 'Property') {
-        if (scope.parent.parent.parent.type === 'CallExpression' && scope.parent.parent.parent.callee.property.name === 'extend') {
-          methodName = scope.parent.key.name;
-          top = false;
-        }
-      } else {
-        scope = scope.parent;
-      }
-    }
-
-    return methodName
-  }
-
-  function isSideEffect(node) {
-    if (node.parent.callee && node.object.type === 'ThisExpression' && members.indexOf(node.property.name) === -1) {
-      let currentMethod = findMethod();
-
-      if (FrameworkHooks.indexOf(currentMethod) > -1) {
-          console.log(node.property.name)
-      }
-    }
-  }
-
-  function collectMembers(node) {
-    if (node.value.type === 'FunctionExpression') {
-      members.push(node.key.name);
-    }
-  }
-
-  return {
-    MemberExpression(node) {
-      isAttrs(node);
-      isExtendingFrameworkObject(node);
-      isMixin(node);
-      isEagerLazyInjection(node);
-      isSendAction(node);
-      //isSideEffect(node);
-      isSettingInCPGetter(node)
-
-    },
-
-    Property(node) {
-      collectMembers(node);
-      collectInjectedProperties(node);
-      isCPMissingDependentKey(node);
-      isUsingAttrsSnapShots(node);
-      isMissingInjectionName(node);
-
-    },
-
-    'Program:exit'() {
-      errors.forEach((err) => {
-        context.report(err[0], err[1]);
-      });
-    },
-  };
+module.exports = {
+  rules: [
+    './rules/no-observers',
+    './rules/no-attrs',
+    './rules/no-action-cp',
+    './rules/no-component-unit-tests',
+    './rules/no-mixins',
+    './rules/no-subclassing',
+    './rules/no-attrs-snapshots',
+    './rules/no-set-interval',
+    './rules/no-set-timeout',
+    './rules/detect-stateless-service',
+    './rules/eager-injections',
+    './rules/cp-send-action',
+    './rules/missing-dependant-keys',
+    './rules/enforce-fastboot'
+  ]
 };
-

guides/rules/no-attrs.md

@@ -0,0 +1,62 @@
+import { get } from '../utils/get';
+import { getCaller } from '../utils/caller';
+
+
+function isCPDesc(node, method) {
+  if (node.type !== "FunctionExpression") {
+    return false;
+  }
+
+  if (get(node, "parent.key.name") !== method) {
+    return false;
+  }
+
+  let grandParent = get(node, "parent.parent");
+  if (!grandParent) {
+    return false;
+  }
+  if (grandParent.type !== "ObjectExpression") {
+    return false;
+  }
+  var greatGrandParent = pParent.parent; // more parents!
+  if (greatGrandParent.type !== "CallExpression") {
+    return false;
+  }
+  var callee = greatGrandParent.callee;
+  if (greatGrandParent.type === "Identifier" && callee.name === "computed") {
+    return true;
+  }
+  if (callee.type === "MemberExpression") {
+    var caller = getCaller(callee);
+    return caller === "Ember.computed" || caller === "Em.computed";
+  }
+  return false; // don't know how you could get here
+}
+
+function _isCpGetter2(node) {
+  if (node.type !== "FunctionExpression") {
+    return false;
+  }
+  var parent = node.parent;
+  if (parent.type !== "CallExpression") {
+    return false;
+  }
+  var callee = parent.callee;
+  if (callee.type === "Identifier" && callee.name === "computed") {
+    return true;
+  }
+  if (callee.type === "MemberExpression") {
+    var caller = n.getCaller(callee);
+    return caller === "Ember.computed" || caller === "Em.computed";
+  }
+  return false;
+}
+
+function isCpGetter(node) {
+  return isCPDesc(node, 'get') || isCPAccessor(node)
+}
+
+
+export default function noActionCp(context) {
+
+}

guides/rules/no-observers.md

@@ -0,0 +1,13 @@
+function isAttrs(node) {
+  return node.property.name === 'attrs' && node.object.type === 'ThisExpression';
+}
+
+export default function noAttrs(context) {
+  return {
+    MemberExpression(node) {
+      if (isAttrs(node)) {
+        context.report(node.property, `Do not use this.attrs. Please see the following guide for more infromation: http://github.com/chadhietala/ember-best-practices/files/guides/no-observers.md`);
+      }
+    }
+  }
+}

lib/index.js

@@ -0,0 +1,23 @@
+function isObserver(node) {
+  let { property, callee } = node;
+  return property && property.name === 'observer' ||
+         callee && callee.name === 'obsever';
+}
+
+const MESSAGE = `Do not use observers. Consider using computed properties instead. Please see following guide for more information: http://github.com/chadhietala/ember-best-practices/files/guides/no-observers.md`;
+
+export default function noObservers(context) {
+  return {
+    MemberExpression(node) {
+      if (isObserver(node)) {
+        context.report(node.property, MESSAGE);
+      }
+    },
+
+    CallExpression(node) {
+      if (isObserver(node)) {
+        context.report(node.callee, MESSAGE);
+      }
+    }
+  };
+};