Merge pull request #2560 from RobbieTheWagner/feat/native-model-class-support

Add native class support for order-in-models and no-empty-attrs

Author: NullVoxPopuli

docs/rules/no-empty-attrs.md

@@ -35,9 +35,3 @@ export default Model.extend({
 ```
 
 In case you need a custom behavior, it's good to write your own [transform](https://api.emberjs.com/ember-data/release/classes/Transform).
-
-## Help Wanted
-
-| Issue                                      | Link                                                                |
-| :----------------------------------------- | :------------------------------------------------------------------ |
-| ❌ Missing native JavaScript class support | [#560](https://github.com/ember-cli/eslint-plugin-ember/issues/560) |

docs/rules/order-in-models.md

@@ -51,6 +51,8 @@ You should write code grouped and ordered in this way:
 4. Multiline computed properties
 5. Other structures (custom methods etc.)
 
+This rule checks ordering only; it does not enforce indentation or other whitespace formatting.
+
 ## Examples
 
 ```js
@@ -85,9 +87,3 @@ export default Model.extend({
   shape: attr('string'),
 });
 ```
-
-## Help Wanted
-
-| Issue                                      | Link                                                                |
-| :----------------------------------------- | :------------------------------------------------------------------ |
-| ❌ Missing native JavaScript class support | [#560](https://github.com/ember-cli/eslint-plugin-ember/issues/560) |

lib/rules/no-empty-attrs.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const ember = require('../utils/ember');
+const decoratorUtils = require('../utils/decorators');
 
 //------------------------------------------------------------------------------
 // Ember Data - Be explicit with Ember data attribute types
@@ -31,6 +32,24 @@ module.exports = {
     const sourceCode = context.sourceCode;
     const { scopeManager } = sourceCode;
 
+    function reportNativeClassAttrs(node) {
+      for (const property of node.body.body) {
+        const attrDecorator = decoratorUtils.findDecorator(property, 'attr');
+
+        if (!attrDecorator) {
+          continue;
+        }
+
+        if (
+          attrDecorator.expression.type === 'Identifier' ||
+          (attrDecorator.expression.type === 'CallExpression' &&
+            attrDecorator.expression.arguments.length === 0)
+        ) {
+          report(attrDecorator.expression);
+        }
+      }
+    }
+
     return {
       CallExpression(node) {
         if (!ember.isDSModel(node, filePath)) {
@@ -48,6 +67,20 @@ module.exports = {
           }
         }
       },
+      ClassDeclaration(node) {
+        if (!ember.isEmberDataModel(context, node)) {
+          return;
+        }
+
+        reportNativeClassAttrs(node);
+      },
+      ClassExpression(node) {
+        if (!ember.isEmberDataModel(context, node)) {
+          return;
+        }
+
+        reportNativeClassAttrs(node);
+      },
     };
   },
 };

lib/rules/order-in-models.js

@@ -86,6 +86,40 @@ module.exports = {
           return;
         }
 
+        reportUnorderedProperties(
+          node,
+          context,
+          'model',
+          order,
+          importedEmberName,
+          importedInjectName,
+          importedObserverName,
+          importedControllerName,
+          scopeManager
+        );
+      },
+      ClassDeclaration(node) {
+        if (!ember.isEmberDataModel(context, node)) {
+          return;
+        }
+
+        reportUnorderedProperties(
+          node,
+          context,
+          'model',
+          order,
+          importedEmberName,
+          importedInjectName,
+          importedObserverName,
+          importedControllerName,
+          scopeManager
+        );
+      },
+      ClassExpression(node) {
+        if (!ember.isEmberDataModel(context, node)) {
+          return;
+        }
+
         reportUnorderedProperties(
           node,
           context,

lib/utils/ember.js

@@ -11,6 +11,7 @@ const kebabCase = require('lodash.kebabcase');
 
 module.exports = {
   isDSModel,
+  isEmberDataModel,
   isModule,
   isModuleByFilePath,
   isMirageDirectory,
@@ -158,6 +159,55 @@ function isDSModel(node, filePath) {
   return isModule(node, 'Model', 'DS') || isModuleByPath;
 }
 
+function isEmberDataModel(context, node) {
+  if (!(types.isClassDeclaration(node) || node.type === 'ClassExpression')) {
+    assert(
+      false,
+      'Function should only be called on a `ClassDeclaration`/`ClassExpression` (native class)'
+    );
+  }
+
+  if (!node.superClass) {
+    return false;
+  }
+
+  if (types.isIdentifier(node.superClass)) {
+    const superClassImportPath = importUtils.getSourceModuleNameForIdentifier(
+      context,
+      node.superClass
+    );
+
+    if (
+      superClassImportPath === '@ember-data/model' ||
+      superClassImportPath === 'ember-data/model'
+    ) {
+      return true;
+    }
+  }
+
+  if (
+    types.isCallExpression(node.superClass) &&
+    types.isMemberExpression(node.superClass.callee) &&
+    types.isIdentifier(node.superClass.callee.property) &&
+    node.superClass.callee.property.name === 'extend' &&
+    types.isIdentifier(node.superClass.callee.object)
+  ) {
+    const superClassImportPath = importUtils.getSourceModuleNameForIdentifier(
+      context,
+      node.superClass.callee.object
+    );
+
+    if (
+      superClassImportPath === '@ember-data/model' ||
+      superClassImportPath === 'ember-data/model'
+    ) {
+      return true;
+    }
+  }
+
+  return isModuleByFilePath(context.filename, 'model');
+}
+
 function isModuleByFilePath(filePath, module) {
   const expectedFileNameJs = `${module}.js`;
   const expectedFileNameTs = `${module}.ts`;

lib/utils/property-order.js

@@ -208,13 +208,15 @@ function reportUnorderedProperties(
   importedControllerName,
   scopeManager
 ) {
+  const isNativeClass = types.isClassDeclaration(node) || node.type === 'ClassExpression';
   let maxOrder = -1;
   const firstPropertyOfType = {};
   let firstPropertyOfNextType;
 
-  const properties = types.isClassDeclaration(node)
-    ? node.body.body
-    : ember.getModuleProperties(node, scopeManager);
+  const properties =
+    types.isClassDeclaration(node) || node.type === 'ClassExpression'
+      ? node.body.body
+      : ember.getModuleProperties(node, scopeManager);
 
   for (const property of properties) {
     const type = determinePropertyType(
@@ -270,18 +272,18 @@ function reportUnorderedProperties(
               nextToken = previousToken;
             }
 
-            // adding a trailing comma when it's the last property defined
+            // adding a trailing comma when it's the last property defined in object literals
             if (nextToken.value === '}') {
               isLastProperty = true;
 
-              if (previousToken.value !== ',') {
+              if (!isNativeClass && previousToken.value !== ',') {
                 optionalComma = ',';
               }
             }
           } while (nextToken.value === ',');
 
-          // additional whitespace is needed only when it's the last property
-          const whitespaceCount = isLastProperty ? property.loc.start.column : 0;
+          // additional whitespace is needed only when it's the last property in object literals
+          const whitespaceCount = !isNativeClass && isLastProperty ? property.loc.start.column : 0;
 
           const propertyOffset = getCommentOffsetBefore(property, sourceCode);
           const foundPropertyOffset = getCommentOffsetBefore(foundProperty, sourceCode);

tests/lib/rules/no-empty-attrs.js

@@ -10,7 +10,14 @@ const RuleTester = require('eslint').RuleTester;
 // ------------------------------------------------------------------------------
 
 const eslintTester = new RuleTester({
-  parserOptions: { ecmaVersion: 2022, sourceType: 'module' },
+  parser: require.resolve('@babel/eslint-parser'),
+  parserOptions: {
+    ecmaVersion: 2022,
+    sourceType: 'module',
+    babelOptions: {
+      configFile: require.resolve('../../../.babelrc'),
+    },
+  },
 });
 
 const message = 'Supply proper attribute type';
@@ -31,6 +38,10 @@ eslintTester.run('no-empty-attrs', rule, {
           return attr.underscore();
         }),
       });`,
+    `import Model, { attr } from '@ember-data/model';
+      export default class UserModel extends Model {
+        @attr('string') name;
+      }`,
   ],
   invalid: [
     {
@@ -98,5 +109,29 @@ eslintTester.run('no-empty-attrs', rule, {
       output: null,
       errors: [{ message, line: 1 }],
     },
+    {
+      code: `import Model, { attr } from '@ember-data/model';
+        export default class UserModel extends Model {
+          @attr() name;
+        }`,
+      output: null,
+      errors: [{ message, line: 3 }],
+    },
+    {
+      code: `import Model, { attr } from '@ember-data/model';
+        export default class UserModel extends Model {
+          @attr name;
+        }`,
+      output: null,
+      errors: [{ message, line: 3 }],
+    },
+    {
+      code: `import Model, { attr } from '@ember-data/model';
+        export default (class UserModel extends Model {
+          @attr name;
+        });`,
+      output: null,
+      errors: [{ message, line: 3 }],
+    },
   ],
 });