[WIP] Update order-in-* rules to handle native class syntax

lib/rules/order-in-components.js

@@ -25,6 +25,8 @@ const ORDER = [
   'willDestroyElement',
   'willClearRender',
   'didDestroyElement',
+  'action-single-line-function',
+  'action-multi-line-function',
   'actions',
   'method',
 ];
@@ -91,6 +93,12 @@ module.exports = {
 
         reportUnorderedProperties(node, context, 'component', order);
       },
+      ClassDeclaration(node) {
+        if (!ember.isEmberComponent(context, node)) {
+          return;
+        }
+        reportUnorderedProperties(node, context, 'component', order);
+      },
     };
   },
 };

lib/utils/property-order.js

@@ -12,6 +12,8 @@ module.exports = {
 
 const NAMES = {
   actions: 'actions hash',
+  'action-single-line-function': 'action single-line function',
+  'action-multi-line-function': 'action multi-line function',
   activate: 'lifecycle hook',
   afterModel: 'lifecycle hook',
   attribute: 'attribute',
@@ -105,10 +107,16 @@ function determinePropertyType(node, parentType) {
   }
 
   if (ember.isSingleLineFn(node)) {
+    if (types.isMethodDefinitionWithDecorator(node, 'action')) {
+      return 'action-single-line-function';
+    }
     return 'single-line-function';
   }
 
   if (ember.isMultiLineFn(node)) {
+    if (types.isMethodDefinitionWithDecorator(node, 'action')) {
+      return 'action-multi-line-function';
+    }
     return 'multi-line-function';
   }
 
@@ -120,7 +128,6 @@ function determinePropertyType(node, parentType) {
     if (utils.isEmptyMethod(node)) {
       return 'empty-method';
     }
-
     return 'method';
   }
 

lib/utils/types.js

@@ -22,6 +22,7 @@ module.exports = {
   isLogicalExpression,
   isMemberExpression,
   isMethodDefinition,
+  isMethodDefinitionWithDecorator,
   isNewExpression,
   isObjectExpression,
   isObjectPattern,
@@ -130,17 +131,7 @@ function isClassProperty(node) {
  * @returns {boolean} Whether or not the node is a ClassProperty with the given decorator.
  */
 function isClassPropertyWithDecorator(node, decoratorName) {
-  return (
-    isClassProperty(node) &&
-    node.decorators &&
-    node.decorators.some(decorator => {
-      const expression = decorator.expression;
-      return (
-        (isIdentifier(expression) && expression.name === decoratorName) ||
-        (isCallExpression(expression) && expression.callee.name === decoratorName)
-      );
-    })
-  );
+  return isClassProperty(node) && hasDecorator(node, decoratorName);
 }
 
 /**
@@ -265,6 +256,37 @@ function isMethodDefinition(node) {
   return node !== undefined && node.type === 'MethodDefinition';
 }
 
+/**
+ * Check whether or not a node is a MethodDefinition.
+ *
+ * @param {Object} node The node to check.
+ * @param {string} decoratorName The decorator to look for.
+ * @return {boolean} Whether or not the node is a MethodDefinition with a decorator.
+ */
+function isMethodDefinitionWithDecorator(node, decoratorName) {
+  return isMethodDefinition(node) && hasDecorator(node, decoratorName);
+}
+
+/**
+ * Check whether or not a node is an NewExpression.
+ *
+ * @param {Object} node The node to check.
+ * @param {string} decoratorName The decorator to look for.
+ * @return {boolean} Whether or not the node has a decorator.
+ */
+function hasDecorator(node, decoratorName) {
+  return (
+    node.decorators &&
+    node.decorators.some(decorator => {
+      const expression = decorator.expression;
+      return (
+        (isIdentifier(expression) && expression.name === decoratorName) ||
+        (isCallExpression(expression) && expression.callee.name === decoratorName)
+      );
+    })
+  );
+}
+
 /**
  * Check whether or not a node is an NewExpression.
  *

package.json

@@ -18,6 +18,7 @@
     "test": "jest",
     "test:coverage": "jest --coverage",
     "test:watch": "jest --watchAll",
+    "test:debug": "node --inspect node_modules/.bin/jest --runInBand",
     "update": "node ./scripts/update-rules.js"
   },
   "repository": {