improve component blueprint for octane

.eslintrc.js

@@ -1,3 +1,4 @@
+/* eslint-env node */
 module.exports = {
   root: true,
   parserOptions: {

blueprints/component-test/index.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const path = require('path');
+const stringUtil = require('ember-cli-string-utils');
+const getPathOption = require('ember-cli-get-component-path-option');
+
+const useTestFrameworkDetector = require('../test-framework-detector');
+
+function invocationFor(options) {
+  let parts = options.entity.name.split('/');
+  return parts.map((p) => stringUtil.classify(p)).join('::');
+}
+
+module.exports = useTestFrameworkDetector({
+  description: 'Generates a component integration or unit test.',
+
+  availableOptions: [
+    {
+      name: 'test-type',
+      type: ['integration', 'unit'],
+      default: 'integration',
+      aliases: [
+        { i: 'integration' },
+        { u: 'unit' },
+        { integration: 'integration' },
+        { unit: 'unit' },
+      ],
+    },
+  ],
+
+  fileMapTokens: function () {
+    return {
+      __root__() {
+        return 'tests';
+      },
+      __testType__(options) {
+        return options.locals.testType || 'integration';
+      },
+      __path__(options) {
+        if (options.pod) {
+          return path.join(options.podPath, options.locals.path, options.dasherizedModuleName);
+        }
+        return 'components';
+      },
+    };
+  },
+
+  locals: function (options) {
+    let dasherizedModuleName = stringUtil.dasherize(options.entity.name);
+    let componentPathName = dasherizedModuleName;
+    let testType = options.testType || 'integration';
+
+    let friendlyTestDescription = [
+      testType === 'unit' ? 'Unit' : 'Integration',
+      'Component',
+      dasherizedModuleName,
+    ].join(' | ');
+
+    if (options.pod && options.path !== 'components' && options.path !== '') {
+      componentPathName = [options.path, dasherizedModuleName].filter(Boolean).join('/');
+    }
+
+    let templateInvocation = invocationFor(options);
+    let componentName = templateInvocation;
+    let openComponent = (descriptor) => `<${descriptor}>`;
+    let closeComponent = (descriptor) => `</${descriptor}>`;
+    let selfCloseComponent = (descriptor) => `<${descriptor} />`;
+
+    return {
+      path: getPathOption(options),
+      testType: testType,
+      componentName,
+      componentPathName,
+      templateInvocation,
+      openComponent,
+      closeComponent,
+      selfCloseComponent,
+      friendlyTestDescription,
+    };
+  }
+});

blueprints/component-test/mocha-files/__root__/__testType__/__path__/__test__.ts

@@ -0,0 +1,34 @@
+import { expect } from 'chai';
+import { describeComponent, it } from 'ember-mocha';<% if (testType === 'integration') { %>
+import hbs from 'htmlbars-inline-precompile';<% } %>
+
+describeComponent('<%= componentPathName %>', '<%= friendlyTestDescription %>',
+  {
+    <% if (testType === 'integration' ) { %>integration: true<% } else if(testType === 'unit') { %>// Specify the other units that are required for this test
+    // needs: ['component:foo', 'helper:bar'],
+    unit: true<% } %>
+  },
+  function() {
+    it('renders', function() {
+      <% if (testType === 'integration' ) { %>// Set any properties with this.set('myProperty', 'value');
+      // Handle any actions with this.on('myAction', function(val) { ... });
+
+      this.render(hbs`<%= selfCloseComponent(componentName) %>`);
+      expect(this.element).to.not.be.null;
+
+      // Template block usage:
+      this.render(hbs`
+        <%= openComponent(componentName) %>
+          template block text
+        <%= closeComponent(componentName) %>
+      `);
+
+      expect(this.element.text().trim()).to.equal('template block text');<% } else if(testType === 'unit') { %>// creates the component instance
+      let component = this.subject();
+      // renders the component on the page
+      this.render();
+      expect(component).to.be.ok;
+      expect(this.element).to.not.be.null;<% } %>
+    });
+  }
+);

blueprints/component-test/qunit-files/__root__/__testType__/__path__/__test__.ts

@@ -0,0 +1,40 @@
+<% if (testType == 'integration') { %>
+import { module, test } from 'qunit';
+import { setupRenderingTest } from 'ember-qunit';
+import { render } from '@ember/test-helpers';
+import { hbs } from 'ember-cli-htmlbars';
+
+module('Integration | Component | <%= dasherizedModuleName %>', function(hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders', async function(assert) {
+    // Set any properties with this.set('myProperty', 'value');
+    // Handle any actions with this.set('myAction', function(val) { ... });
+
+    await render(hbs`<<%= templateInvocation %> />`);
+
+    assert.equal(this.element.textContent.trim(), '');
+
+    // Template block usage:
+    await render(hbs`
+      <<%= templateInvocation %>>
+        template block text
+      </<%= templateInvocation %>>
+    `);
+
+    assert.equal(this.element.textContent.trim(), 'template block text');
+  });
+});
+<% } else if (testType == 'unit') { %>
+import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Component | <%= dasherizedModuleName %>', function(hooks) {
+  setupTest(hooks);
+
+  test('it exists', function(assert) {
+    let component = this.owner.factoryFor('component:<%= dasherizedModuleName %>').create();
+    assert.ok(component);
+  });
+});
+<% } >

blueprints/component/files/__root__/__path__/__name__.ts

@@ -0,0 +1,4 @@
+import Component from '@ember/component';
+<%= importTemplate %>
+export default class <%= classifiedModuleName %> extends Component {
+};

blueprints/component/files/__root__/__templatepath__/__templatename__.hbs

@@ -0,0 +1 @@
+{{yield}}

blueprints/component/glimmer-files/__root__/__path__/__name__.hbs

@@ -0,0 +1 @@
+{{yield}}

blueprints/component/glimmer-files/__root__/__path__/__name__.ts

@@ -0,0 +1,7 @@
+import Component from '@glimmer/component';
+
+interface <%= classifiedModuleName %>Args {  
+}
+
+export default class <%= classifiedModuleName %> extends Component<<%= classifiedModuleName %>Args> {
+};

blueprints/component/index.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const path = require('path');
+const stringUtil = require('ember-cli-string-utils');
+const pathUtil = require('ember-cli-path-utils');
+const getPathOption = require('ember-cli-get-component-path-option');
+const normalizeEntityName = require('ember-cli-normalize-entity-name');
+const EOL = require('os').EOL;
+
+module.exports = {
+  description: 'Generates a component.',
+
+  availableOptions: [
+    {
+      name: 'path',
+      type: String,
+      default: 'components',
+      aliases: [{ 'no-path': '' }],
+    },
+  ],
+
+  filesPath: function() {
+    let filesDirectory = 'files';
+    let dependencies = this.project.dependencies();
+
+    if ('@glimmer/component' in dependencies) {
+      filesDirectory = 'glimmer-files';
+    }
+
+    return path.join(this.path, filesDirectory);
+  },
+
+  fileMapTokens: function() {
+    return {
+      __path__: function(options) {
+        if (options.pod) {
+          return path.join(options.podPath, options.locals.path, options.dasherizedModuleName);
+        } else {
+          return 'components';
+        }
+      },
+      __templatepath__: function(options) {
+        if (options.pod) {
+          return path.join(options.podPath, options.locals.path, options.dasherizedModuleName);
+        }
+        return 'templates/components';
+      },
+      __templatename__: function(options) {
+        if (options.pod) {
+          return 'template';
+        }
+        return options.dasherizedModuleName;
+      },
+    };
+  },
+
+  normalizeEntityName: function(entityName) {
+    return normalizeEntityName(entityName);
+  },
+
+  locals: function(options) {
+    let templatePath = '';
+    let importTemplate = '';
+    let contents = '';
+
+    let classifiedModuleName = stringUtil.dasherize(options.entity.name);
+
+    // if we're in an addon, build import statement
+    if (options.project.isEmberCLIAddon() || (options.inRepoAddon && !options.inDummy)) {
+      if (options.pod) {
+        templatePath = './template';
+      } else {
+        templatePath =
+          pathUtil.getRelativeParentPath(options.entity.name) +
+          'templates/components/' +
+          classifiedModuleName;
+      }
+      importTemplate = '// @ts-ignore: Ignore import of compiled template' + EOL + 'import layout from \'' + templatePath + '\';' + EOL;
+      contents = EOL + '  layout = layout;';
+    }
+
+    return {
+      importTemplate: importTemplate,
+      contents: contents,
+      path: getPathOption(options),
+      classifiedModuleName
+    };
+  },
+};

blueprints/helper-test/mocha-files/tests/__testType__/helpers/__name__-test.ts

@@ -21,7 +21,7 @@ describe('<%= friendlyTestName %>', function() {
 
     this.render(hbs`{{<%= dasherizedModuleName %> inputValue}}`);
 
-    expect(this.$().text().trim()).to.equal('1234');
+    expect(this.element.text().trim()).to.equal('1234');
   });
 });
 <% } else if (testType == 'unit') { %>import { describe, it } from 'mocha';

jsconfig.json

@@ -0,0 +1 @@
+{"compilerOptions":{"target":"es6","experimentalDecorators":true},"exclude":["node_modules","bower_components","tmp","vendor",".git","dist"]}

lib/utilities/update-paths-for-addon.js

@@ -14,10 +14,10 @@ module.exports = function(paths, addonName, appName, options) {
   appStarPaths = paths[appNameStar] = paths[appNameStar] || [];
 
   if (options.removePaths) {
-    if (paths.hasOwnProperty(addonName)) {
+    if (Object.prototype.hasOwnProperty.call(paths, addonName)) {
       delete paths[addonName];
     }
-    if (paths.hasOwnProperty(addonNameStar)) {
+    if (Object.prototype.hasOwnProperty.call(paths, addonNameStar)) {
       delete paths[addonNameStar]
     }
     let addonAppPathIndex = appStarPaths.indexOf([addonAppPath, '*'].join('/'));
@@ -26,16 +26,16 @@ module.exports = function(paths, addonName, appName, options) {
       paths[appNameStar] = appStarPaths;
     }
   } else {
-    if (!paths.hasOwnProperty(addonName)) {
+    if (!Object.prototype.hasOwnProperty.call(paths, addonName)) {
       paths[addonName] = [ addonAddonPath ];
     }
-    if (!paths.hasOwnProperty(addonNameStar)) {
+    if (!Object.prototype.hasOwnProperty.call(paths, addonNameStar)) {
       paths[addonNameStar] = [ [addonAddonPath, '*'].join('/') ];
     }
-    if (!paths.hasOwnProperty(addonTestSupportPath)) {
+    if (!Object.prototype.hasOwnProperty.call(paths, addonTestSupportPath)) {
       paths[addonTestSupportPath] = [ [addonPath, 'addon-test-support'].join('/') ];
     }
-    if (!paths.hasOwnProperty(addonTestSupportStarPath)) {
+    if (!Object.prototype.hasOwnProperty.call(paths, addonTestSupportStarPath)) {
       paths[addonTestSupportStarPath] = [ [addonPath, 'addon-test-support', '*'].join('/') ];
     }
     if (appStarPaths.indexOf(addonAppPath) === -1) {