ember-appkit-rails 0.4.0 → 0.5.0

data/test/generators/serializer_override_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class SerializerOverrideTest < Rails::Generators::TestCase
+  include GeneratorTestSupport
+
+  tests Rails::Generators::SerializerGenerator
+  destination File.join(Rails.root, "tmp")
+  setup :prepare_destination
+
+  test "create serializer under config/serializers" do
+    run_generator ["post"]
+    assert_file "#{config_path}/serializers/post_serializer.rb"
+  end
+
+  test "does not create serializer under app/serializers" do
+    run_generator ["post"]
+    assert_no_file "#{app_path}/serializers/post_serializer.rb"
+  end
+end

data/test/generators/view_generator_test.rb

@@ -11,30 +11,30 @@ class ViewGeneratorTest < Rails::Generators::TestCase
 
   test "create view with template by default" do
     run_generator ["post"]
-    assert_file "#{app_path}/views/post.js.es6"
+    assert_file "#{app_path}/views/post.es6"
     assert_file "#{app_path}/templates/post.hbs"
   end
 
   test "create view without a template" do
     run_generator ["post", "--without-template"]
-    assert_file "#{app_path}/views/post.js.es6"
+    assert_file "#{app_path}/views/post.es6"
     assert_no_file "#{app_path}/templates/post.hbs"
   end
 
   test "create view and template (using ember-rails flags)" do
     run_generator ["post", "--with-template"]
-    assert_file "#{app_path}/views/post.js.es6"
+    assert_file "#{app_path}/views/post.es6"
     assert_file "#{app_path}/templates/post.hbs"
   end
 
   test "create namespaced view" do
     run_generator ["post/index"]
-    assert_file "#{app_path}/views/post/index.js.es6"
+    assert_file "#{app_path}/views/post/index.es6"
   end
 
   test "Assert files are properly created" do
     run_generator %w(ember)
-    assert_file "#{app_path}/views/ember.js.es6"
+    assert_file "#{app_path}/views/ember.es6"
   end
 
   test "Uses config.ember.appkit.paths.app" do
@@ -42,7 +42,7 @@ class ViewGeneratorTest < Rails::Generators::TestCase
 
     with_config paths: {app: custom_path} do
       run_generator [ "ember"]
-      assert_file "#{custom_path}/views/ember.js.es6"
+      assert_file "#{custom_path}/views/ember.es6"
     end
   end
 end

data/test/integration/engine_test.rb

@@ -5,6 +5,10 @@ class EngineTest < ActionDispatch::IntegrationTest
     refute Rails.application.config.assets.paths.include?(File.join(Rails.root, 'app/assets/javascripts'))
   end
 
+  test 'config/serializers is added to autoload_path' do
+    assert Rails.application.config.paths.eager_load.include?(File.join(Rails.root, 'config/serializers'))
+  end
+
   test 'app is in the asset load path' do
     assert Rails.application.config.assets.paths.include?(File.join(Rails.root, 'app'))
   end

data/test/support/generator_test_support.rb

@@ -71,10 +71,10 @@ module GeneratorTestSupport
   end
 
   def copy_router(path = config_path)
-    source = File.expand_path("../../../lib/generators/templates/router.js.es6", __FILE__)
+    source = File.expand_path("../../../lib/generators/templates/router.es6", __FILE__)
     destination = File.join(destination_root, path)
     FileUtils.mkdir_p(destination)
-    FileUtils.cp source, File.join(destination, 'router.js.es6')
+    FileUtils.cp source, File.join(destination, 'router.es6')
   end
 
   def copy_application(path = config_path)

data/vendor/assets/javascripts/{app.js.es6.erb → app.es6.erb}

@@ -1,10 +1,12 @@
 <% config = Rails.application.config.ember %>
-import Resolver from 'resolver';
+import Resolver from 'ember/resolver';
 
 if (typeof Turbolinks !== 'undefined') {
   throw new Error("Turbolinks has been detected. Ember Appkit Rails will not function properly alongside Turbolinks.");
 }
 
+if (window.config === undefined) { window.config = {}; }
+
 var App = Ember.Application.extend({
   Resolver: Resolver
 }, window.config);

data/vendor/assets/javascripts/ember-appkit/index.js

@@ -1,5 +1,4 @@
 //= require ./loader
 //= require ./resolver
-//= require ./resolver_ext
 //= require app
 //= require templates/application

data/vendor/assets/javascripts/ember-appkit/resolver.js

@@ -1,5 +1,5 @@
 // Fetched from: https://raw.github.com/stefanpenner/ember-jj-abrams-resolver/master/dist/ember-resolver.js
-// Fetched on: 2014-01-11T18:12:01
+// Fetched on: 2014-03-07T00:18:39
 // ==========================================================================
 // Project:   Ember - JavaScript Application Framework
 // Copyright: Copyright 2013 Stefan Penner and Ember App Kit Contributors
@@ -13,16 +13,21 @@
 (function() {
 /*globals define registry requirejs */
 
-define("resolver",
+define("ember/resolver",
   [],
   function() {
     "use strict";
+
+    if (typeof requirejs.entries === 'undefined') {
+      requirejs.entries = requirejs._eak_seen;
+    }
+
   /*
    * This module defines a subclass of Ember.DefaultResolver that adds two
    * important features:
    *
    *  1) The resolver makes the container aware of es6 modules via the AMD
-   *     output. The loader's _seen is consulted so that classes can be
+   *     output. The loader's _moduleEntries is consulted so that classes can be
    *     resolved directly via the module loader, without needing a manual
    *     `import`.
    *  2) is able provide injections to classes that implement `extend`
@@ -64,55 +69,88 @@ define("resolver",
     };
   }
 
-  function chooseModuleName(seen, moduleName) {
+  function chooseModuleName(moduleEntries, moduleName) {
     var underscoredModuleName = Ember.String.underscore(moduleName);
 
-    if (moduleName !== underscoredModuleName && seen[moduleName] && seen[underscoredModuleName]) {
+    if (moduleName !== underscoredModuleName && moduleEntries[moduleName] && moduleEntries[underscoredModuleName]) {
       throw new TypeError("Ambiguous module names: `" + moduleName + "` and `" + underscoredModuleName + "`");
     }
 
-    if (seen[moduleName]) {
+    if (moduleEntries[moduleName]) {
       return moduleName;
-    } else if (seen[underscoredModuleName]) {
+    } else if (moduleEntries[underscoredModuleName]) {
       return underscoredModuleName;
     } else {
-      return moduleName;
+      var parts = moduleName.split('/'),
+          lastPart = parts[parts.length - 1],
+          partializedModuleName;
+
+      parts[parts.length - 1] = lastPart.replace(/^-/, '_');
+      partializedModuleName = parts.join('/');
+
+      if (moduleEntries[partializedModuleName]) {
+        Ember.deprecate('Modules should not contain underscores. ' +
+                        'Attempted to lookup "'+moduleName+'" which ' +
+                        'was not found. Please rename "'+partializedModuleName+'" '+
+                        'to "'+moduleName+'" instead.', false);
+
+        return partializedModuleName;
+      } else {
+        return moduleName;
+      }
     }
   }
 
-  function resolveRouter(parsedName) {
-    /*jshint validthis:true */
-
-    var prefix = this.namespace.modulePrefix,
-        routerModule;
+  function logLookup(found, parsedName, moduleName) {
+    if (Ember.ENV.LOG_MODULE_RESOLVER) {
+      var symbol;
 
-    if (parsedName.fullName === 'router:main') {
-      // for now, lets keep the router at app/router.js
-      if (requirejs._eak_seen[prefix + '/router']) {
-        routerModule = require(prefix + '/router');
-        if (routerModule['default']) { routerModule = routerModule['default']; }
+      if (found) { symbol = '[✓]'; }
+      else       { symbol = '[ ]'; }
 
-        return routerModule;
-      }
+      Ember.Logger.info(symbol, parsedName.fullName, new Array(40 - parsedName.fullName.length).join('.'), moduleName);
     }
   }
 
   function resolveOther(parsedName) {
     /*jshint validthis:true */
 
-    var prefix = this.namespace.modulePrefix;
+    var moduleName, tmpModuleName, prefix, podPrefix, moduleEntries;
+
+    prefix = this.namespace.modulePrefix;
+    podPrefix = this.namespace.podModulePrefix || prefix;
+    moduleEntries = requirejs.entries;
+
     Ember.assert('module prefix must be defined', prefix);
 
     var pluralizedType = parsedName.type + 's';
     var name = parsedName.fullNameWithoutType;
 
-    var moduleName = prefix + '/' +  pluralizedType + '/' + name;
+    // lookup using POD formatting first
+    tmpModuleName = podPrefix + '/' + name + '/' + parsedName.type;
+    if (moduleEntries[tmpModuleName]) {
+      moduleName = tmpModuleName;
+    }
+
+    // if not using POD format, use the custom prefix
+    if (this.namespace[parsedName.type + 'Prefix']) {
+      prefix = this.namespace[parsedName.type + 'Prefix'];
+    }
+
+    // if router:main or adapter:main look for a module with just the type first
+    tmpModuleName = prefix + '/' + parsedName.type;
+    if (!moduleName && name === 'main' && moduleEntries[tmpModuleName]) {
+      moduleName = prefix + '/' + parsedName.type;
+    }
+
+    // fallback if not type:main or POD format
+    if (!moduleName) { moduleName = prefix + '/' +  pluralizedType + '/' + name; }
 
     // allow treat all dashed and all underscored as the same thing
     // supports components with dashes and other stuff with underscores.
-    var normalizedModuleName = chooseModuleName(requirejs._eak_seen, moduleName);
+    var normalizedModuleName = chooseModuleName(moduleEntries, moduleName);
 
-    if (requirejs._eak_seen[normalizedModuleName]) {
+    if (moduleEntries[normalizedModuleName]) {
       var module = require(normalizedModuleName, null, null, true /* force sync */);
 
       if (module && module['default']) { module = module['default']; }
@@ -125,24 +163,66 @@ define("resolver",
         module = classFactory(module);
       }
 
-      if (Ember.ENV.LOG_MODULE_RESOLVER) {
-        Ember.Logger.info('[✓]', parsedName.fullName, new Array(40 - parsedName.fullName.length).join('.'), moduleName);
-      }
+      logLookup(true, parsedName, moduleName);
 
       return module;
     } else {
-      if (Ember.ENV.LOG_MODULE_RESOLVER) {
-        Ember.Logger.info('[ ]', parsedName.fullName, new Array(40 - parsedName.fullName.length).join('.'), moduleName);
-      }
+      logLookup(false, parsedName, moduleName);
+
       return this._super(parsedName);
     }
   }
   // Ember.DefaultResolver docs:
   //   https://github.com/emberjs/ember.js/blob/master/packages/ember-application/lib/system/resolver.js
   var Resolver = Ember.DefaultResolver.extend({
-    resolveTemplate: resolveOther,
     resolveOther: resolveOther,
-    resolveRouter: resolveRouter,
+    resolveTemplate: resolveOther,
+  /**
+    This method is called via the container's resolver method.
+    It parses the provided `fullName` and then looks up and
+    returns the appropriate template or class.
+
+    @method resolve
+    @param {String} fullName the lookup string
+    @return {Object} the resolved factory
+  */
+  resolve: function(fullName) {
+    var parsedName = this.parseName(fullName),
+        resolveMethodName = parsedName.resolveMethodName;
+
+    if (!(parsedName.name && parsedName.type)) {
+      throw new TypeError("Invalid fullName: `" + fullName + "`, must be of the form `type:name` ");
+    }
+
+    if (this[resolveMethodName]) {
+      var resolved = this[resolveMethodName](parsedName);
+      if (resolved) { return resolved; }
+    }
+    return this.resolveOther(parsedName);
+  },
+  /**
+    Returns a human-readable description for a fullName. Used by the
+    Application namespace in assertions to describe the
+    precise name of the class that Ember is looking for, rather than
+    container keys.
+
+    @protected
+    @param {String} fullName the lookup string
+    @method lookupDescription
+  */
+  lookupDescription: function(fullName) {
+    var parsedName = this.parseName(fullName);
+
+    if (parsedName.type === 'template') {
+      return "template at " + parsedName.fullNameWithoutType.replace(/\./g, '/');
+    }
+
+    var description = parsedName.root + "." + classify(parsedName.name);
+    if (parsedName.type !== 'model') { description += classify(parsedName.type); }
+
+    return description;
+  },
+
     makeToString: function(factory, fullName) {
       return '' + this.namespace.modulePrefix + '@' + fullName + ':';
     },
@@ -168,6 +248,129 @@ define("resolver",
   return Resolver;
 });
 
+define("resolver",
+  ["ember/resolver"],
+  function (Resolver) {
+    Ember.deprecate('Importing/requiring Ember Resolver as "resolver" is deprecated, please use "ember/resolver" instead');
+    return Resolver;
+  });
+
+})();
+
+
+
+(function() {
+/*globals define registry requirejs */
+
+define("ember/container-debug-adapter",
+  [],
+  function() {
+    "use strict";
+
+  // Support Ember < 1.5-beta.4
+  // TODO: Remove this after 1.5.0 is released
+  if (typeof Ember.ContainerDebugAdapter === 'undefined') {
+    return null;
+  }
+  /*
+   * This module defines a subclass of Ember.ContainerDebugAdapter that adds two
+   * important features:
+   *
+   *  1) is able provide injections to classes that implement `extend`
+   *     (as is typical with Ember).
+   */
+
+  var ContainerDebugAdapter = Ember.ContainerDebugAdapter.extend({
+    /**
+      The container of the application being debugged.
+      This property will be injected
+      on creation.
+
+      @property container
+      @default null
+    */
+    // container: null, LIVES IN PARENT
+
+    /**
+      The resolver instance of the application
+      being debugged. This property will be injected
+      on creation.
+
+      @property resolver
+      @default null
+    */
+    // resolver: null,  LIVES IN PARENT
+    /**
+      Returns true if it is possible to catalog a list of available
+      classes in the resolver for a given type.
+
+      @method canCatalogEntriesByType
+      @param {string} type The type. e.g. "model", "controller", "route"
+      @return {boolean} whether a list is available for this type.
+    */
+    canCatalogEntriesByType: function(type) {
+      return true;
+    },
+
+    /**
+      Returns the available classes a given type.
+
+      @method catalogEntriesByType
+      @param {string} type The type. e.g. "model", "controller", "route"
+      @return {Array} An array of classes.
+    */
+    catalogEntriesByType: function(type) {
+      var entries = requirejs.entries,
+          module,
+          types = Ember.A();
+
+      var makeToString = function(){
+        return this.shortname;
+      };
+
+      for(var key in entries) {
+        if(entries.hasOwnProperty(key) && key.indexOf(type) !== -1)
+        {
+          // // TODO return the name instead of the module itself
+          // module = require(key, null, null, true);
+
+          // if (module && module['default']) { module = module['default']; }
+          // module.shortname = key.split(type +'s/').pop();
+          // module.toString = makeToString;
+
+          // types.push(module);
+          types.push(key.split(type +'s/').pop());
+        }
+      }
+
+      return types;
+    }
+  });
+
+  ContainerDebugAdapter['default'] = ContainerDebugAdapter;
+  return ContainerDebugAdapter;
+});
+
+})();
+
+
+
+(function() {
+(function() {
+  "use strict";
+
+  Ember.Application.initializer({
+    name: 'container-debug-adapter',
+
+    initialize: function(container) {
+      var ContainerDebugAdapter = require('ember/container-debug-adapter');
+      var Resolver = require('ember/resolver');
+
+      container.register('container-debug-adapter:main', ContainerDebugAdapter);
+    }
+  });
+}());
+
 })();