Merge pull request #207 from ember-cli/dots

Normalize dots to slashes where appropriate

mu-trees/addon/ember-config.js

@@ -70,6 +70,7 @@ export default function generateConfig(name) {
       },
       routes: {
         group: 'ui',
+        defaultType: 'route',
         privateCollections: ['components', 'utils'],
         types: ['route', 'controller', 'template']
       },

mu-trees/addon/resolvers/glimmer-wrapper/index.js

@@ -2,7 +2,11 @@ import Ember from 'ember';
 import GlimmerResolver from '@glimmer/resolver/resolver';
 import RequireJSRegistry from '../../module-registries/requirejs';
 
-const { DefaultResolver } = Ember;
+const { DefaultResolver, String: { dasherize } } = Ember;
+
+function slasherize(dotted) {
+  return dotted.replace(/\./g, '/');
+}
 
 const TEMPLATE_TO_PARTIAL = /^template:(.*\/)?_([\w-]+)/;
 
@@ -38,30 +42,44 @@ const Resolver = DefaultResolver.extend({
       referrer = referrer.split('/template.hbs')[0];
     }
 
-    if (lookupString.indexOf('service:') === 0) {
-      let parts = lookupString.split(':');
-      lookupString = `${parts[0]}:${Ember.String.dasherize(parts[1])}`;
-    } else if (lookupString.indexOf('template:components/') === 0) {
-      lookupString = lookupString.replace('components/', '');
-    } else if (lookupString.indexOf('template:') === 0) {
-      /*
-       * Ember partials are looked up as templates. Here we replace the template
-       * resolution with a partial resolute when appropriate. Try to keep this
-       * code as "pay-go" as possible.
-       */
-      let match = TEMPLATE_TO_PARTIAL.exec(lookupString);
-      if (match) {
-        let namespace = match[1] || '';
-        let name = match[2];
+    let [type, name] = lookupString.split(':');
+    if (name) {
+      if (type === 'service') {
+        /* Services may be camelCased */
+        lookupString = `service:${dasherize(name)}`;
+      } else if (type === 'route') {
+        /* Routes may have.dot.paths */
+        lookupString = `route:${slasherize(name)}`;
+      } else if (type === 'controller') {
+        /* Controllers may have.dot.paths */
+        lookupString = `controller:${slasherize(name)}`;
+      } else if (type === 'template') {
+        if (name.indexOf('components/') === 0) {
+          lookupString = `template:${name.slice(11)}`;
+        } else {
+          /*
+           * Ember partials are looked up as templates. Here we replace the template
+           * resolution with a partial resolute when appropriate. Try to keep this
+           * code as "pay-go" as possible.
+           */
+          let match = TEMPLATE_TO_PARTIAL.exec(lookupString);
+          if (match) {
+            let namespace = match[1] || '';
+            let name = match[2];
 
-        lookupString = `partial:${namespace}${name}`;
-      } else {
-        if (referrer) {
-          throw new Error(`Cannot look up a route template ${lookupString} with a referrer`);
+            lookupString = `partial:${namespace}${name}`;
+          } else {
+            if (referrer) {
+              throw new Error(`Cannot look up a route template ${lookupString} with a referrer`);
+            }
+            /*
+             * Templates for routes must be looked up with a referrer. They may
+             * have dots.in.paths
+             */
+            lookupString = `template`;
+            referrer = `route:/${this._configRootName}/routes/${slasherize(name)}`;
+          }
         }
-        let parts = lookupString.split(':');
-        lookupString = `template`;
-        referrer = `route:/${this._configRootName}/routes/${parts[1]}`;
       }
     }
 

mu-trees/tests/unit/resolvers/glimmer-wrapper/basic-test.js

@@ -105,6 +105,56 @@ test('Services with camelCare are normalized', function(assert) {
   );
 });
 
+test('Routes with dots are normalized', function(assert) {
+  let expectedModule = {};
+  let resolver = this.resolverForEntries({
+    app: {
+      name: 'example-app'
+    },
+    types: {
+      route: { definitiveCollection: 'routes' }
+    },
+    collections: {
+      routes: {
+        types: [ 'route' ]
+      }
+    }
+  }, {
+    'route:/app/routes/parent/child': expectedModule
+  });
+
+  assert.equal(
+    resolver.resolve('route:parent.child'),
+    expectedModule,
+    'route names with dots are slasherized'
+  );
+});
+
+test('Controllers with dots are normalized', function(assert) {
+  let expectedModule = {};
+  let resolver = this.resolverForEntries({
+    app: {
+      name: 'example-app'
+    },
+    types: {
+      controller: { definitiveCollection: 'controllers' }
+    },
+    collections: {
+      controllers: {
+        types: [ 'controller' ]
+      }
+    }
+  }, {
+    'controller:/app/controllers/parent/child': expectedModule
+  });
+
+  assert.equal(
+    resolver.resolve('controller:parent.child'),
+    expectedModule,
+    'controller names with dots are slasherized'
+  );
+});
+
 /*
  * "Rule 2" of the unification RFC.
  *
@@ -417,6 +467,43 @@ test('Can resolve a partial', function(assert) {
   );
 });
 
+test('Can normalize and resolve a template for route', function(assert) {
+  let template = {};
+  let resolver = this.resolverForEntries({
+    app: {
+      name: 'example-app'
+    },
+    types: {
+      route: { definitiveCollection: 'routes' },
+      template: { definitiveCollection: 'components' }
+    },
+    collections: {
+      routes: {
+        group: 'ui',
+        defaultType: 'route',
+        types: ['route', 'template']
+      },
+      components: {
+        group: 'ui',
+        types: ['template']
+      }
+    }
+  }, {
+    'template:/app/routes/parent/child': template
+  });
+
+  assert.equal(
+    resolver.resolve('template:parent/child', ''),
+    template,
+    'template resolved'
+  );
+  assert.equal(
+    resolver.resolve('template:parent.child', ''),
+    template,
+    'template normalized and resolved'
+  );
+});
+
 test('Can resolve private component template', function(assert) {
   let template = {};
   let notTemplate = {};