language stringclasses 1 value | owner stringlengths 2 15 | repo stringlengths 2 21 | sha stringlengths 45 45 | message stringlengths 7 36.3k | path stringlengths 1 199 | patch stringlengths 15 102k | is_multipart bool 2 classes |
|---|---|---|---|---|---|---|---|
Other | emberjs | ember.js | 49730043e687a1d789d90246e375b0712199a8fe.json | Add 2.7.0-beta.1 to CHANGELOG.
[ci skip] | CHANGELOG.md | @@ -1,5 +1,10 @@
# Ember Changelog
+### 2.7.0-beta.1 (June 8, 2016)
+
+- [#13424](https://github.com/emberjs/ember.js/pull/13424) [DEPRECATE] Deprecate Ember.Binding. See [the deprecation guide](http://emberjs.com/deprecations/v2.x/#toc_ember-binding) for more details.
+- [#13599](https://github.com/emberjs/ember.js/pull/13599) [FEATURE] Enable `ember-runtime-computed-uniq-by` feature.
+
### 2.6.0 (June 8, 2016)
- [#13520](https://github.com/emberjs/ember.js/pull/13520) [BUGFIX] Fixes issues with `baseURL` and `rootURL` in `Ember.HistoryLocation` and ensures that `Ember.NoneLocation` properly handles `rootURL`. | false |
Other | emberjs | ember.js | 7b226e94b3fa2ca2bef57ff8720acdd195a38e6a.json | Add 2.6.0 to CHANGELOG.
[ci skip]
(cherry picked from commit df81b93bb14ecbae46fbc14862941d78df036ebe) | CHANGELOG.md | @@ -1,22 +1,18 @@
# Ember Changelog
-### 2.6.0-beta.4 (May 09, 2016)
+### 2.6.0 (June 8, 2016)
+- [#13520](https://github.com/emberjs/ember.js/pull/13520) [BUGFIX] Fixes issues with `baseURL` and `rootURL` in `Ember.HistoryLocation` and ensures that `Ember.NoneLocation` properly handles `rootURL`.
+- [#13590](https://github.com/emberjs/ember.js/pull/13590) [BUGFIX] Avoid `_lazyInjections` in production builds.
- [#13442](https://github.com/emberjs/ember.js/pull/13442) [BUGFIX] Revert `Ember.Handlebars.SafeString` deprecation.
- [#13449](https://github.com/emberjs/ember.js/pull/13449) [BUGFIX] Ensure that `Ember.get(null, 'foo')` returns `undefined`.
- [#13465](https://github.com/emberjs/ember.js/pull/13465) [BUGFIX] Propagate loc information for inline link-to transform.
- [#13461](https://github.com/emberjs/ember.js/pull/13461) [BUGFIX] Prevent `Ember.get` from attempting to retrieve properties on primitive objects.
-
-### 2.6.0-beta.3 (May 02, 2016)
-
- [#13418](https://github.com/emberjs/ember.js/pull/13418) [BUGFIX] Ensure that passing `run.later` a timeout value of `NaN` does not break all future
timers.
- [#13435](https://github.com/emberjs/ember.js/pull/13435) [BUGFIX] Fix positional parameters when used with component helper.
- [#13438](https://github.com/emberjs/ember.js/pull/13438) [BUGFIX] Ensure custom components extending from `Ember.LinkComponent` can operate
in both block and inline form.
-
-### 2.6.0-beta.2 (April 27, 2016)
-
- [#13356](https://github.com/emberjs/ember.js/pull/13356) [BUGFIX] Update `Registry#has` to always return true/false.
- [#13359](https://github.com/emberjs/ember.js/pull/13359) [BUGFIX] Fix `{{if}}` and `{{unless}}` subexpression sometimes not updating.
- [#13344](https://github.com/emberjs/ember.js/pull/13344) [BUGFIX] Revert `Ember.merge` deprecation.
@@ -29,9 +25,6 @@
- [#13315](https://github.com/emberjs/ember.js/pull/13315) [CLEANUP] Remove legacy view related exports.
- [#13310](https://github.com/emberjs/ember.js/pull/13310) [BUGFIX] Fix `mouseenter` typo in ember-testing helpers.
- [#13314](https://github.com/emberjs/ember.js/pull/13314) [CLEANUP] Remove Metamorph view and mixin.
-
-### 2.6.0-beta.1 (April 11, 2016)
-
- [#13144](https://github.com/emberjs/ember.js/pull/13144) / [#13195](https://github.com/emberjs/ember.js/pull/13195) / [#13193](https://github.com/emberjs/ember.js/pull/13193) [CLEANUP] Remove support for `ember-legacy-views` addon.
- [#13192](https://github.com/emberjs/ember.js/pull/13192) [CLEANUP] Remove support for `ember-legacy-controllers` addon.
- [#13295](https://github.com/emberjs/ember.js/pull/13295) [CLEANUP] Disable `render` helper in block form. | false |
Other | emberjs | ember.js | dc4b60be5849a6dad2cc464822294a435e08e31c.json | Fix master build failures (#13606) | package.json | @@ -37,7 +37,7 @@
"express": "^4.5.0",
"finalhandler": "^0.4.0",
"github": "^0.2.3",
- "glimmer-engine": "tildeio/glimmer#525e75e",
+ "glimmer-engine": "tildeio/glimmer#bf8213",
"glob": "^5.0.13",
"htmlbars": "0.14.23",
"mocha": "^2.4.5", | false |
Other | emberjs | ember.js | 78cea046e4ca01a068ae5701cd835357584327ff.json | Add lazy evaluation tests (#13596)
In both `{{#if truthy}}...{{else}}{{some-helper}}{{/if}}` and `{{if
truthy ... (some-helper)}}`, `some-helper` should NOT be evaluated.
This is especially important when you are trying to use the `if`
helper to guard for `null`s etc.
They already works in Glimmer. The block form works in HTMLBars, but
not the inline form.
See #13589 | packages/ember-glimmer/tests/utils/shared-conditional-tests.js | @@ -605,6 +605,59 @@ export class TogglingHelperConditionalsTest extends TogglingConditionalsTest {
this.assertText('T1');
}
+ ['@glimmer evaluation should be lazy'](assert) {
+ let truthyEvaluated;
+ let falsyEvaluated;
+
+ let withoutEvaluatingTruthy = (callback) => {
+ truthyEvaluated = false;
+ callback();
+ assert.ok(!truthyEvaluated, 'x-truthy is not evaluated');
+ };
+
+ let withoutEvaluatingFalsy = (callback) => {
+ falsyEvaluated = false;
+ callback();
+ assert.ok(!falsyEvaluated, 'x-falsy is not evaluated');
+ };
+
+ this.registerHelper('x-truthy', {
+ compute() {
+ truthyEvaluated = true;
+ return 'T';
+ }
+ });
+
+ this.registerHelper('x-falsy', {
+ compute() {
+ falsyEvaluated = true;
+ return 'F';
+ }
+ });
+
+ let template = this.wrappedTemplateFor({ cond: 'cond', truthy: '(x-truthy)', falsy: '(x-falsy)' });
+
+ withoutEvaluatingFalsy(() => this.render(template, { cond: this.truthyValue }));
+
+ this.assertText('T');
+
+ withoutEvaluatingFalsy(() => this.runTask(() => this.rerender()));
+
+ this.assertText('T');
+
+ withoutEvaluatingTruthy(() => this.runTask(() => set(this.context, 'cond', this.falsyValue)));
+
+ this.assertText('F');
+
+ withoutEvaluatingTruthy(() => this.runTask(() => this.rerender()));
+
+ this.assertText('F');
+
+ withoutEvaluatingFalsy(() => this.runTask(() => set(this.context, 'cond', this.truthyValue)));
+
+ this.assertText('T');
+ }
+
}
export const SyntaxCondtionalTestHelpers = {
@@ -812,6 +865,59 @@ export class TogglingSyntaxConditionalsTest extends TogglingConditionalsTest {
this.assertText('');
}
+ ['@test evaluation should be lazy'](assert) {
+ let truthyEvaluated;
+ let falsyEvaluated;
+
+ let withoutEvaluatingTruthy = (callback) => {
+ truthyEvaluated = false;
+ callback();
+ assert.ok(!truthyEvaluated, 'x-truthy is not evaluated');
+ };
+
+ let withoutEvaluatingFalsy = (callback) => {
+ falsyEvaluated = false;
+ callback();
+ assert.ok(!falsyEvaluated, 'x-falsy is not evaluated');
+ };
+
+ this.registerHelper('x-truthy', {
+ compute() {
+ truthyEvaluated = true;
+ return 'T';
+ }
+ });
+
+ this.registerHelper('x-falsy', {
+ compute() {
+ falsyEvaluated = true;
+ return 'F';
+ }
+ });
+
+ let template = this.wrappedTemplateFor({ cond: 'cond', truthy: '{{x-truthy}}', falsy: '{{x-falsy}}' });
+
+ withoutEvaluatingFalsy(() => this.render(template, { cond: this.truthyValue }));
+
+ this.assertText('T');
+
+ withoutEvaluatingFalsy(() => this.runTask(() => this.rerender()));
+
+ this.assertText('T');
+
+ withoutEvaluatingTruthy(() => this.runTask(() => set(this.context, 'cond', this.falsyValue)));
+
+ this.assertText('F');
+
+ withoutEvaluatingTruthy(() => this.runTask(() => this.rerender()));
+
+ this.assertText('F');
+
+ withoutEvaluatingFalsy(() => this.runTask(() => set(this.context, 'cond', this.truthyValue)));
+
+ this.assertText('T');
+ }
+
}
applyMixins(TogglingSyntaxConditionalsTest, SyntaxCondtionalTestHelpers); | false |
Other | emberjs | ember.js | 44a299b5cc777acdaf65a2035a950186bb7a7be2.json | Remove view tests (#13579)
These tests either test a view specific feature, or already have test
coverage in the analogous controller/template feature. | packages/ember/tests/routing/basic_test.js | @@ -321,90 +321,6 @@ QUnit.test('Model passed via renderTemplate model is set as controller\'s model'
equal(jQuery('p:contains(emberjs)', '#qunit-fixture').length, 1, 'Passed model was set as controllers model');
});
-test('Renders correct view with slash notation', function() {
- setTemplate('home/page', compile('<p>{{view.name}}</p>'));
-
- Router.map(function() {
- this.route('home', { path: '/' });
- });
-
- App.HomeRoute = Route.extend({
- renderTemplate() {
- this.render('home/page');
- }
- });
-
- App.HomePageView = EmberView.extend({
- name: 'Home/Page'
- });
-
- bootApplication();
-
- equal(jQuery('p:contains(Home/Page)', '#qunit-fixture').length, 1, 'The homepage template was rendered');
-});
-
-test('Renders the view given in the view option', function() {
- setTemplate('home', compile('<p>{{view.name}}</p>'));
-
- Router.map(function() {
- this.route('home', { path: '/' });
- });
-
- App.HomeRoute = Route.extend({
- renderTemplate() {
- this.render({ view: 'homePage' });
- }
- });
-
- App.HomePageView = EmberView.extend({
- name: 'Home/Page'
- });
-
- bootApplication();
-
- equal(jQuery('p:contains(Home/Page)', '#qunit-fixture').length, 1, 'The homepage view was rendered');
-});
-
-test('render does not replace templateName if user provided', function() {
- Router.map(function() {
- this.route('home', { path: '/' });
- });
-
- setTemplate('the_real_home_template', compile(
- '<p>THIS IS THE REAL HOME</p>'
- ));
-
- App.HomeView = EmberView.extend({
- templateName: 'the_real_home_template'
- });
- App.HomeController = Controller.extend();
- App.HomeRoute = Route.extend();
-
- bootApplication();
-
- equal(jQuery('p', '#qunit-fixture').text(), 'THIS IS THE REAL HOME', 'The homepage template was rendered');
-});
-
-test('render does not replace template if user provided', function () {
- Router.map(function () {
- this.route('home', { path: '/' });
- });
-
- App.HomeView = EmberView.extend({
- template: compile('<p>THIS IS THE REAL HOME</p>')
- });
- App.HomeController = Controller.extend();
- App.HomeRoute = Route.extend();
-
- bootApplication();
-
- run(function () {
- router.handleURL('/');
- });
-
- equal(jQuery('p', '#qunit-fixture').text(), 'THIS IS THE REAL HOME', 'The homepage template was rendered');
-});
-
QUnit.test('render uses templateName from route', function() {
Router.map(function() {
this.route('home', { path: '/' }); | false |
Other | emberjs | ember.js | 370d02598e3543b0062db6c56226a394827a2859.json | Remove obsolete Rakefile | Rakefile | @@ -1,159 +0,0 @@
-require 'bundler/setup'
-require './lib/ember/version'
-require 'zlib'
-require 'fileutils'
-require 'pathname'
-require 'json'
-
-### RELEASE TASKS ###
-
-namespace :release do
-
- def pretend?
- ENV['PRETEND']
- end
-
- task :gem do
- sh 'npm run-script build'
- sh 'gem build ember-source.gemspec'
- sh "gem push ember-source-#{Ember::VERSION.gsub('-','.')}.gem"
- end
-
- namespace :starter_kit do
- ember_output = "tmp/starter-kit/js/libs/ember-#{Ember::VERSION}.js"
-
- task :pull => "tmp/starter-kit" do
- cd("tmp/starter-kit") do
- sh "git pull origin master"
- end
- end
-
- task :clean => :pull do
- cd("tmp/starter-kit") do
- rm_rf Dir["js/libs/ember*.js"]
- end
- end
-
- file "dist/ember.js" => :dist
- file "dist/ember.min.js" => :dist
-
- task "dist/starter-kit.#{Ember::VERSION}.zip" => ["tmp/starter-kit/index.html"] do
- mkdir_p "dist"
-
- cd("tmp") do
- sh %{zip -r ../dist/starter-kit.#{Ember::VERSION}.zip starter-kit -x "starter-kit/.git/*"}
- end
- end
-
- file ember_output => [:clean, "tmp/starter-kit", "dist/ember.js"] do
- sh "cp dist/ember.js #{ember_output}"
- end
-
- file "tmp/starter-kit" do
- mkdir_p "tmp"
-
- cd("tmp") do
- sh "git clone git@github.com:emberjs/starter-kit.git"
- end
- end
-
- file "tmp/starter-kit/index.html" => [ember_output] do
- index = File.read("tmp/starter-kit/index.html")
- index.gsub! %r{<script src="js/libs/ember-\d\.\d.*</script>},
- %{<script src="js/libs/ember-#{Ember::VERSION}.js"></script>}
-
- open("tmp/starter-kit/index.html", "w") { |f| f.write index }
- end
-
- task :index => "tmp/starter-kit/index.html"
-
- desc "Update starter-kit repo"
- task :update => :index do
- puts "Updating starter-kit repo"
- unless pretend?
- cd("tmp/starter-kit") do
- sh "git add -A"
- sh "git commit -m 'Updated to #{Ember::VERSION}'"
- sh "git tag v#{Ember::VERSION}"
-
- print "Are you sure you want to push the starter-kit repo to github? (y/N) "
- res = STDIN.gets.chomp
- if res == 'y'
- sh "git push origin master"
- sh "git push --tags"
- else
- puts "Not pushing"
- end
- end
- end
- end
-
- desc "Build the Ember.js starter kit"
- task :build => "dist/starter-kit.#{Ember::VERSION}.zip"
-
- desc "Prepare starter-kit for release"
- task :prepare => [:clean, :build]
-
- desc "Release starter-kit"
- task :deploy => [:build, :update]
- end
-
- namespace :website do
- file "tmp/website" do
- mkdir_p "tmp"
-
- cd("tmp") do
- sh "git clone https://github.com/emberjs/website.git"
- end
- end
-
- task :pull => "tmp/website" do
- cd("tmp/website") do
- sh "git pull origin master"
- end
- end
-
- task :about => [:pull, :dist] do
- about = File.read("tmp/website/source/about.html.erb")
- min_gz = Zlib::Deflate.deflate(File.read("dist/ember.min.js")).bytes.count / 1024
-
- about.gsub!(/(\d+\.\d+\.\d+-rc(?:\.?\d+)?)/, Ember::VERSION)
- about.gsub!(/min \+ gzip \d+kb/, "min + gzip #{min_gz}kb")
-
- open("tmp/website/source/about.html.erb", "w") { |f| f.write about }
- end
-
- desc "Update website repo"
- task :update => :about do
- puts "Updating website repo"
- unless pretend?
- cd("tmp/website") do
- sh "git add -A"
- sh "git commit -m 'Updated to #{Ember::VERSION}'"
-
- print "Are you sure you want to push the website repo to github? (y/N) "
- res = STDIN.gets.chomp
- if res == 'y'
- sh "git push origin master"
- sh "git push --tags"
- else
- puts "Not pushing"
- end
- end
- puts "NOTE: You still need to run `rake deploy` from within the website repo."
- end
- end
-
- desc "Prepare website for release"
- task :prepare => [:about]
-
- desc "Update website repo"
- task :deploy => [:update]
- end
-
- desc "Prepare Ember for new release"
- task :prepare => ['ember:clean', 'ember:release:prepare', 'starter_kit:prepare', 'website:prepare']
-
- desc "Deploy a new Ember release"
- task :deploy => ['ember:release:deploy', 'starter_kit:deploy', 'website:deploy']
-end | false |
Other | emberjs | ember.js | 0c64d88ba1fb8afcafca38317605fe8e19cda035.json | Fix failure in master.
Due to name change that caused a PR's green status to be a lie. | packages/ember-glimmer/lib/environment.js | @@ -148,7 +148,7 @@ export default class Environment extends GlimmerEnvironment {
if (mappedKey !== key) {
path = path.map((segment) => segment === key ? mappedKey : segment);
}
- let definition = this.getComponentDefinition(path);
+ let definition = this.createComponentDefinition(path, isBlock);
wrapClassBindingAttribute(args);
wrapClassAttribute(args);
return new CurlyComponentSyntax({ args, definition, templates }); | false |
Other | emberjs | ember.js | 9a72fea4854f1a12dbd81b7779afd77f99331b7e.json | fix import path | packages/ember-glimmer/tests/integration/helpers/closure-action-test.js | @@ -2,7 +2,7 @@ import run from 'ember-metal/run_loop';
import { computed } from 'ember-metal/computed';
import isEnabled from 'ember-metal/features';
import { subscribe, unsubscribe } from 'ember-metal/instrumentation';
-import { INVOKE } from 'ember-routing-htmlbars/keywords/closure-action';
+import { INVOKE } from 'ember-htmlbars/keywords/closure-action';
import { RenderingTest, moduleFor } from '../../utils/test-case';
import { Component } from '../../utils/helpers';
| false |
Other | emberjs | ember.js | 81884e31f9a6007719a42ba71e84cf2c1cce41ef.json | Enforce child outlets to be fragments. (#13521)
Enforce child outlets to be fragments fixes crash when a outlet was filled with a element, and emitted a did-create-element after the args register had already be changed.
Remove unneeded setOutletState rerender workaround.
Add regression test for did-create-element opcode crash. | packages/ember-glimmer/lib/syntax/outlet.js | @@ -179,7 +179,7 @@ class OutletComponentDefinition extends AbstractOutletComponentDefinition {
}
compile(builder) {
- builder.fromLayout(this.template.asLayout());
+ builder.wrapLayout(this.template.asLayout());
}
}
| true |
Other | emberjs | ember.js | 81884e31f9a6007719a42ba71e84cf2c1cce41ef.json | Enforce child outlets to be fragments. (#13521)
Enforce child outlets to be fragments fixes crash when a outlet was filled with a element, and emitted a did-create-element after the args register had already be changed.
Remove unneeded setOutletState rerender workaround.
Add regression test for did-create-element opcode crash. | packages/ember-glimmer/lib/views/outlet.js | @@ -97,7 +97,6 @@ export default class OutletView {
setOutletState(state) {
this.outletState = state;
this._tag.dirty();
- this.rerender(); // FIXME
}
toReference() { | true |
Other | emberjs | ember.js | 81884e31f9a6007719a42ba71e84cf2c1cce41ef.json | Enforce child outlets to be fragments. (#13521)
Enforce child outlets to be fragments fixes crash when a outlet was filled with a element, and emitted a did-create-element after the args register had already be changed.
Remove unneeded setOutletState rerender workaround.
Add regression test for did-create-element opcode crash. | packages/ember-glimmer/tests/integration/application/rendering-test.js | @@ -318,4 +318,15 @@ moduleFor('Application test: rendering', class extends ApplicationTest {
});
}
+ // Regression test, glimmer child outlets tried to assume the first element.
+ // but the if put-args clobbered the args used by did-create-element.
+ // I wish there was a way to assert that the OutletComponentManager did not
+ // receive a didCreateElement.
+ ['@test a child outlet is always a fragment']() {
+ this.registerTemplate('application', '{{outlet}}');
+ this.registerTemplate('index', '{{#if true}}1{{/if}}<div>2</div>');
+ return this.visit('/').then(() => {
+ this.assertComponentElement(this.firstChild, { content: '1<div>2</div>' });
+ });
+ }
}); | true |
Other | emberjs | ember.js | aa79ca71fe04776e1c9f4220f49bf35faf38743a.json | Introduce ENGINE_PARENT symbol.
Access to an engine's parent property should be tightly controlled.
Using a symbol allows for access only via `getEngineParent` and
`setEngineParent`. | packages/ember-application/lib/system/engine-parent.js | @@ -0,0 +1,33 @@
+/**
+@module ember
+@submodule ember-application
+*/
+
+import symbol from 'ember-metal/symbol';
+
+export const ENGINE_PARENT = symbol('ENGINE_PARENT');
+
+/**
+ `getEngineParent` retrieves an engine instance's parent instance.
+
+ @method getEngineParent
+ @param {EngineInstance} engine An engine instance.
+ @return {EngineInstance} The parent engine instance.
+ @for Ember
+ @public
+*/
+export function getEngineParent(engine) {
+ return engine[ENGINE_PARENT];
+}
+
+/**
+ `setEngineParent` sets an engine instance's parent instance.
+
+ @method setEngineParent
+ @param {EngineInstance} engine An engine instance.
+ @param {EngineInstance} parent The parent engine instance.
+ @private
+*/
+export function setEngineParent(engine, parent) {
+ engine[ENGINE_PARENT] = parent;
+} | true |
Other | emberjs | ember.js | aa79ca71fe04776e1c9f4220f49bf35faf38743a.json | Introduce ENGINE_PARENT symbol.
Access to an engine's parent property should be tightly controlled.
Using a symbol allows for access only via `getEngineParent` and
`setEngineParent`. | packages/ember-application/tests/system/engine_parent_test.js | @@ -0,0 +1,16 @@
+import { getEngineParent, setEngineParent, ENGINE_PARENT } from 'ember-application/system/engine-parent';
+
+QUnit.module('EngineParent', {});
+
+QUnit.test('An engine\'s parent can be set with `setEngineParent` and retrieved with `getEngineParent`', function() {
+ let engine = {};
+ let parent = {};
+
+ strictEqual(getEngineParent(engine), undefined, 'parent has not been set');
+
+ setEngineParent(engine, parent);
+
+ strictEqual(getEngineParent(engine), parent, 'parent has been set');
+
+ strictEqual(engine[ENGINE_PARENT], parent, 'parent has been set to the ENGINE_PARENT symbol');
+}); | true |
Other | emberjs | ember.js | c79eda2425ace1667c9b541ec6a4bcd1e8ef2fd5.json | Fix tests on master (#13511) | packages/ember-application/tests/system/engine_initializers_test.js | @@ -319,12 +319,12 @@ QUnit.test('initializers are per-engine', function() {
initialize(engine) {}
});
- throws(function() {
+ expectAssertion(function() {
FirstEngine.initializer({
name: 'abc',
initialize(engine) {}
});
- }, Error, /Assertion Failed: The initializer 'abc' has already been registered'/);
+ });
let SecondEngine = Engine.extend();
SecondEngine.instanceInitializer({ | true |
Other | emberjs | ember.js | c79eda2425ace1667c9b541ec6a4bcd1e8ef2fd5.json | Fix tests on master (#13511) | packages/ember-application/tests/system/engine_instance_initializers_test.js | @@ -341,12 +341,12 @@ QUnit.test('initializers are per-engine', function() {
initialize(engine) {}
});
- throws(function() {
+ expectAssertion(function() {
FirstEngine.instanceInitializer({
name: 'abc',
initialize(engine) {}
});
- }, Error, /Assertion Failed: The instance initializer 'abc' has already been registered'/);
+ });
let SecondEngine = Engine.extend();
SecondEngine.instanceInitializer({ | true |
Other | emberjs | ember.js | c79eda2425ace1667c9b541ec6a4bcd1e8ef2fd5.json | Fix tests on master (#13511) | packages/ember-application/tests/system/initializers_test.js | @@ -358,12 +358,12 @@ QUnit.test('initializers are per-app', function() {
initialize(app) {}
});
- throws(function() {
+ expectAssertion(function() {
FirstApp.initializer({
name: 'abc',
initialize(app) {}
});
- }, Error, /Assertion Failed: The initializer 'abc' has already been registered'/);
+ });
let SecondApp = Application.extend();
SecondApp.instanceInitializer({ | true |
Other | emberjs | ember.js | c79eda2425ace1667c9b541ec6a4bcd1e8ef2fd5.json | Fix tests on master (#13511) | packages/ember-application/tests/system/instance_initializers_test.js | @@ -327,12 +327,12 @@ QUnit.test('initializers are per-app', function() {
initialize(app) {}
});
- throws(function() {
+ expectAssertion(function() {
FirstApp.instanceInitializer({
name: 'abc',
initialize(app) {}
});
- }, Error, /Assertion Failed: The instance initializer 'abc' has already been registered'/);
+ });
let SecondApp = Application.extend();
SecondApp.instanceInitializer({ | true |
Other | emberjs | ember.js | 9471527454b30b9a892d6d40f21735365b5a2897.json | Reorganize metal to support 2WB in Glimmer
This commit restructures some of the more arcane parts of ember-metal's
observer system.
It eliminates some special casing around `length`, which isn't necessary
anymore but complicates the overall abstraction of observable
properties.
Relatedly, it also finishes implementing PROPERTY_DID_CHANGE, which now
executes reliably any time an observer would have fired. You can think
of it as an always-on observer if it's present on an object. Glimmer 2
curly components use this hook to propagate `set`s on components back to
their original bindings (if the bindings are present).
This commit also implements two way bindings in Glimmer 2, by making
PropertyReferences implement an `UPDATE` method. If that method is
present, it is used to propagate changes upwards (otherwise, an
exception is thrown). | packages/ember-glimmer/lib/component.js | @@ -7,9 +7,14 @@ import AriaRoleSupport from 'ember-views/mixins/aria_role_support';
import ViewMixin from 'ember-views/mixins/view_support';
import EmberView from 'ember-views/views/view';
import symbol from 'ember-metal/symbol';
+import { get } from 'ember-metal/property_get';
+import { PROPERTY_DID_CHANGE } from 'ember-metal/property_events';
+import { UPDATE } from './utils/references';
import { DirtyableTag } from 'glimmer-reference';
export const DIRTY_TAG = symbol('DIRTY_TAG');
+export const ARGS = symbol('ARGS');
+export const IS_DISPATCHING_ATTRS = symbol('IS_DISPATCHING_ATTRS');
export default CoreView.extend(
ChildViewsSupport,
@@ -36,5 +41,36 @@ export default CoreView.extend(
__defineNonEnumerable(property) {
this[property.name] = property.descriptor.value;
+ },
+
+ [IS_DISPATCHING_ATTRS]: false,
+
+ [PROPERTY_DID_CHANGE](key) {
+ if (this[IS_DISPATCHING_ATTRS]) { return; }
+
+ let args, reference;
+
+ if ((args = this[ARGS]) && (reference = args[key])) {
+ if (reference[UPDATE]) {
+ reference[UPDATE](get(this, key));
+ } else {
+ let name = this._debugContainerKey.split(':')[1];
+ let value = get(this, key);
+ throw new Error(strip`
+Cannot set the \`${key}\` property (on component ${name}) to
+\`${value}\`. The \`${key}\` property came from an immutable
+binding in the template, such as {{${name} ${key}="string"}}
+or {{${name} ${key}=(if theTruth "truth" "false")}}.
+ `);
+ }
+ }
}
});
+
+function strip([...strings], ...values) {
+ let str = strings.map((string, index) => {
+ let interpolated = values[index];
+ return string + (interpolated !== undefined ? interpolated : '');
+ }).join('');
+ return str.split('\n').map(s => s.trim()).join(' ');
+} | true |
Other | emberjs | ember.js | 9471527454b30b9a892d6d40f21735365b5a2897.json | Reorganize metal to support 2WB in Glimmer
This commit restructures some of the more arcane parts of ember-metal's
observer system.
It eliminates some special casing around `length`, which isn't necessary
anymore but complicates the overall abstraction of observable
properties.
Relatedly, it also finishes implementing PROPERTY_DID_CHANGE, which now
executes reliably any time an observer would have fired. You can think
of it as an always-on observer if it's present on an object. Glimmer 2
curly components use this hook to propagate `set`s on components back to
their original bindings (if the bindings are present).
This commit also implements two way bindings in Glimmer 2, by making
PropertyReferences implement an `UPDATE` method. If that method is
present, it is used to propagate changes upwards (otherwise, an
exception is thrown). | packages/ember-glimmer/lib/syntax/curly-component.js | @@ -1,7 +1,10 @@
import { StatementSyntax, ValueReference } from 'glimmer-runtime';
import { AttributeBindingReference, RootReference, applyClassNameBinding } from '../utils/references';
-import { DIRTY_TAG } from '../component';
+import { DIRTY_TAG, IS_DISPATCHING_ATTRS } from '../component';
import { assert } from 'ember-metal/debug';
+import isEnabled from 'ember-metal/features';
+import { meta as metaFor } from 'ember-metal/meta';
+import { watchKey } from 'ember-metal/watch_key';
import processArgs from '../utils/process-args';
function aliasIdToElementId(args, props) {
@@ -48,6 +51,16 @@ class CurlyComponentManager {
let component = klass.create(props);
+ if (isEnabled('mandatory-setter')) {
+ let meta = metaFor(component);
+ let keys = Object.keys(props);
+
+ for (let i = 0; i < keys.length; i++) {
+ // Watching a key triggers Ember to install the mandatory setter
+ watchKey(component, keys[i], meta);
+ }
+ }
+
dynamicScope.view = component;
parentView.appendChild(component);
@@ -146,7 +159,9 @@ class CurlyComponentManager {
let oldAttrs = component.attrs;
let newAttrs = attrs;
+ component[IS_DISPATCHING_ATTRS] = true;
component.setProperties(props);
+ component[IS_DISPATCHING_ATTRS] = false;
component.trigger('didUpdateAttrs', { oldAttrs, newAttrs });
component.trigger('didReceiveAttrs', { oldAttrs, newAttrs }); | true |
Other | emberjs | ember.js | 9471527454b30b9a892d6d40f21735365b5a2897.json | Reorganize metal to support 2WB in Glimmer
This commit restructures some of the more arcane parts of ember-metal's
observer system.
It eliminates some special casing around `length`, which isn't necessary
anymore but complicates the overall abstraction of observable
properties.
Relatedly, it also finishes implementing PROPERTY_DID_CHANGE, which now
executes reliably any time an observer would have fired. You can think
of it as an always-on observer if it's present on an object. Glimmer 2
curly components use this hook to propagate `set`s on components back to
their original bindings (if the bindings are present).
This commit also implements two way bindings in Glimmer 2, by making
PropertyReferences implement an `UPDATE` method. If that method is
present, it is used to propagate changes upwards (otherwise, an
exception is thrown). | packages/ember-glimmer/lib/utils/process-args.js | @@ -1,6 +1,7 @@
import { CONSTANT_TAG } from 'glimmer-reference';
import { assert } from 'ember-metal/debug';
import EmptyObject from 'ember-metal/empty_object';
+import { ARGS } from '../component';
export default function processArgs(args, positionalParamsDefinition) {
if (!positionalParamsDefinition || positionalParamsDefinition.length === 0 || args.positional.length === 0) {
@@ -16,7 +17,7 @@ const EMPTY_ARGS = {
tag: CONSTANT_TAG,
value() {
- return { attrs: {}, props: { attrs: {} } };
+ return { attrs: {}, props: { attrs: {}, [ARGS]: {} } };
}
};
@@ -39,13 +40,16 @@ class SimpleArgs {
let keys = namedArgs.keys;
let attrs = namedArgs.value();
let props = new EmptyObject();
+ let args = new EmptyObject();
props.attrs = attrs;
+ props[ARGS] = args;
for (let i = 0, l = keys.length; i < l; i++) {
let name = keys[i];
let value = attrs[name];
+ args[name] = namedArgs.get(name);
props[name] = value;
}
@@ -72,6 +76,7 @@ class RestArgs {
let result = simpleArgs.value();
+ result.props[ARGS] = positionalArgs;
result.attrs[restArgName] = result.props[restArgName] = positionalArgs.value();
return result;
@@ -111,7 +116,8 @@ class PositionalArgs {
for (let i = 0; i < positionalParamNames.length; i++) {
let name = positionalParamNames[i];
- result.attrs[name] = result.props[name] = positionalArgs.at(i).value();
+ let reference = result.props[ARGS][name] = positionalArgs.at(i);
+ result.attrs[name] = result.props[name] = reference.value();
}
return result; | true |
Other | emberjs | ember.js | 9471527454b30b9a892d6d40f21735365b5a2897.json | Reorganize metal to support 2WB in Glimmer
This commit restructures some of the more arcane parts of ember-metal's
observer system.
It eliminates some special casing around `length`, which isn't necessary
anymore but complicates the overall abstraction of observable
properties.
Relatedly, it also finishes implementing PROPERTY_DID_CHANGE, which now
executes reliably any time an observer would have fired. You can think
of it as an always-on observer if it's present on an object. Glimmer 2
curly components use this hook to propagate `set`s on components back to
their original bindings (if the bindings are present).
This commit also implements two way bindings in Glimmer 2, by making
PropertyReferences implement an `UPDATE` method. If that method is
present, it is used to propagate changes upwards (otherwise, an
exception is thrown). | packages/ember-glimmer/lib/utils/references.js | @@ -1,11 +1,15 @@
import { get } from 'ember-metal/property_get';
+import { set } from 'ember-metal/property_set';
import { tagFor } from 'ember-metal/tags';
+import symbol from 'ember-metal/symbol';
import { CURRENT_TAG, CONSTANT_TAG, VOLATILE_TAG, ConstReference, DirtyableTag, UpdatableTag, combine, isConst } from 'glimmer-reference';
import { ConditionalReference as GlimmerConditionalReference, NULL_REFERENCE, UNDEFINED_REFERENCE } from 'glimmer-runtime';
import emberToBool from './to-bool';
import { RECOMPUTE_TAG } from '../helper';
import { dasherize } from 'ember-runtime/system/string';
+export const UPDATE = symbol('UPDATE');
+
// FIXME: fix tests that uses a "fake" proxy (i.e. a POJOs that "happen" to
// have an `isTruthy` property on them). This is not actually supported –
// we should fix the tests to use an actual proxy. When that's done, we should
@@ -97,6 +101,11 @@ class PropertyReference extends CachedReference { // jshint ignore:line
}
}
+ [UPDATE](value) {
+ let parent = this._parentReference.value();
+ set(parent, this._propertyKey, value);
+ }
+
get(propertyKey) {
return new PropertyReference(this, propertyKey);
} | true |
Other | emberjs | ember.js | 9471527454b30b9a892d6d40f21735365b5a2897.json | Reorganize metal to support 2WB in Glimmer
This commit restructures some of the more arcane parts of ember-metal's
observer system.
It eliminates some special casing around `length`, which isn't necessary
anymore but complicates the overall abstraction of observable
properties.
Relatedly, it also finishes implementing PROPERTY_DID_CHANGE, which now
executes reliably any time an observer would have fired. You can think
of it as an always-on observer if it's present on an object. Glimmer 2
curly components use this hook to propagate `set`s on components back to
their original bindings (if the bindings are present).
This commit also implements two way bindings in Glimmer 2, by making
PropertyReferences implement an `UPDATE` method. If that method is
present, it is used to propagate changes upwards (otherwise, an
exception is thrown). | packages/ember-glimmer/tests/integration/components/curly-components-test.js | @@ -1,4 +1,5 @@
/* globals EmberDev */
+import isEnabled from 'ember-metal/features';
import { set } from 'ember-metal/property_set';
import { observer } from 'ember-metal/mixin';
import { Component, compile } from '../../utils/helpers';
@@ -2041,7 +2042,97 @@ moduleFor('Components test: curly components', class extends RenderingTest {
// this.assertText('blarkporybaz- Click Me');
}
- ['@htmlbars a two way binding flows upstream through a CP when consumed in the template']() {
+ ['@glimmer cannot set an immutable argument']() {
+ let component;
+ let FooBarComponent = Component.extend({
+ init() {
+ this._super(...arguments);
+ component = this;
+ }
+ });
+
+ this.registerComponent('foo-bar', {
+ ComponentClass: FooBarComponent,
+
+ template: '{{foo}} – {{bar}}'
+ });
+
+ this.render('{{foo-bar foo="foo" bar=(concat localBar)}}', {
+ localBar: 'bar'
+ });
+
+ this.assertText('foo – bar');
+
+ this.runTask(() => this.rerender());
+
+ this.assertText('foo – bar');
+
+ if (isEnabled('mandatory-setter')) {
+ expectAssertion(() => {
+ component.foo = 'new foo';
+ }, /You must use Ember\.set\(\) to set the `foo` property \(of .+\) to `new foo`\./);
+
+ expectAssertion(() => {
+ component.bar = 'new bar';
+ }, /You must use Ember\.set\(\) to set the `bar` property \(of .+\) to `new bar`\./);
+
+ this.assertText('foo – bar');
+ }
+
+ throws(() => {
+ this.runTask(() => { component.set('foo', 'new foo'); });
+ }, 'Cannot set the `foo` property (on component foo-bar) to `new foo`. The `foo` property came from an immutable binding in the template, such as {{foo-bar foo="string"}} or {{foo-bar foo=(if theTruth "truth" "false")}}.');
+
+ throws(() => {
+ this.runTask(() => { component.set('bar', 'new bar'); });
+ }, 'Cannot set the `bar` property (on component foo-bar) to `new bar`. The `bar` property came from an immutable binding in the template, such as {{foo-bar bar="string"}} or {{foo-bar bar=(if theTruth "truth" "false")}}.');
+
+ this.assertText('foo – bar');
+ }
+
+ ['@test a two way binding flows upstream when consumed in the template']() {
+ let component;
+ let FooBarComponent = Component.extend({
+ init() {
+ this._super(...arguments);
+ component = this;
+ }
+ });
+
+ this.registerComponent('foo-bar', {
+ ComponentClass: FooBarComponent,
+
+ template: '{{bar}}'
+ });
+
+ this.render('{{localBar}} - {{foo-bar bar=localBar}}', {
+ localBar: 'initial value'
+ });
+
+ this.assertText('initial value - initial value');
+
+ this.runTask(() => this.rerender());
+
+ this.assertText('initial value - initial value');
+
+ if (isEnabled('mandatory-setter')) {
+ expectAssertion(() => {
+ component.bar = 'foo-bar';
+ }, /You must use Ember\.set\(\) to set the `bar` property \(of .+\) to `foo-bar`\./);
+
+ this.assertText('initial value - initial value');
+ }
+
+ this.runTask(() => { component.set('bar', 'updated value'); });
+
+ this.assertText('updated value - updated value');
+
+ this.runTask(() => { this.component.set('localBar', 'initial value'); });
+
+ this.assertText('initial value - initial value');
+ }
+
+ ['@test a two way binding flows upstream through a CP when consumed in the template']() {
let component;
let FooBarComponent = Component.extend({
init() {
@@ -2086,8 +2177,7 @@ moduleFor('Components test: curly components', class extends RenderingTest {
this.assertText('initial value - initial value');
}
- // regression introduced in Ember 1.13
- ['@skip a two way binding flows upstream through a CP without template consumption']() {
+ ['@test a two way binding flows upstream through a CP without template consumption']() {
let component;
let FooBarComponent = Component.extend({
init() { | true |
Other | emberjs | ember.js | 9471527454b30b9a892d6d40f21735365b5a2897.json | Reorganize metal to support 2WB in Glimmer
This commit restructures some of the more arcane parts of ember-metal's
observer system.
It eliminates some special casing around `length`, which isn't necessary
anymore but complicates the overall abstraction of observable
properties.
Relatedly, it also finishes implementing PROPERTY_DID_CHANGE, which now
executes reliably any time an observer would have fired. You can think
of it as an always-on observer if it's present on an object. Glimmer 2
curly components use this hook to propagate `set`s on components back to
their original bindings (if the bindings are present).
This commit also implements two way bindings in Glimmer 2, by making
PropertyReferences implement an `UPDATE` method. If that method is
present, it is used to propagate changes upwards (otherwise, an
exception is thrown). | packages/ember-glimmer/tests/integration/content-test.js | @@ -190,6 +190,32 @@ class DynamicContentTest extends RenderingTest {
this.assertInvariants();
}
+ ['@test it can render a computed property with nested dependency']() {
+ let Formatter = EmberObject.extend({
+ formattedMessage: computed('messenger.message', function() {
+ return this.get('messenger.message').toUpperCase();
+ })
+ });
+
+ let m = Formatter.create({ messenger: { message: 'hello' } });
+
+ this.renderPath('m.formattedMessage', { m });
+
+ this.assertContent('HELLO');
+
+ this.assertStableRerender();
+
+ this.runTask(() => set(m, 'messenger.message', 'goodbye'));
+
+ this.assertContent('GOODBYE');
+ this.assertInvariants();
+
+ this.runTask(() => set(this.context, 'm', Formatter.create({ messenger: { message: 'hello' } })));
+
+ this.assertContent('HELLO');
+ this.assertInvariants();
+ }
+
['@test it can read from a null object']() {
let nullObject = Object.create(null);
nullObject['message'] = 'hello'; | true |
Other | emberjs | ember.js | 9471527454b30b9a892d6d40f21735365b5a2897.json | Reorganize metal to support 2WB in Glimmer
This commit restructures some of the more arcane parts of ember-metal's
observer system.
It eliminates some special casing around `length`, which isn't necessary
anymore but complicates the overall abstraction of observable
properties.
Relatedly, it also finishes implementing PROPERTY_DID_CHANGE, which now
executes reliably any time an observer would have fired. You can think
of it as an always-on observer if it's present on an object. Glimmer 2
curly components use this hook to propagate `set`s on components back to
their original bindings (if the bindings are present).
This commit also implements two way bindings in Glimmer 2, by making
PropertyReferences implement an `UPDATE` method. If that method is
present, it is used to propagate changes upwards (otherwise, an
exception is thrown). | packages/ember-metal/lib/chains.js | @@ -334,6 +334,8 @@ ChainNode.prototype = {
}
};
+import { makeChainNode } from './watch_path';
+
export function finishChains(obj) {
// We only create meta if we really have to
let m = peekMeta(obj);
@@ -348,7 +350,7 @@ export function finishChains(obj) {
// ensure that if we have inherited any chains they have been
// copied onto our own meta.
if (m.readableChains()) {
- m.writableChains();
+ m.writableChains(makeChainNode);
}
}
} | true |
Other | emberjs | ember.js | 9471527454b30b9a892d6d40f21735365b5a2897.json | Reorganize metal to support 2WB in Glimmer
This commit restructures some of the more arcane parts of ember-metal's
observer system.
It eliminates some special casing around `length`, which isn't necessary
anymore but complicates the overall abstraction of observable
properties.
Relatedly, it also finishes implementing PROPERTY_DID_CHANGE, which now
executes reliably any time an observer would have fired. You can think
of it as an always-on observer if it's present on an object. Glimmer 2
curly components use this hook to propagate `set`s on components back to
their original bindings (if the bindings are present).
This commit also implements two way bindings in Glimmer 2, by making
PropertyReferences implement an `UPDATE` method. If that method is
present, it is used to propagate changes upwards (otherwise, an
exception is thrown). | packages/ember-metal/lib/computed.js | @@ -416,10 +416,7 @@ ComputedPropertyPrototype._set = function computedPropertySet(obj, keyName, valu
return ret;
}
- let watched = meta.peekWatching(keyName);
- if (watched) {
- propertyWillChange(obj, keyName);
- }
+ propertyWillChange(obj, keyName);
if (hadCachedValue) {
cache[keyName] = undefined;
@@ -435,9 +432,7 @@ ComputedPropertyPrototype._set = function computedPropertySet(obj, keyName, valu
cache[keyName] = ret;
}
- if (watched) {
- propertyDidChange(obj, keyName);
- }
+ propertyDidChange(obj, keyName);
return ret;
}; | true |
Other | emberjs | ember.js | 9471527454b30b9a892d6d40f21735365b5a2897.json | Reorganize metal to support 2WB in Glimmer
This commit restructures some of the more arcane parts of ember-metal's
observer system.
It eliminates some special casing around `length`, which isn't necessary
anymore but complicates the overall abstraction of observable
properties.
Relatedly, it also finishes implementing PROPERTY_DID_CHANGE, which now
executes reliably any time an observer would have fired. You can think
of it as an always-on observer if it's present on an object. Glimmer 2
curly components use this hook to propagate `set`s on components back to
their original bindings (if the bindings are present).
This commit also implements two way bindings in Glimmer 2, by making
PropertyReferences implement an `UPDATE` method. If that method is
present, it is used to propagate changes upwards (otherwise, an
exception is thrown). | packages/ember-metal/lib/meta.js | @@ -2,8 +2,11 @@
// Remove "use strict"; from transpiled module until
// https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
+import isEnabled from 'ember-metal/features';
import { protoMethods as listenerMethods } from 'ember-metal/meta_listeners';
import EmptyObject from 'ember-metal/empty_object';
+import { lookupDescriptor } from 'ember-metal/utils';
+import symbol from 'ember-metal/symbol';
/**
@module ember-metal
@@ -74,6 +77,10 @@ function Meta(obj, parentMeta) {
this._initializeListeners();
}
+Meta.prototype.isInitialized = function(obj) {
+ return this.proto !== obj;
+};
+
for (let name in listenerMethods) {
Meta.prototype[name] = listenerMethods[name];
}
@@ -167,6 +174,7 @@ Meta.prototype._findInherited = function(key, subkey) {
}
};
+export const UNDEFINED = symbol('undefined');
// Implements a member that provides a lazily created map of maps,
// with inheritance at both levels.
@@ -302,6 +310,38 @@ var EMBER_META_PROPERTY = {
descriptor: META_DESC
};
+if (isEnabled('mandatory-setter')) {
+ Meta.prototype.readInheritedValue = function(key, subkey) {
+ let internalKey = `_${key}`;
+
+ let pointer = this;
+
+ while (pointer !== undefined) {
+ let map = pointer[internalKey];
+ if (map) {
+ let value = map[subkey];
+ if (value !== undefined || subkey in map) {
+ return map[subkey];
+ }
+ }
+ pointer = pointer.parent;
+ }
+
+ return UNDEFINED;
+ };
+
+ Meta.prototype.writeValue = function(obj, key, value) {
+ let descriptor = lookupDescriptor(obj, key);
+ let isMandatorySetter = descriptor && descriptor.set && descriptor.set.isMandatorySetter;
+
+ if (isMandatorySetter) {
+ this.writeValues(key, value);
+ } else {
+ obj[key] = value;
+ }
+ };
+}
+
// choose the one appropriate for given platform
let setMeta = function(obj, meta) {
// if `null` already, just set it to the new value | true |
Other | emberjs | ember.js | 9471527454b30b9a892d6d40f21735365b5a2897.json | Reorganize metal to support 2WB in Glimmer
This commit restructures some of the more arcane parts of ember-metal's
observer system.
It eliminates some special casing around `length`, which isn't necessary
anymore but complicates the overall abstraction of observable
properties.
Relatedly, it also finishes implementing PROPERTY_DID_CHANGE, which now
executes reliably any time an observer would have fired. You can think
of it as an always-on observer if it's present on an object. Glimmer 2
curly components use this hook to propagate `set`s on components back to
their original bindings (if the bindings are present).
This commit also implements two way bindings in Glimmer 2, by making
PropertyReferences implement an `UPDATE` method. If that method is
present, it is used to propagate changes upwards (otherwise, an
exception is thrown). | packages/ember-metal/lib/properties.js | @@ -4,7 +4,7 @@
import { assert } from 'ember-metal/debug';
import isEnabled from 'ember-metal/features';
-import { meta as metaFor } from 'ember-metal/meta';
+import { meta as metaFor, peekMeta } from 'ember-metal/meta';
import { overrideChains } from 'ember-metal/property_events';
// ..........................................................
// DESCRIPTOR
@@ -43,7 +43,12 @@ const REDEFINE_SUPPORTED = (function () {
export function MANDATORY_SETTER_FUNCTION(name) {
function SETTER_FUNCTION(value) {
- assert(`You must use Ember.set() to set the \`${name}\` property (of ${this}) to \`${value}\`.`, false);
+ let m = peekMeta(this);
+ if (!m.isInitialized(this)) {
+ m.writeValues(name, value);
+ } else {
+ assert(`You must use Ember.set() to set the \`${name}\` property (of ${this}) to \`${value}\`.`, false);
+ }
}
SETTER_FUNCTION.isMandatorySetter = true;
@@ -57,10 +62,19 @@ export function DEFAULT_GETTER_FUNCTION(name) {
};
}
+import { UNDEFINED } from './meta';
+
export function INHERITING_GETTER_FUNCTION(name) {
function IGETTER_FUNCTION() {
- var proto = Object.getPrototypeOf(this);
- return proto && proto[name];
+ let meta = this['__ember_meta__'];
+ let val = meta && meta.readInheritedValue('values', name);
+
+ if (val === UNDEFINED) {
+ var proto = Object.getPrototypeOf(this);
+ return proto && proto[name];
+ } else {
+ return val;
+ }
}
IGETTER_FUNCTION.isInheritingGetter = true; | true |
Other | emberjs | ember.js | 9471527454b30b9a892d6d40f21735365b5a2897.json | Reorganize metal to support 2WB in Glimmer
This commit restructures some of the more arcane parts of ember-metal's
observer system.
It eliminates some special casing around `length`, which isn't necessary
anymore but complicates the overall abstraction of observable
properties.
Relatedly, it also finishes implementing PROPERTY_DID_CHANGE, which now
executes reliably any time an observer would have fired. You can think
of it as an always-on observer if it's present on an object. Glimmer 2
curly components use this hook to propagate `set`s on components back to
their original bindings (if the bindings are present).
This commit also implements two way bindings in Glimmer 2, by making
PropertyReferences implement an `UPDATE` method. If that method is
present, it is used to propagate changes upwards (otherwise, an
exception is thrown). | packages/ember-metal/lib/property_events.js | @@ -8,6 +8,9 @@ import {
sendEvent,
accumulateListeners
} from 'ember-metal/events';
+import {
+ markObjectAsDirty
+} from './tags';
import ObserverSet from 'ember-metal/observer_set';
import symbol from 'ember-metal/symbol';
@@ -39,26 +42,24 @@ var deferred = 0;
*/
function propertyWillChange(obj, keyName) {
var m = peekMeta(obj);
- var watching = (m && m.peekWatching(keyName) > 0) || keyName === 'length';
- var proto = m && m.proto;
- var possibleDesc = obj[keyName];
- var desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
- if (!watching) {
+ if (m && !m.isInitialized(obj)) {
return;
}
- if (proto === obj) {
- return;
- }
+ var watching = m && m.peekWatching(keyName) > 0;
+ var possibleDesc = obj[keyName];
+ var desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
if (desc && desc.willChange) {
desc.willChange(obj, keyName);
}
- dependentKeysWillChange(obj, keyName, m);
- chainsWillChange(obj, keyName, m);
- notifyBeforeObservers(obj, keyName);
+ if (watching) {
+ dependentKeysWillChange(obj, keyName, m);
+ chainsWillChange(obj, keyName, m);
+ notifyBeforeObservers(obj, keyName);
+ }
}
/**
@@ -79,36 +80,37 @@ function propertyWillChange(obj, keyName) {
*/
function propertyDidChange(obj, keyName) {
var m = peekMeta(obj);
- var watching = (m && m.peekWatching(keyName) > 0) || keyName === 'length';
- var proto = m && m.proto;
- var possibleDesc = obj[keyName];
- var desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
- if (proto === obj) {
+ if (m && !m.isInitialized(obj)) {
return;
}
+ var watching = m && m.peekWatching(keyName) > 0;
+ var possibleDesc = obj[keyName];
+ var desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
+
// shouldn't this mean that we're watching this key?
if (desc && desc.didChange) {
desc.didChange(obj, keyName);
}
- if (obj[PROPERTY_DID_CHANGE]) {
- obj[PROPERTY_DID_CHANGE](keyName);
- }
+ if (watching) {
+ if (m.hasDeps(keyName)) {
+ dependentKeysDidChange(obj, keyName, m);
+ }
- if (!watching && keyName !== 'length') {
- return;
+ chainsDidChange(obj, keyName, m, false);
+ notifyObservers(obj, keyName);
}
- if (m && m.hasDeps(keyName)) {
- dependentKeysDidChange(obj, keyName, m);
+ if (obj[PROPERTY_DID_CHANGE]) {
+ obj[PROPERTY_DID_CHANGE](keyName);
}
- chainsDidChange(obj, keyName, m, false);
- notifyObservers(obj, keyName);
+ markObjectAsDirty(m);
}
+
var WILL_SEEN, DID_SEEN;
// called whenever a property is about to change to clear the cache of any dependent keys (and notify those properties of changes, etc...)
function dependentKeysWillChange(obj, depKey, meta) { | true |
Other | emberjs | ember.js | 9471527454b30b9a892d6d40f21735365b5a2897.json | Reorganize metal to support 2WB in Glimmer
This commit restructures some of the more arcane parts of ember-metal's
observer system.
It eliminates some special casing around `length`, which isn't necessary
anymore but complicates the overall abstraction of observable
properties.
Relatedly, it also finishes implementing PROPERTY_DID_CHANGE, which now
executes reliably any time an observer would have fired. You can think
of it as an always-on observer if it's present on an object. Glimmer 2
curly components use this hook to propagate `set`s on components back to
their original bindings (if the bindings are present).
This commit also implements two way bindings in Glimmer 2, by making
PropertyReferences implement an `UPDATE` method. If that method is
present, it is used to propagate changes upwards (otherwise, an
exception is thrown). | packages/ember-metal/lib/property_set.js | @@ -2,11 +2,10 @@ import { assert } from 'ember-metal/debug';
import isEnabled from 'ember-metal/features';
import { _getPath as getPath } from 'ember-metal/property_get';
import {
- PROPERTY_DID_CHANGE,
propertyWillChange,
propertyDidChange
} from 'ember-metal/property_events';
-import { defineProperty } from 'ember-metal/properties';
+
import EmberError from 'ember-metal/error';
import {
isPath,
@@ -17,14 +16,9 @@ import {
} from 'ember-metal/meta';
import {
- lookupDescriptor,
toString
} from 'ember-metal/utils';
-import {
- markObjectAsDirty
-} from './tags';
-
/**
Sets the value of a property on an object, respecting computed properties
and notifying observers and other listeners of the change. If the
@@ -44,79 +38,67 @@ export function set(obj, keyName, value, tolerant) {
`Set must be called with three or four arguments; an object, a property key, a value and tolerant true/false`,
arguments.length === 3 || arguments.length === 4
);
- assert(`Cannot call set with '${keyName}' on an undefined object.`, obj !== undefined && obj !== null);
+ assert(`Cannot call set with '${keyName}' on an undefined object.`, obj && typeof obj === 'object' || typeof obj === 'function');
assert(`The key provided to set must be a string, you passed ${keyName}`, typeof keyName === 'string');
assert(`'this' in paths is not supported`, !pathHasThis(keyName));
+ assert(`calling set on destroyed object: ${toString(obj)}.${keyName} = ${toString(value)}`, !obj.isDestroyed);
- let meta, possibleDesc, desc;
-
- if (obj) {
- meta = peekMeta(obj);
- possibleDesc = obj[keyName];
- desc = (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) ? possibleDesc : undefined;
- }
-
- var isUnknown, currentValue;
- if (desc === undefined && isPath(keyName)) {
+ if (isPath(keyName)) {
return setPath(obj, keyName, value, tolerant);
}
- assert(`calling set on destroyed object: ${toString(obj)}.${keyName} = ${toString(value)}`,
- !obj.isDestroyed);
+ let meta = peekMeta(obj);
+ let possibleDesc = obj[keyName];
- markObjectAsDirty(meta);
+ let desc, currentValue;
+ if (possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor) {
+ desc = possibleDesc;
+ } else {
+ currentValue = possibleDesc;
+ }
- if (desc) {
+ if (desc) { /* computed property */
desc.set(obj, keyName, value);
+ } else if (obj.setUnknownProperty && currentValue === undefined && !(keyName in obj)) { /* unknown property */
+ assert('setUnknownProperty must be a function', typeof obj.setUnknownProperty === 'function');
+ obj.setUnknownProperty(keyName, value);
+ } else if (currentValue === value) { /* no change */
+ return value;
} else {
- if (value !== undefined && typeof obj === 'object' && obj[keyName] === value) {
- return value;
- }
+ propertyWillChange(obj, keyName);
- isUnknown = 'object' === typeof obj && !(keyName in obj);
-
- // setUnknownProperty is called if `obj` is an object,
- // the property does not already exist, and the
- // `setUnknownProperty` method exists on the object
- if (isUnknown && 'function' === typeof obj.setUnknownProperty) {
- obj.setUnknownProperty(keyName, value);
- } else if (meta && meta.peekWatching(keyName) > 0) {
- if (meta.proto !== obj) {
- currentValue = obj[keyName];
- }
- // only trigger a change if the value has changed
- if (value !== currentValue) {
- propertyWillChange(obj, keyName);
-
- if (isEnabled('mandatory-setter')) {
- if ((currentValue === undefined && !(keyName in obj)) ||
- !Object.prototype.propertyIsEnumerable.call(obj, keyName)
- ) {
- defineProperty(obj, keyName, null, value); // setup mandatory setter
- } else {
- let descriptor = lookupDescriptor(obj, keyName);
- let isMandatorySetter = descriptor && descriptor.set && descriptor.set.isMandatorySetter;
- if (isMandatorySetter) {
- meta.writeValues(keyName, value);
- } else {
- obj[keyName] = value;
- }
- }
- } else {
- obj[keyName] = value;
- }
- propertyDidChange(obj, keyName);
- }
+ if (isEnabled('mandatory-setter')) {
+ setWithMandatorySetter(meta, obj, keyName, value);
} else {
obj[keyName] = value;
- if (obj[PROPERTY_DID_CHANGE]) {
- obj[PROPERTY_DID_CHANGE](keyName);
- }
}
+
+ propertyDidChange(obj, keyName);
}
+
return value;
}
+if (isEnabled('mandatory-setter')) {
+ var setWithMandatorySetter = function(meta, obj, keyName, value) {
+ if (meta && meta.peekWatching(keyName) > 0) {
+ makeEnumerable(obj, keyName);
+ meta.writeValue(obj, keyName, value);
+ } else {
+ obj[keyName] = value;
+ }
+ };
+
+ var makeEnumerable = function(obj, key) {
+ let desc = Object.getOwnPropertyDescriptor(obj, key);
+
+ if (desc && desc.set && desc.set.isMandatorySetter) {
+ desc.enumerable = true;
+ Object.defineProperty(obj, key, desc);
+ }
+ };
+}
+
function setPath(root, path, value, tolerant) {
var keyName;
| true |
Other | emberjs | ember.js | 9471527454b30b9a892d6d40f21735365b5a2897.json | Reorganize metal to support 2WB in Glimmer
This commit restructures some of the more arcane parts of ember-metal's
observer system.
It eliminates some special casing around `length`, which isn't necessary
anymore but complicates the overall abstraction of observable
properties.
Relatedly, it also finishes implementing PROPERTY_DID_CHANGE, which now
executes reliably any time an observer would have fired. You can think
of it as an always-on observer if it's present on an object. Glimmer 2
curly components use this hook to propagate `set`s on components back to
their original bindings (if the bindings are present).
This commit also implements two way bindings in Glimmer 2, by making
PropertyReferences implement an `UPDATE` method. If that method is
present, it is used to propagate changes upwards (otherwise, an
exception is thrown). | packages/ember-metal/lib/watch_key.js | @@ -12,9 +12,6 @@ import { lookupDescriptor } from 'ember-metal/utils';
let handleMandatorySetter;
export function watchKey(obj, keyName, meta) {
- // can't watch length on Array - it is special...
- if (keyName === 'length' && Array.isArray(obj)) { return; }
-
var m = meta || metaFor(obj);
// activate watching first time
@@ -42,6 +39,14 @@ export function watchKey(obj, keyName, meta) {
if (isEnabled('mandatory-setter')) {
+ let hasOwnProperty = function(obj, key) {
+ return Object.prototype.hasOwnProperty.call(obj, key);
+ };
+
+ let propertyIsEnumerable = function(obj, key) {
+ return Object.prototype.propertyIsEnumerable.call(obj, key);
+ };
+
// Future traveler, although this code looks scary. It merely exists in
// development to aid in development asertions. Production builds of
// ember strip this entire block out
@@ -61,12 +66,12 @@ if (isEnabled('mandatory-setter')) {
if (configurable && isWritable && hasValue && keyName in obj) {
let desc = {
configurable: true,
- enumerable: Object.prototype.propertyIsEnumerable.call(obj, keyName),
set: MANDATORY_SETTER_FUNCTION(keyName),
+ enumerable: propertyIsEnumerable(obj, keyName),
get: undefined
};
- if (Object.prototype.hasOwnProperty.call(obj, keyName)) {
+ if (hasOwnProperty(obj, keyName)) {
m.writeValues(keyName, obj[keyName]);
desc.get = DEFAULT_GETTER_FUNCTION(keyName);
} else {
@@ -78,6 +83,8 @@ if (isEnabled('mandatory-setter')) {
};
}
+import { UNDEFINED } from './meta';
+
export function unwatchKey(obj, keyName, meta) {
var m = meta || metaFor(obj);
let count = m.peekWatching(keyName);
@@ -109,16 +116,20 @@ export function unwatchKey(obj, keyName, meta) {
if (maybeMandatoryDescriptor.set && maybeMandatoryDescriptor.set.isMandatorySetter) {
if (maybeMandatoryDescriptor.get && maybeMandatoryDescriptor.get.isInheritingGetter) {
- delete obj[keyName];
- } else {
- Object.defineProperty(obj, keyName, {
- configurable: true,
- enumerable: Object.prototype.propertyIsEnumerable.call(obj, keyName),
- writable: true,
- value: m.peekValues(keyName)
- });
- m.deleteFromValues(keyName);
+ let possibleValue = m.readInheritedValue('values', keyName);
+ if (possibleValue === UNDEFINED) {
+ delete obj[keyName];
+ return;
+ }
}
+
+ Object.defineProperty(obj, keyName, {
+ configurable: true,
+ enumerable: Object.prototype.propertyIsEnumerable.call(obj, keyName),
+ writable: true,
+ value: m.peekValues(keyName)
+ });
+ m.deleteFromValues(keyName);
}
}
} | true |
Other | emberjs | ember.js | 9471527454b30b9a892d6d40f21735365b5a2897.json | Reorganize metal to support 2WB in Glimmer
This commit restructures some of the more arcane parts of ember-metal's
observer system.
It eliminates some special casing around `length`, which isn't necessary
anymore but complicates the overall abstraction of observable
properties.
Relatedly, it also finishes implementing PROPERTY_DID_CHANGE, which now
executes reliably any time an observer would have fired. You can think
of it as an always-on observer if it's present on an object. Glimmer 2
curly components use this hook to propagate `set`s on components back to
their original bindings (if the bindings are present).
This commit also implements two way bindings in Glimmer 2, by making
PropertyReferences implement an `UPDATE` method. If that method is
present, it is used to propagate changes upwards (otherwise, an
exception is thrown). | packages/ember-metal/lib/watch_path.js | @@ -10,14 +10,11 @@ function chainsFor(obj, meta) {
return (meta || metaFor(obj)).writableChains(makeChainNode);
}
-function makeChainNode(obj) {
+export function makeChainNode(obj) {
return new ChainNode(null, null, obj);
}
export function watchPath(obj, keyPath, meta) {
- // can't watch length on Array - it is special...
- if (keyPath === 'length' && Array.isArray(obj)) { return; }
-
var m = meta || metaFor(obj);
let counter = m.peekWatching(keyPath) || 0;
if (!counter) { // activate watching first time | true |
Other | emberjs | ember.js | 9471527454b30b9a892d6d40f21735365b5a2897.json | Reorganize metal to support 2WB in Glimmer
This commit restructures some of the more arcane parts of ember-metal's
observer system.
It eliminates some special casing around `length`, which isn't necessary
anymore but complicates the overall abstraction of observable
properties.
Relatedly, it also finishes implementing PROPERTY_DID_CHANGE, which now
executes reliably any time an observer would have fired. You can think
of it as an always-on observer if it's present on an object. Glimmer 2
curly components use this hook to propagate `set`s on components back to
their original bindings (if the bindings are present).
This commit also implements two way bindings in Glimmer 2, by making
PropertyReferences implement an `UPDATE` method. If that method is
present, it is used to propagate changes upwards (otherwise, an
exception is thrown). | packages/ember-metal/lib/watching.js | @@ -35,9 +35,6 @@ import {
@param {String} _keyPath
*/
function watch(obj, _keyPath, m) {
- // can't watch length on Array - it is special...
- if (_keyPath === 'length' && Array.isArray(obj)) { return; }
-
if (!isPath(_keyPath)) {
watchKey(obj, _keyPath, m);
} else {
@@ -58,9 +55,6 @@ export function watcherCount(obj, key) {
}
export function unwatch(obj, _keyPath, m) {
- // can't watch length on Array - it is special...
- if (_keyPath === 'length' && Array.isArray(obj)) { return; }
-
if (!isPath(_keyPath)) {
unwatchKey(obj, _keyPath, m);
} else { | true |
Other | emberjs | ember.js | 9471527454b30b9a892d6d40f21735365b5a2897.json | Reorganize metal to support 2WB in Glimmer
This commit restructures some of the more arcane parts of ember-metal's
observer system.
It eliminates some special casing around `length`, which isn't necessary
anymore but complicates the overall abstraction of observable
properties.
Relatedly, it also finishes implementing PROPERTY_DID_CHANGE, which now
executes reliably any time an observer would have fired. You can think
of it as an always-on observer if it's present on an object. Glimmer 2
curly components use this hook to propagate `set`s on components back to
their original bindings (if the bindings are present).
This commit also implements two way bindings in Glimmer 2, by making
PropertyReferences implement an `UPDATE` method. If that method is
present, it is used to propagate changes upwards (otherwise, an
exception is thrown). | packages/ember-metal/tests/watching/watch_test.js | @@ -216,8 +216,8 @@ testBoth('watching "length" property on an array', function(get, set) {
equal(get(arr, 'length'), 0, 'should have original prop');
set(arr, 'length', '10');
- equal(willCount, 0, 'should NOT have invoked willCount');
- equal(didCount, 0, 'should NOT have invoked didCount');
+ equal(willCount, 1, 'should NOT have invoked willCount');
+ equal(didCount, 1, 'should NOT have invoked didCount');
equal(get(arr, 'length'), 10, 'should get new value');
equal(arr.length, 10, 'property should be accessible on arr'); | true |
Other | emberjs | ember.js | 9471527454b30b9a892d6d40f21735365b5a2897.json | Reorganize metal to support 2WB in Glimmer
This commit restructures some of the more arcane parts of ember-metal's
observer system.
It eliminates some special casing around `length`, which isn't necessary
anymore but complicates the overall abstraction of observable
properties.
Relatedly, it also finishes implementing PROPERTY_DID_CHANGE, which now
executes reliably any time an observer would have fired. You can think
of it as an always-on observer if it's present on an object. Glimmer 2
curly components use this hook to propagate `set`s on components back to
their original bindings (if the bindings are present).
This commit also implements two way bindings in Glimmer 2, by making
PropertyReferences implement an `UPDATE` method. If that method is
present, it is used to propagate changes upwards (otherwise, an
exception is thrown). | packages/ember-runtime/lib/system/native_array.js | @@ -37,9 +37,7 @@ var NativeArray = Mixin.create(MutableArray, Observable, Copyable, {
// because length is a built-in property we need to know to just get the
// original property.
get(key) {
- if (key === 'length') {
- return this.length;
- } else if ('number' === typeof key) {
+ if ('number' === typeof key) {
return this[key];
} else {
return this._super(key); | true |
Other | emberjs | ember.js | 9471527454b30b9a892d6d40f21735365b5a2897.json | Reorganize metal to support 2WB in Glimmer
This commit restructures some of the more arcane parts of ember-metal's
observer system.
It eliminates some special casing around `length`, which isn't necessary
anymore but complicates the overall abstraction of observable
properties.
Relatedly, it also finishes implementing PROPERTY_DID_CHANGE, which now
executes reliably any time an observer would have fired. You can think
of it as an always-on observer if it's present on an object. Glimmer 2
curly components use this hook to propagate `set`s on components back to
their original bindings (if the bindings are present).
This commit also implements two way bindings in Glimmer 2, by making
PropertyReferences implement an `UPDATE` method. If that method is
present, it is used to propagate changes upwards (otherwise, an
exception is thrown). | packages/ember-runtime/tests/system/object/observer_test.js | @@ -208,4 +208,8 @@ testBoth('chain observer on class that has a reference to an uninitialized objec
parent.set('one.two', 'new');
equal(changed, true, 'child should have been notified of change to path');
+
+ parent.set('one', { two: 'newer' });
+
+ equal(changed, true, 'child should have been notified of change to path');
}); | true |
Other | emberjs | ember.js | bcbec4f47a10112829e3183cb562f5b9d71e5f20.json | Improve testing for uniquely named initializers.
Tests now verify that initializers can be named the same on
_different_ apps/engines, but must be uniquely named on _each_
app/engine. | packages/ember-application/tests/system/engine_initializers_test.js | @@ -310,18 +310,29 @@ QUnit.test('initializers are concatenated', function() {
});
QUnit.test('initializers are per-engine', function() {
- expect(0);
+ expect(2);
+
let FirstEngine = Engine.extend();
+
FirstEngine.initializer({
- name: 'shouldNotCollide',
+ name: 'abc',
initialize(engine) {}
});
+ throws(function() {
+ FirstEngine.initializer({
+ name: 'abc',
+ initialize(engine) {}
+ });
+ }, Error, /Assertion Failed: The initializer 'abc' has already been registered'/);
+
let SecondEngine = Engine.extend();
- SecondEngine.initializer({
- name: 'shouldNotCollide',
+ SecondEngine.instanceInitializer({
+ name: 'abc',
initialize(engine) {}
});
+
+ ok(true, 'Two engines can have initializers named the same.');
});
QUnit.test('initializers are executed in their own context', function() { | true |
Other | emberjs | ember.js | bcbec4f47a10112829e3183cb562f5b9d71e5f20.json | Improve testing for uniquely named initializers.
Tests now verify that initializers can be named the same on
_different_ apps/engines, but must be uniquely named on _each_
app/engine. | packages/ember-application/tests/system/engine_instance_initializers_test.js | @@ -332,18 +332,29 @@ QUnit.test('initializers are concatenated', function() {
});
QUnit.test('initializers are per-engine', function() {
- expect(0);
+ expect(2);
+
let FirstEngine = Engine.extend();
+
FirstEngine.instanceInitializer({
- name: 'shouldNotCollide',
+ name: 'abc',
initialize(engine) {}
});
+ throws(function() {
+ FirstEngine.instanceInitializer({
+ name: 'abc',
+ initialize(engine) {}
+ });
+ }, Error, /Assertion Failed: The instance initializer 'abc' has already been registered'/);
+
let SecondEngine = Engine.extend();
SecondEngine.instanceInitializer({
- name: 'shouldNotCollide',
+ name: 'abc',
initialize(engine) {}
});
+
+ ok(true, 'Two engines can have initializers named the same.');
});
QUnit.test('initializers are executed in their own context', function() { | true |
Other | emberjs | ember.js | bcbec4f47a10112829e3183cb562f5b9d71e5f20.json | Improve testing for uniquely named initializers.
Tests now verify that initializers can be named the same on
_different_ apps/engines, but must be uniquely named on _each_
app/engine. | packages/ember-application/tests/system/initializers_test.js | @@ -349,18 +349,29 @@ QUnit.test('initializers are concatenated', function() {
});
QUnit.test('initializers are per-app', function() {
- expect(0);
- var FirstApp = Application.extend();
+ expect(2);
+
+ let FirstApp = Application.extend();
+
FirstApp.initializer({
- name: 'shouldNotCollide',
- initialize(application) {}
+ name: 'abc',
+ initialize(app) {}
});
- var SecondApp = Application.extend();
- SecondApp.initializer({
- name: 'shouldNotCollide',
- initialize(application) {}
+ throws(function() {
+ FirstApp.initializer({
+ name: 'abc',
+ initialize(app) {}
+ });
+ }, Error, /Assertion Failed: The initializer 'abc' has already been registered'/);
+
+ let SecondApp = Application.extend();
+ SecondApp.instanceInitializer({
+ name: 'abc',
+ initialize(app) {}
});
+
+ ok(true, 'Two apps can have initializers named the same.');
});
QUnit.test('initializers are executed in their own context', function() { | true |
Other | emberjs | ember.js | bcbec4f47a10112829e3183cb562f5b9d71e5f20.json | Improve testing for uniquely named initializers.
Tests now verify that initializers can be named the same on
_different_ apps/engines, but must be uniquely named on _each_
app/engine. | packages/ember-application/tests/system/instance_initializers_test.js | @@ -318,18 +318,29 @@ QUnit.test('initializers are concatenated', function() {
});
QUnit.test('initializers are per-app', function() {
- expect(0);
- var FirstApp = Application.extend();
+ expect(2);
+
+ let FirstApp = Application.extend();
+
FirstApp.instanceInitializer({
- name: 'shouldNotCollide',
- initialize(registry) {}
+ name: 'abc',
+ initialize(app) {}
});
- var SecondApp = Application.extend();
+ throws(function() {
+ FirstApp.instanceInitializer({
+ name: 'abc',
+ initialize(app) {}
+ });
+ }, Error, /Assertion Failed: The instance initializer 'abc' has already been registered'/);
+
+ let SecondApp = Application.extend();
SecondApp.instanceInitializer({
- name: 'shouldNotCollide',
- initialize(registry) {}
+ name: 'abc',
+ initialize(app) {}
});
+
+ ok(true, 'Two apps can have initializers named the same.');
});
QUnit.test('initializers are run before ready hook', function() { | true |
Other | emberjs | ember.js | 591b864b428274600a2d0b4374c63cc2d74fbc2d.json | Introduce tests for EngineInstance initializers. | packages/ember-application/tests/system/engine_instance_initializers_test.js | @@ -0,0 +1,366 @@
+import run from 'ember-metal/run_loop';
+import Engine from 'ember-application/system/engine';
+import EngineInstance from 'ember-application/system/engine-instance';
+
+let MyEngine,
+ myEngine,
+ myEngineInstance;
+
+QUnit.module('Ember.Engine instance initializers', {
+ setup() {
+ },
+
+ teardown() {
+ run(function() {
+ if (myEngineInstance) {
+ myEngineInstance.destroy();
+ }
+
+ if (myEngine) {
+ myEngine.destroy();
+ }
+ });
+ }
+});
+
+QUnit.test('initializers require proper \'name\' and \'initialize\' properties', function() {
+ MyEngine = Engine.extend();
+
+ expectAssertion(function() {
+ run(function() {
+ MyEngine.instanceInitializer({ name: 'initializer' });
+ });
+ });
+
+ expectAssertion(function() {
+ run(function() {
+ MyEngine.instanceInitializer({ initialize() {} });
+ });
+ });
+});
+
+QUnit.test('initializers are passed an engine instance', function() {
+ MyEngine = Engine.extend();
+
+ MyEngine.instanceInitializer({
+ name: 'initializer',
+ initialize(instance) {
+ ok(instance instanceof EngineInstance, 'initialize is passed an engine instance');
+ }
+ });
+
+ myEngine = MyEngine.create();
+ myEngineInstance = myEngine.buildInstance();
+ return myEngineInstance.boot();
+});
+
+QUnit.test('initializers can be registered in a specified order', function() {
+ let order = [];
+
+ MyEngine = Engine.extend();
+
+ MyEngine.instanceInitializer({
+ name: 'fourth',
+ after: 'third',
+ initialize(engine) {
+ order.push('fourth');
+ }
+ });
+
+ MyEngine.instanceInitializer({
+ name: 'second',
+ after: 'first',
+ before: 'third',
+ initialize(engine) {
+ order.push('second');
+ }
+ });
+
+ MyEngine.instanceInitializer({
+ name: 'fifth',
+ after: 'fourth',
+ before: 'sixth',
+ initialize(engine) {
+ order.push('fifth');
+ }
+ });
+
+ MyEngine.instanceInitializer({
+ name: 'first',
+ before: 'second',
+ initialize(engine) {
+ order.push('first');
+ }
+ });
+
+ MyEngine.instanceInitializer({
+ name: 'third',
+ initialize(engine) {
+ order.push('third');
+ }
+ });
+
+ MyEngine.instanceInitializer({
+ name: 'sixth',
+ initialize(engine) {
+ order.push('sixth');
+ }
+ });
+
+ myEngine = MyEngine.create();
+ myEngineInstance = myEngine.buildInstance();
+
+ return myEngineInstance.boot().then(() => {
+ deepEqual(order, ['first', 'second', 'third', 'fourth', 'fifth', 'sixth']);
+ });
+});
+
+QUnit.test('initializers can be registered in a specified order as an array', function() {
+ let order = [];
+ MyEngine = Engine.extend();
+
+ MyEngine.instanceInitializer({
+ name: 'third',
+ initialize(engine) {
+ order.push('third');
+ }
+ });
+
+ MyEngine.instanceInitializer({
+ name: 'second',
+ after: 'first',
+ before: ['third', 'fourth'],
+ initialize(engine) {
+ order.push('second');
+ }
+ });
+
+ MyEngine.instanceInitializer({
+ name: 'fourth',
+ after: ['second', 'third'],
+ initialize(engine) {
+ order.push('fourth');
+ }
+ });
+
+ MyEngine.instanceInitializer({
+ name: 'fifth',
+ after: 'fourth',
+ before: 'sixth',
+ initialize(engine) {
+ order.push('fifth');
+ }
+ });
+
+ MyEngine.instanceInitializer({
+ name: 'first',
+ before: ['second'],
+ initialize(engine) {
+ order.push('first');
+ }
+ });
+
+ MyEngine.instanceInitializer({
+ name: 'sixth',
+ initialize(engine) {
+ order.push('sixth');
+ }
+ });
+
+ myEngine = MyEngine.create();
+ myEngineInstance = myEngine.buildInstance();
+
+ return myEngineInstance.boot().then(() => {
+ deepEqual(order, ['first', 'second', 'third', 'fourth', 'fifth', 'sixth']);
+ });
+});
+
+QUnit.test('initializers can have multiple dependencies', function () {
+ let order = [];
+
+ MyEngine = Engine.extend();
+
+ let a = {
+ name: 'a',
+ before: 'b',
+ initialize(engine) {
+ order.push('a');
+ }
+ };
+ let b = {
+ name: 'b',
+ initialize(engine) {
+ order.push('b');
+ }
+ };
+ let c = {
+ name: 'c',
+ after: 'b',
+ initialize(engine) {
+ order.push('c');
+ }
+ };
+ let afterB = {
+ name: 'after b',
+ after: 'b',
+ initialize(engine) {
+ order.push('after b');
+ }
+ };
+ let afterC = {
+ name: 'after c',
+ after: 'c',
+ initialize(engine) {
+ order.push('after c');
+ }
+ };
+
+ MyEngine.instanceInitializer(b);
+ MyEngine.instanceInitializer(a);
+ MyEngine.instanceInitializer(afterC);
+ MyEngine.instanceInitializer(afterB);
+ MyEngine.instanceInitializer(c);
+
+ myEngine = MyEngine.create();
+ myEngineInstance = myEngine.buildInstance();
+
+ return myEngineInstance.boot().then(() => {
+ ok(order.indexOf(a.name) < order.indexOf(b.name), 'a < b');
+ ok(order.indexOf(b.name) < order.indexOf(c.name), 'b < c');
+ ok(order.indexOf(b.name) < order.indexOf(afterB.name), 'b < afterB');
+ ok(order.indexOf(c.name) < order.indexOf(afterC.name), 'c < afterC');
+ });
+});
+
+QUnit.test('initializers set on Engine subclasses should not be shared between engines', function() {
+ let firstInitializerRunCount = 0;
+ let secondInitializerRunCount = 0;
+ let FirstEngine = Engine.extend();
+ let firstEngine, firstEngineInstance;
+
+ FirstEngine.instanceInitializer({
+ name: 'first',
+ initialize(engine) {
+ firstInitializerRunCount++;
+ }
+ });
+
+ let SecondEngine = Engine.extend();
+ let secondEngine, secondEngineInstance;
+
+ SecondEngine.instanceInitializer({
+ name: 'second',
+ initialize(engine) {
+ secondInitializerRunCount++;
+ }
+ });
+
+ firstEngine = FirstEngine.create();
+ firstEngineInstance = firstEngine.buildInstance();
+
+ return firstEngineInstance.boot()
+ .then(() => {
+ equal(firstInitializerRunCount, 1, 'first initializer only was run');
+ equal(secondInitializerRunCount, 0, 'first initializer only was run');
+
+ secondEngine = SecondEngine.create();
+ secondEngineInstance = secondEngine.buildInstance();
+ return secondEngineInstance.boot();
+ })
+ .then(() => {
+ equal(firstInitializerRunCount, 1, 'second initializer only was run');
+ equal(secondInitializerRunCount, 1, 'second initializer only was run');
+
+ run(function() {
+ firstEngineInstance.destroy();
+ secondEngineInstance.destroy();
+
+ firstEngine.destroy();
+ secondEngine.destroy();
+ });
+ });
+});
+
+QUnit.test('initializers are concatenated', function() {
+ let firstInitializerRunCount = 0;
+ let secondInitializerRunCount = 0;
+ let FirstEngine = Engine.extend();
+
+ FirstEngine.instanceInitializer({
+ name: 'first',
+ initialize(engine) {
+ firstInitializerRunCount++;
+ }
+ });
+
+ let SecondEngine = FirstEngine.extend();
+
+ SecondEngine.instanceInitializer({
+ name: 'second',
+ initialize(engine) {
+ secondInitializerRunCount++;
+ }
+ });
+
+ let firstEngine = FirstEngine.create();
+ let firstEngineInstance = firstEngine.buildInstance();
+
+ let secondEngine, secondEngineInstance;
+
+ return firstEngineInstance.boot()
+ .then(() => {
+ equal(firstInitializerRunCount, 1, 'first initializer only was run when base class created');
+ equal(secondInitializerRunCount, 0, 'second initializer was not run when first base class created');
+ firstInitializerRunCount = 0;
+
+ secondEngine = SecondEngine.create();
+ secondEngineInstance = secondEngine.buildInstance();
+ return secondEngineInstance.boot();
+ })
+ .then(() => {
+ equal(firstInitializerRunCount, 1, 'first initializer was run when subclass created');
+ equal(secondInitializerRunCount, 1, 'second initializers was run when subclass created');
+
+ run(function() {
+ firstEngineInstance.destroy();
+ secondEngineInstance.destroy();
+
+ firstEngine.destroy();
+ secondEngine.destroy();
+ });
+ });
+});
+
+QUnit.test('initializers are per-engine', function() {
+ expect(0);
+ let FirstEngine = Engine.extend();
+ FirstEngine.instanceInitializer({
+ name: 'shouldNotCollide',
+ initialize(engine) {}
+ });
+
+ let SecondEngine = Engine.extend();
+ SecondEngine.instanceInitializer({
+ name: 'shouldNotCollide',
+ initialize(engine) {}
+ });
+});
+
+QUnit.test('initializers are executed in their own context', function() {
+ expect(1);
+
+ let MyEngine = Engine.extend();
+
+ MyEngine.instanceInitializer({
+ name: 'coolInitializer',
+ myProperty: 'cool',
+ initialize(engine) {
+ equal(this.myProperty, 'cool', 'should have access to its own context');
+ }
+ });
+
+ myEngine = MyEngine.create();
+ myEngineInstance = myEngine.buildInstance();
+
+ return myEngineInstance.boot();
+}); | false |
Other | emberjs | ember.js | e087ae693f690e9476156ce68ec09610edcb10b7.json | Move common boot concerns to EngineInstance. | packages/ember-application/lib/system/application-instance.js | @@ -85,41 +85,19 @@ const ApplicationInstance = EngineInstance.extend({
// appended to the rootElement, in the case of apps, to the fixture harness
// in tests, or rendered to a string in the case of FastBoot.
this.register('-application-instance:main', this, { instantiate: false });
-
- this._booted = false;
},
/**
- Initialize the `Ember.ApplicationInstance` and return a promise that resolves
- with the instance itself when the boot process is complete.
+ Overrides the base `EngineInstance._bootSync` method with concerns relevant
+ to booting application (instead of engine) instances.
- The primary task here is to run any registered instance initializers.
+ This method should only contain synchronous boot concerns. Asynchronous
+ boot concerns should eventually be moved to the `boot` method, which
+ returns a promise.
- See the documentation on `BootOptions` for the options it takes.
-
- @private
- @method boot
- @param options
- @return {Promise<Ember.ApplicationInstance,Error>}
- */
- boot(options = {}) {
- if (this._bootPromise) { return this._bootPromise; }
-
- this._bootPromise = new RSVP.Promise(resolve => resolve(this._bootSync(options)));
-
- return this._bootPromise;
- },
-
- /**
- Unfortunately, a lot of existing code assumes booting an instance is
- synchronous – specifically, a lot of tests assumes the last call to
- `app.advanceReadiness()` or `app.reset()` will result in a new instance
- being fully-booted when the current runloop completes.
-
- We would like new code (like the `visit` API) to stop making this assumption,
- so we created the asynchronous version above that returns a promise. But until
- we have migrated all the code, we would have to expose this method for use
- *internally* in places where we need to boot an instance synchronously.
+ Until all boot code has been made asynchronous, we need to continue to
+ expose this method for use *internally* in places where we need to boot an
+ instance synchronously.
@private
*/
@@ -128,21 +106,7 @@ const ApplicationInstance = EngineInstance.extend({
options = new BootOptions(options);
- let registry = this.__registry__;
-
- registry.register('-environment:main', options.toEnvironment(), { instantiate: false });
- registry.injection('view', '_environment', '-environment:main');
- registry.injection('route', '_environment', '-environment:main');
-
- registry.register('service:-document', options.document, { instantiate: false });
-
- if (options.isInteractive) {
- registry.injection('view', 'renderer', 'renderer:-dom');
- registry.injection('component', 'renderer', 'renderer:-dom');
- } else {
- registry.injection('view', 'renderer', 'renderer:-inert');
- registry.injection('component', 'renderer', 'renderer:-inert');
- }
+ this.setupRegistry(options);
if (options.rootElement) {
this.rootElement = options.rootElement;
@@ -166,6 +130,24 @@ const ApplicationInstance = EngineInstance.extend({
return this;
},
+ setupRegistry(options) {
+ let registry = this.__registry__;
+
+ registry.register('-environment:main', options.toEnvironment(), { instantiate: false });
+ registry.injection('view', '_environment', '-environment:main');
+ registry.injection('route', '_environment', '-environment:main');
+
+ registry.register('service:-document', options.document, { instantiate: false });
+
+ if (options.isInteractive) {
+ registry.injection('view', 'renderer', 'renderer:-dom');
+ registry.injection('component', 'renderer', 'renderer:-dom');
+ } else {
+ registry.injection('view', 'renderer', 'renderer:-inert');
+ registry.injection('component', 'renderer', 'renderer:-inert');
+ }
+ },
+
router: computed(function() {
return this.lookup('router:main');
}).readOnly(), | true |
Other | emberjs | ember.js | e087ae693f690e9476156ce68ec09610edcb10b7.json | Move common boot concerns to EngineInstance. | packages/ember-application/lib/system/engine-instance.js | @@ -8,6 +8,7 @@ import Registry from 'container/registry';
import ContainerProxy from 'ember-runtime/mixins/container_proxy';
import RegistryProxy from 'ember-runtime/mixins/registry_proxy';
import run from 'ember-metal/run_loop';
+import RSVP from 'ember-runtime/ext/rsvp';
/**
The `EngineInstance` encapsulates all of the stateful aspects of a
@@ -48,6 +49,53 @@ const EngineInstance = EmberObject.extend(RegistryProxy, ContainerProxy, {
// Create a per-instance container from the instance's registry
this.__container__ = registry.container({ owner: this });
+
+ this._booted = false;
+ },
+
+ /**
+ Initialize the `Ember.EngineInstance` and return a promise that resolves
+ with the instance itself when the boot process is complete.
+
+ The primary task here is to run any registered instance initializers.
+
+ See the documentation on `BootOptions` for the options it takes.
+
+ @private
+ @method boot
+ @param options {Object}
+ @return {Promise<Ember.EngineInstance,Error>}
+ */
+ boot(options = {}) {
+ if (this._bootPromise) { return this._bootPromise; }
+
+ this._bootPromise = new RSVP.Promise(resolve => resolve(this._bootSync(options)));
+
+ return this._bootPromise;
+ },
+
+ /**
+ Unfortunately, a lot of existing code assumes booting an instance is
+ synchronous – specifically, a lot of tests assume the last call to
+ `app.advanceReadiness()` or `app.reset()` will result in a new instance
+ being fully-booted when the current runloop completes.
+
+ We would like new code (like the `visit` API) to stop making this
+ assumption, so we created the asynchronous version above that returns a
+ promise. But until we have migrated all the code, we would have to expose
+ this method for use *internally* in places where we need to boot an instance
+ synchronously.
+
+ @private
+ */
+ _bootSync(options) {
+ if (this._booted) { return this; }
+
+ this.base.runInstanceInitializers(this);
+
+ this._booted = true;
+
+ return this;
},
/** | true |
Other | emberjs | ember.js | 7b925e31bd952f3c8a83cd2cd64cf622c7d26b32.json | Remove unused lookupFactory method | packages/ember-views/lib/component_lookup.js | @@ -1,56 +1,18 @@
import { assert } from 'ember-metal/debug';
import EmberObject from 'ember-runtime/system/object';
-import EmberComponent from 'ember-htmlbars/component';
-import { CONTAINS_DASH_CACHE } from 'ember-htmlbars/system/lookup-helper';
-import { getOwner } from 'container/owner';
export default EmberObject.extend({
- invalidName(name) {
- if (!CONTAINS_DASH_CACHE.get(name)) {
- assert(`You cannot use '${name}' as a component name. Component names must contain a hyphen.`);
- return true;
- }
- },
-
- lookupFactory(name, owner) {
- owner = owner || getOwner(this);
-
- var fullName = 'component:' + name;
- var templateFullName = 'template:components/' + name;
- var templateRegistered = owner && owner.hasRegistration(templateFullName);
-
- if (templateRegistered) {
- owner.inject(fullName, 'layout', templateFullName);
- }
-
- var Component = owner._lookupFactory(fullName);
-
- // Only treat as a component if either the component
- // or a template has been registered.
- if (templateRegistered || Component) {
- if (!Component) {
- owner.register(fullName, EmberComponent);
- Component = owner._lookupFactory(fullName);
- }
- return Component;
- }
- },
-
componentFor(name, owner, options) {
- if (this.invalidName(name)) {
- return;
- }
+ assert(`You cannot use '${name}' as a component name. Component names must contain a hyphen.`, ~name.indexOf('-'));
- var fullName = 'component:' + name;
+ let fullName = 'component:' + name;
return owner._lookupFactory(fullName, options);
},
layoutFor(name, owner, options) {
- if (this.invalidName(name)) {
- return;
- }
+ assert(`You cannot use '${name}' as a component name. Component names must contain a hyphen.`, ~name.indexOf('-'));
- var templateFullName = 'template:components/' + name;
+ let templateFullName = 'template:components/' + name;
return owner.lookup(templateFullName, options);
}
}); | true |
Other | emberjs | ember.js | 7b925e31bd952f3c8a83cd2cd64cf622c7d26b32.json | Remove unused lookupFactory method | packages/ember-views/lib/streams/utils.js | @@ -21,18 +21,6 @@ export function readViewFactory(object, owner) {
return viewClass;
}
-export function readComponentFactory(nameOrStream, owner) {
- var name = read(nameOrStream);
- var componentLookup = owner.lookup('component-lookup:main');
- assert(
- 'Could not find \'component-lookup:main\' on the provided container, ' +
- 'which is necessary for performing component lookups',
- componentLookup
- );
-
- return componentLookup.lookupFactory(name, owner);
-}
-
export function readUnwrappedModel(object) {
if (isStream(object)) {
var result = object.value(); | true |
Other | emberjs | ember.js | 00e517f36eba5db96f420f758647e53d233780a0.json | Verify registry built for Ember.Application. | packages/ember-application/tests/system/application_test.js | @@ -1,6 +1,7 @@
/*globals EmberDev */
import VERSION from 'ember/version';
import { ENV, context } from 'ember-environment';
+import isEnabled from 'ember-metal/features';
import run from 'ember-metal/run_loop';
import libraries from 'ember-metal/libraries';
import Application, { _resetLegacyAddonWarnings } from 'ember-application/system/application';
@@ -17,6 +18,8 @@ import compile from 'ember-template-compiler/system/compile';
import { _loaded } from 'ember-runtime/system/lazy_load';
import { getDebugFunction, setDebugFunction } from 'ember-metal/debug';
import { setTemplates, set as setTemplate } from 'ember-htmlbars/template_registry';
+import { privatize as P } from 'container/registry';
+import { verifyInjection, verifyRegistration } from '../test-helpers/registry-check';
var trim = jQuery.trim;
@@ -118,6 +121,74 @@ QUnit.test('includes deprecated access to `application.registry`', function() {
}, /Using `Application.registry.register` is deprecated. Please use `Application.register` instead./);
});
+QUnit.test('builds a registry', function() {
+ strictEqual(application.resolveRegistration('application:main'), application, `application:main is registered`);
+ deepEqual(application.registeredOptionsForType('component'), { singleton: false }, `optionsForType 'component'`);
+ deepEqual(application.registeredOptionsForType('view'), { singleton: false }, `optionsForType 'view'`);
+ verifyInjection(application, 'renderer', 'dom', 'service:-dom-helper');
+ verifyRegistration(application, 'controller:basic');
+ verifyInjection(application, 'service:-dom-helper', 'document', 'service:-document');
+ verifyRegistration(application, '-view-registry:main');
+ verifyInjection(application, 'view', '_viewRegistry', '-view-registry:main');
+ verifyInjection(application, 'route', '_topLevelViewTemplate', 'template:-outlet');
+ verifyRegistration(application, 'route:basic');
+ verifyRegistration(application, 'event_dispatcher:main');
+ verifyInjection(application, 'router:main', 'namespace', 'application:main');
+ verifyInjection(application, 'view:-outlet', 'namespace', 'application:main');
+
+ verifyRegistration(application, 'location:auto');
+ verifyRegistration(application, 'location:hash');
+ verifyRegistration(application, 'location:history');
+ verifyRegistration(application, 'location:none');
+
+ verifyInjection(application, 'controller', 'target', 'router:main');
+ verifyInjection(application, 'controller', 'namespace', 'application:main');
+
+ verifyRegistration(application, P`-bucket-cache:main`);
+ verifyInjection(application, 'router', '_bucketCache', P`-bucket-cache:main`);
+ verifyInjection(application, 'route', '_bucketCache', P`-bucket-cache:main`);
+ verifyInjection(application, 'controller', '_bucketCache', P`-bucket-cache:main`);
+
+ verifyInjection(application, 'route', 'router', 'router:main');
+
+ verifyRegistration(application, 'component:-text-field');
+ verifyRegistration(application, 'component:-text-area');
+ verifyRegistration(application, 'component:-checkbox');
+ verifyRegistration(application, 'component:link-to');
+
+ verifyRegistration(application, 'service:-routing');
+ verifyInjection(application, 'service:-routing', 'router', 'router:main');
+
+ // DEBUGGING
+ verifyRegistration(application, 'resolver-for-debugging:main');
+ verifyInjection(application, 'container-debug-adapter:main', 'resolver', 'resolver-for-debugging:main');
+ verifyInjection(application, 'data-adapter:main', 'containerDebugAdapter', 'container-debug-adapter:main');
+ verifyRegistration(application, 'container-debug-adapter:main');
+
+ if (isEnabled('ember-glimmer')) {
+ verifyRegistration(application, 'service:-glimmer-environment');
+ verifyInjection(application, 'service:-glimmer-environment', 'dom', 'service:-dom-helper');
+ verifyInjection(application, 'renderer', 'env', 'service:-glimmer-environment');
+ verifyRegistration(application, 'view:-outlet');
+ verifyRegistration(application, 'renderer:-dom');
+ verifyRegistration(application, 'renderer:-inert');
+ verifyRegistration(application, 'service:-dom-helper');
+ verifyRegistration(application, P`template:components/-default`);
+ verifyRegistration(application, 'template:-outlet');
+ verifyInjection(application, 'view:-outlet', 'template', 'template:-outlet');
+ verifyInjection(application, 'template', 'env', 'service:-glimmer-environment');
+ deepEqual(application.registeredOptionsForType('helper'), { instantiate: false }, `optionsForType 'helper'`);
+ } else {
+ deepEqual(application.registeredOptionsForType('template'), { instantiate: false }, `optionsForType 'template'`);
+ verifyRegistration(application, 'view:-outlet');
+ verifyRegistration(application, 'renderer:-dom');
+ verifyRegistration(application, 'renderer:-inert');
+ verifyRegistration(application, 'service:-dom-helper');
+ verifyRegistration(application, 'template:-outlet');
+ verifyRegistration(application, 'view:toplevel');
+ }
+});
+
const originalLogVersion = ENV.LOG_VERSION;
QUnit.module('Ember.Application initialization', { | false |
Other | emberjs | ember.js | 32746fb694bfd70ca1f36bc6c0bdaafe78b43e36.json | Add failing test for protected attrs with no value
See https://github.com/tildeio/htmlbars/pull/455
This test demonstrates that with the current version of htmlbars bound
view attributes requiring sanitization will throw an error in node if
their value is undefined. | tests/node/component-rendering-test.js | @@ -44,6 +44,17 @@ QUnit.test("Component with dynamic value", function(assert) {
assert.ok(html.match(/<h1>Hello World<\/h1>/));
});
+QUnit.test("Ensure undefined attributes requiring protocol sanitization do not error", function(assert) {
+ var component = buildComponent('', {
+ tagName: 'link',
+ attributeBindings: ['href', 'rel'],
+ rel: 'canonical'
+ });
+
+ var html = renderComponent(component);
+ assert.ok(html.match(/rel="canonical"/));
+});
+
function buildComponent(template, props) {
var Component = Ember.Component.extend({
renderer: new Ember._Renderer(new DOMHelper(new SimpleDOM.Document())), | false |
Other | emberjs | ember.js | 15e31d665ecc21786cbf0f5599562d7a4f6536be.json | Add 2.6.0-beta.4 to CHANGELOG.md.
[ci skip]
(cherry picked from commit 60fc7dfff785d7d6a6770f57fe9447c5e59d8efd) | CHANGELOG.md | @@ -1,5 +1,12 @@
# Ember Changelog
+### 2.6.0-beta.4 (May 09, 2016)
+
+- [#13442](https://github.com/emberjs/ember.js/pull/13442) [BUGFIX] Revert `Ember.Handlebars.SafeString` deprecation.
+- [#13449](https://github.com/emberjs/ember.js/pull/13449) [BUGFIX] Ensure that `Ember.get(null, 'foo')` returns `undefined`.
+- [#13465](https://github.com/emberjs/ember.js/pull/13465) [BUGFIX] Propagate loc information for inline link-to transform.
+- [#13461](https://github.com/emberjs/ember.js/pull/13461) [BUGFIX] Prevent `Ember.get` from attempting to retrieve properties on primitive objects.
+
### 2.6.0-beta.3 (May 02, 2016)
- [#13418](https://github.com/emberjs/ember.js/pull/13418) [BUGFIX] Ensure that passing `run.later` a timeout value of `NaN` does not break all future | false |
Other | emberjs | ember.js | 714b3d73d0e0f05d1c5a47def21c568686428ba3.json | Add test for parameterless helper invocation. | packages/ember-glimmer/tests/integration/helpers/custom-helper-test.js | @@ -282,6 +282,30 @@ moduleFor('Helpers test: custom helpers', class extends RenderingTest {
this.assertText('Who overcomes by force hath overcome but half his foe');
}
+ ['@test parameterless helper is usable in subexpressions']() {
+ this.registerHelper('should-show', () => { return true; });
+
+ this.render(`{{#if (should-show)}}true{{/if}}`);
+
+ this.assertText('true');
+
+ this.runTask(() => this.rerender());
+
+ this.assertText('true');
+ }
+
+ ['@glimmer parameterless helper is usable in attributes']() {
+ this.registerHelper('foo-bar', () => { return 'baz'; });
+
+ this.render(`<div data-foo-bar="{{foo-bar}}"></div>`);
+
+ this.assertHTML('<div data-foo-bar="baz"></div>');
+
+ this.runTask(() => this.rerender());
+
+ this.assertHTML('<div data-foo-bar="baz"></div>');
+ }
+
['@test simple helper not usable with a block']() {
this.registerHelper('some-helper', () => {});
| false |
Other | emberjs | ember.js | 34d0d2ebd14a90629f37ef6ea8d4ab3807ea4f90.json | Add 2.6.0-beta.3 to CHANGELOG.md.
[ci skip]
(cherry picked from commit e737eee8060d941ad96da1f08d49ac2b360452e7) | CHANGELOG.md | @@ -1,5 +1,13 @@
# Ember Changelog
+### 2.6.0-beta.3 (May 02, 2016)
+
+- [#13418](https://github.com/emberjs/ember.js/pull/13418) [BUGFIX] Ensure that passing `run.later` a timeout value of `NaN` does not break all future
+ timers.
+- [#13435](https://github.com/emberjs/ember.js/pull/13435) [BUGFIX] Fix positional parameters when used with component helper.
+- [#13438](https://github.com/emberjs/ember.js/pull/13438) [BUGFIX] Ensure custom components extending from `Ember.LinkComponent` can operate
+ in both block and inline form.
+
### 2.6.0-beta.2 (April 27, 2016)
- [#13356](https://github.com/emberjs/ember.js/pull/13356) [BUGFIX] Update `Registry#has` to always return true/false. | false |
Other | emberjs | ember.js | 158158364999302d1309b2135f7b46218496007f.json | Implement remaining lifecycle hooks
The original implementation of the hooks in HTMLBars does a deeper walk
than necessary (using the AlwaysDirty validator), resulting in executing
the experimental "new hooks" too often.
In particular, hooks were executed downstream from the original call to
`rerender()` even if the rerendering component did not use `this.set()`
to update the arguments of downstream components.
Because Glimmer uses a pull-based model instead of a blunt push-based
model, we can avoid a deeper traversal than is necessary. | package.json | @@ -38,7 +38,7 @@
"express": "^4.5.0",
"finalhandler": "^0.4.0",
"github": "^0.2.3",
- "glimmer-engine": "tildeio/glimmer#591a188",
+ "glimmer-engine": "tildeio/glimmer#2c22999",
"glob": "^5.0.13",
"htmlbars": "0.14.16",
"mocha": "^2.4.5", | true |
Other | emberjs | ember.js | 158158364999302d1309b2135f7b46218496007f.json | Implement remaining lifecycle hooks
The original implementation of the hooks in HTMLBars does a deeper walk
than necessary (using the AlwaysDirty validator), resulting in executing
the experimental "new hooks" too often.
In particular, hooks were executed downstream from the original call to
`rerender()` even if the rerendering component did not use `this.set()`
to update the arguments of downstream components.
Because Glimmer uses a pull-based model instead of a blunt push-based
model, we can avoid a deeper traversal than is necessary. | packages/ember-glimmer/lib/components/curly-component.js | @@ -1,5 +1,6 @@
import { StatementSyntax, ValueReference } from 'glimmer-runtime';
import { AttributeBindingReference, RootReference, applyClassNameBinding } from '../utils/references';
+import { DIRTY_TAG } from '../ember-views/component';
import EmptyObject from 'ember-metal/empty_object';
export class CurlyComponentSyntax extends StatementSyntax {
@@ -19,7 +20,7 @@ export class CurlyComponentSyntax extends StatementSyntax {
function attrsToProps(keys, attrs) {
let merged = new EmptyObject();
- merged.attrs = merged;
+ merged.attrs = attrs;
for (let i = 0, l = keys.length; i < l; i++) {
let name = keys[i];
@@ -32,9 +33,10 @@ function attrsToProps(keys, attrs) {
}
class ComponentStateBucket {
- constructor(component) {
+ constructor(component, args) {
this.component = component;
this.classRef = null;
+ this.argsRevision = args.tag.value();
}
}
@@ -46,17 +48,19 @@ class CurlyComponentManager {
let attrs = args.named.value();
let props = attrsToProps(args.named.keys, attrs);
+ props.renderer = parentView.renderer;
+
let component = klass.create(props);
dynamicScope.view = component;
parentView.appendChild(component);
- // component.trigger('didInitAttrs', { attrs });
- // component.trigger('didReceiveAttrs', { newAttrs: attrs });
- // component.trigger('willInsertElement');
- // component.trigger('willRender');
+ component.trigger('didInitAttrs', { attrs });
+ component.trigger('didReceiveAttrs', { newAttrs: attrs });
+ component.trigger('willInsertElement');
+ component.trigger('willRender');
- let bucket = new ComponentStateBucket(component);
+ let bucket = new ComponentStateBucket(component, args);
if (args.named.has('class')) {
bucket.classRef = args.named.get('class');
@@ -99,30 +103,41 @@ class CurlyComponentManager {
component._transitionTo('hasElement');
}
+ getTag({ component }) {
+ return component[DIRTY_TAG];
+ }
+
didCreate({ component }) {
component.trigger('didInsertElement');
- // component.trigger('didRender');
+ component.trigger('didRender');
component._transitionTo('inDOM');
}
- update({ component }, args, dynamicScope) {
- let attrs = args.named.value();
- let props = attrsToProps(args.named.keys, attrs);
+ update(bucket, args, dynamicScope) {
+ let { component, argsRevision } = bucket;
- // let oldAttrs = component.attrs;
- // let newAttrs = attrs;
+ if (!args.tag.validate(argsRevision)) {
+ bucket.argsRevision = args.tag.value();
- component.setProperties(props);
+ let attrs = args.named.value();
+ let props = attrsToProps(args.named.keys, attrs);
+
+ let oldAttrs = component.attrs;
+ let newAttrs = attrs;
+
+ component.setProperties(props);
+
+ component.trigger('didUpdateAttrs', { oldAttrs, newAttrs });
+ component.trigger('didReceiveAttrs', { oldAttrs, newAttrs });
+ }
- // component.trigger('didUpdateAttrs', { oldAttrs, newAttrs });
- // component.trigger('didReceiveAttrs', { oldAttrs, newAttrs });
- // component.trigger('willUpdate');
- // component.trigger('willRender');
+ component.trigger('willUpdate');
+ component.trigger('willRender');
}
didUpdate({ component }) {
- // component.trigger('didUpdate');
- // component.trigger('didRender');
+ component.trigger('didUpdate');
+ component.trigger('didRender');
}
getDestructor({ component }) { | true |
Other | emberjs | ember.js | 158158364999302d1309b2135f7b46218496007f.json | Implement remaining lifecycle hooks
The original implementation of the hooks in HTMLBars does a deeper walk
than necessary (using the AlwaysDirty validator), resulting in executing
the experimental "new hooks" too often.
In particular, hooks were executed downstream from the original call to
`rerender()` even if the rerendering component did not use `this.set()`
to update the arguments of downstream components.
Because Glimmer uses a pull-based model instead of a blunt push-based
model, we can avoid a deeper traversal than is necessary. | packages/ember-glimmer/lib/components/outlet.js | @@ -100,6 +100,10 @@ class AbstractOutletComponentManager {
return new RootReference(state.render.controller);
}
+ getTag(state) {
+ return null;
+ }
+
getDestructor(state) {
return null;
} | true |
Other | emberjs | ember.js | 158158364999302d1309b2135f7b46218496007f.json | Implement remaining lifecycle hooks
The original implementation of the hooks in HTMLBars does a deeper walk
than necessary (using the AlwaysDirty validator), resulting in executing
the experimental "new hooks" too often.
In particular, hooks were executed downstream from the original call to
`rerender()` even if the rerendering component did not use `this.set()`
to update the arguments of downstream components.
Because Glimmer uses a pull-based model instead of a blunt push-based
model, we can avoid a deeper traversal than is necessary. | packages/ember-glimmer/lib/ember-metal-views/index.js | @@ -61,8 +61,15 @@ class Renderer {
}
remove(view) {
+ view.trigger('willDestroyElement');
view._transitionTo('destroying');
- view['_renderResult'].destroy();
+
+ let { _renderResult } = view;
+
+ if (_renderResult) {
+ _renderResult.destroy();
+ }
+
view.destroy();
}
| true |
Other | emberjs | ember.js | 158158364999302d1309b2135f7b46218496007f.json | Implement remaining lifecycle hooks
The original implementation of the hooks in HTMLBars does a deeper walk
than necessary (using the AlwaysDirty validator), resulting in executing
the experimental "new hooks" too often.
In particular, hooks were executed downstream from the original call to
`rerender()` even if the rerendering component did not use `this.set()`
to update the arguments of downstream components.
Because Glimmer uses a pull-based model instead of a blunt push-based
model, we can avoid a deeper traversal than is necessary. | packages/ember-glimmer/lib/ember-views/component.js | @@ -6,6 +6,10 @@ import InstrumentationSupport from 'ember-views/mixins/instrumentation_support';
import AriaRoleSupport from 'ember-views/mixins/aria_role_support';
import ViewMixin from 'ember-views/mixins/view_support';
import EmberView from 'ember-views/views/view';
+import symbol from 'ember-metal/symbol';
+import { DirtyableTag } from 'glimmer-reference';
+
+export const DIRTY_TAG = symbol('DIRTY_TAG');
export default CoreView.extend(
ChildViewsSupport,
@@ -22,6 +26,12 @@ export default CoreView.extend(
init() {
this._super(...arguments);
this._viewRegistry = this._viewRegistry || EmberView.views;
+ this[DIRTY_TAG] = new DirtyableTag();
+ },
+
+ rerender() {
+ this[DIRTY_TAG].dirty();
+ this._super();
},
__defineNonEnumerable(property) { | true |
Other | emberjs | ember.js | 158158364999302d1309b2135f7b46218496007f.json | Implement remaining lifecycle hooks
The original implementation of the hooks in HTMLBars does a deeper walk
than necessary (using the AlwaysDirty validator), resulting in executing
the experimental "new hooks" too often.
In particular, hooks were executed downstream from the original call to
`rerender()` even if the rerendering component did not use `this.set()`
to update the arguments of downstream components.
Because Glimmer uses a pull-based model instead of a blunt push-based
model, we can avoid a deeper traversal than is necessary. | packages/ember-glimmer/lib/environment.js | @@ -26,8 +26,9 @@ import { default as get } from './helpers/get';
import { default as hash } from './helpers/hash';
import { default as loc } from './helpers/loc';
import { default as log } from './helpers/log';
-import { default as classHelper } from './helpers/-class';
+import { default as readonly } from './helpers/readonly';
import { default as unbound } from './helpers/unbound';
+import { default as classHelper } from './helpers/-class';
import { OWNER } from 'container/owner';
const builtInHelpers = {
@@ -38,6 +39,7 @@ const builtInHelpers = {
hash,
loc,
log,
+ readonly,
unbound,
'-class': classHelper
};
@@ -163,6 +165,11 @@ export default class Environment extends GlimmerEnvironment {
return createIterable(ref, keyPath);
}
+ didCreate(component, manager) {
+ this.createdComponents.unshift(component);
+ this.createdManagers.unshift(manager);
+ }
+
didDestroy(destroyable) {
destroyable.destroy();
} | true |
Other | emberjs | ember.js | 158158364999302d1309b2135f7b46218496007f.json | Implement remaining lifecycle hooks
The original implementation of the hooks in HTMLBars does a deeper walk
than necessary (using the AlwaysDirty validator), resulting in executing
the experimental "new hooks" too often.
In particular, hooks were executed downstream from the original call to
`rerender()` even if the rerendering component did not use `this.set()`
to update the arguments of downstream components.
Because Glimmer uses a pull-based model instead of a blunt push-based
model, we can avoid a deeper traversal than is necessary. | packages/ember-glimmer/lib/helpers/readonly.js | @@ -0,0 +1,7 @@
+import { helper } from '../helper';
+
+function readonly(args) {
+ return args[0];
+}
+
+export default helper(readonly); | true |
Other | emberjs | ember.js | 158158364999302d1309b2135f7b46218496007f.json | Implement remaining lifecycle hooks
The original implementation of the hooks in HTMLBars does a deeper walk
than necessary (using the AlwaysDirty validator), resulting in executing
the experimental "new hooks" too often.
In particular, hooks were executed downstream from the original call to
`rerender()` even if the rerendering component did not use `this.set()`
to update the arguments of downstream components.
Because Glimmer uses a pull-based model instead of a blunt push-based
model, we can avoid a deeper traversal than is necessary. | packages/ember-glimmer/tests/integration/components/life-cycle-test.js | @@ -0,0 +1,543 @@
+import { set } from 'ember-metal/property_set';
+import { Component } from '../../utils/helpers';
+import { strip } from '../../utils/abstract-test-case';
+import { moduleFor, RenderingTest } from '../../utils/test-case';
+
+class LifeCycleHooksTest extends RenderingTest {
+ constructor() {
+ super();
+ this.hooks = [];
+ this.components = {};
+ }
+
+ /* abstract */
+ get ComponentClass() {
+ throw new Error('Not implemented: `ComponentClass`');
+ }
+
+ /* abstract */
+ invocationFor(name, namedArgs = {}) {
+ throw new Error('Not implemented: `invocationFor`');
+ }
+
+ /* abstract */
+ attrFor(name) {
+ throw new Error('Not implemented: `attrFor`');
+ }
+
+ get boundHelpers() {
+ return {
+ invoke: bind(this.invocationFor, this),
+ attr: bind(this.attrFor, this)
+ };
+ }
+
+ registerComponent(name, { template = null }) {
+ let pushComponent = (instance) => {
+ this.components[name] = instance;
+ };
+
+ let pushHook = (hookName, args) => {
+ this.hooks.push(hook(name, hookName, args));
+ };
+
+ let ComponentClass = this.ComponentClass.extend({
+ init() {
+ expectDeprecation(() => { this._super(...arguments); },
+ /didInitAttrs called/);
+
+ pushHook('init');
+ pushComponent(this);
+ },
+
+ didInitAttrs(options) {
+ pushHook('didInitAttrs', options);
+ },
+
+ didUpdateAttrs(options) {
+ pushHook('didUpdateAttrs', options);
+ },
+
+ willUpdate(options) {
+ pushHook('willUpdate', options);
+ },
+
+ didReceiveAttrs(options) {
+ pushHook('didReceiveAttrs', options);
+ },
+
+ willRender() {
+ pushHook('willRender');
+ },
+
+ didRender() {
+ pushHook('didRender');
+ },
+
+ didInsertElement() {
+ pushHook('didInsertElement');
+ },
+
+ didUpdate(options) {
+ pushHook('didUpdate', options);
+ }
+ });
+
+ super.registerComponent(name, { ComponentClass, template });
+ }
+
+ assertHooks(label, ...rawHooks) {
+ let hooks = rawHooks.map(raw => hook(...raw));
+ this.assert.deepEqual(json(this.hooks), json(hooks), label);
+ this.hooks = [];
+ }
+
+ ['@test lifecycle hooks are invoked in a predictable order']() {
+ let { attr, invoke } = this.boundHelpers;
+
+ this.registerComponent('the-top', { template: strip`
+ <div>
+ Twitter: {{${attr('twitter')}}}|
+ ${invoke('the-middle', { name: string('Tom Dale') })}
+ </div>`
+ });
+
+ this.registerComponent('the-middle', { template: strip`
+ <div>
+ Name: {{${attr('name')}}}|
+ ${invoke('the-bottom', { website: string('tomdale.net') })}
+ </div>`
+ });
+
+ this.registerComponent('the-bottom', { template: strip`
+ <div>
+ Website: {{${attr('website')}}}
+ </div>`
+ });
+
+ this.render(invoke('the-top', { twitter: expr('twitter') }), { twitter: '@tomdale' });
+
+ this.assertText('Twitter: @tomdale|Name: Tom Dale|Website: tomdale.net');
+
+ let topAttrs = { twitter: '@tomdale' };
+ let middleAttrs = { name: 'Tom Dale' };
+ let bottomAttrs = { website: 'tomdale.net' };
+
+ this.assertHooks(
+
+ 'after initial render',
+
+ // Sync hooks
+
+ ['the-top', 'init'],
+ ['the-top', 'didInitAttrs', { attrs: topAttrs }],
+ ['the-top', 'didReceiveAttrs', { newAttrs: topAttrs }],
+ ['the-top', 'willRender'],
+
+ ['the-middle', 'init'],
+ ['the-middle', 'didInitAttrs', { attrs: middleAttrs }],
+ ['the-middle', 'didReceiveAttrs', { newAttrs: middleAttrs }],
+ ['the-middle', 'willRender'],
+
+ ['the-bottom', 'init'],
+ ['the-bottom', 'didInitAttrs', { attrs: bottomAttrs }],
+ ['the-bottom', 'didReceiveAttrs', { newAttrs: bottomAttrs }],
+ ['the-bottom', 'willRender'],
+
+ // Async hooks
+
+ ['the-bottom', 'didInsertElement'],
+ ['the-bottom', 'didRender'],
+
+ ['the-middle', 'didInsertElement'],
+ ['the-middle', 'didRender'],
+
+ ['the-top', 'didInsertElement'],
+ ['the-top', 'didRender']
+
+ );
+
+ this.runTask(() => this.components['the-bottom'].rerender());
+
+ this.assertText('Twitter: @tomdale|Name: Tom Dale|Website: tomdale.net');
+
+ this.assertHooks(
+
+ 'after no-op rerender (bottom)',
+
+ // Sync hooks
+
+ ['the-bottom', 'willUpdate'],
+ ['the-bottom', 'willRender'],
+
+ // Async hooks
+
+ ['the-bottom', 'didUpdate'],
+ ['the-bottom', 'didRender']
+
+ );
+
+ this.runTask(() => this.components['the-middle'].rerender());
+
+ this.assertText('Twitter: @tomdale|Name: Tom Dale|Website: tomdale.net');
+
+ bottomAttrs = { oldAttrs: { website: 'tomdale.net' }, newAttrs: { website: 'tomdale.net' } };
+
+ // The original implementation of the hooks in HTMLBars does a
+ // deeper walk than necessary (using the AlwaysDirty validator),
+ // resulting in executing the experimental "new hooks" too often.
+ //
+ // In particular, hooks were executed downstream from the original
+ // call to `rerender()` even if the rerendering component did not
+ // use `this.set()` to update the arguments of downstream components.
+ //
+ // Because Glimmer uses a pull-based model instead of a blunt
+ // push-based model, we can avoid a deeper traversal than is
+ // necessary.
+
+ if (this.isHTMLBars) {
+ this.assertHooks(
+
+ 'after no-op rerender (middle)',
+
+ // Sync hooks
+
+ ['the-middle', 'willUpdate'],
+ ['the-middle', 'willRender'],
+
+ ['the-bottom', 'didUpdateAttrs', bottomAttrs],
+ ['the-bottom', 'didReceiveAttrs', bottomAttrs],
+
+ ['the-bottom', 'willUpdate'],
+ ['the-bottom', 'willRender'],
+
+ // Async hooks
+
+ ['the-bottom', 'didUpdate'],
+ ['the-bottom', 'didRender'],
+
+ ['the-middle', 'didUpdate'],
+ ['the-middle', 'didRender']
+
+ );
+ } else {
+ this.assertHooks(
+
+ 'after no-op rerender (middle)',
+
+ // Sync hooks
+
+ ['the-middle', 'willUpdate'],
+ ['the-middle', 'willRender'],
+
+ // Async hooks
+
+ ['the-middle', 'didUpdate'],
+ ['the-middle', 'didRender']
+
+ );
+ }
+
+ this.runTask(() => this.components['the-top'].rerender());
+
+ this.assertText('Twitter: @tomdale|Name: Tom Dale|Website: tomdale.net');
+
+ middleAttrs = { oldAttrs: { name: 'Tom Dale' }, newAttrs: { name: 'Tom Dale' } };
+
+
+ if (this.isHTMLBars) {
+ this.assertHooks(
+
+ 'after no-op rerender (top)',
+
+ // Sync hooks
+
+ ['the-top', 'willUpdate'],
+ ['the-top', 'willRender'],
+
+ ['the-middle', 'didUpdateAttrs', middleAttrs],
+ ['the-middle', 'didReceiveAttrs', middleAttrs],
+
+ ['the-middle', 'willUpdate'],
+ ['the-middle', 'willRender'],
+
+ ['the-bottom', 'didUpdateAttrs', bottomAttrs],
+ ['the-bottom', 'didReceiveAttrs', bottomAttrs],
+
+ ['the-bottom', 'willUpdate'],
+ ['the-bottom', 'willRender'],
+
+ // Async hooks
+
+ ['the-bottom', 'didUpdate'],
+ ['the-bottom', 'didRender'],
+
+ ['the-middle', 'didUpdate'],
+ ['the-middle', 'didRender'],
+
+ ['the-top', 'didUpdate'],
+ ['the-top', 'didRender']
+
+ );
+ } else {
+ this.assertHooks(
+
+ 'after no-op rerender (top)',
+
+ // Sync hooks
+
+ ['the-top', 'willUpdate'],
+ ['the-top', 'willRender'],
+
+ // Async hooks
+
+ ['the-top', 'didUpdate'],
+ ['the-top', 'didRender']
+
+ );
+ }
+
+ this.runTask(() => set(this.context, 'twitter', '@horsetomdale'));
+
+ this.assertText('Twitter: @horsetomdale|Name: Tom Dale|Website: tomdale.net');
+
+ // Because the `twitter` attr is only used by the topmost component,
+ // and not passed down, we do not expect to see lifecycle hooks
+ // called for child components. If the `didReceiveAttrs` hook used
+ // the new attribute to rerender itself imperatively, that would result
+ // in lifecycle hooks being invoked for the child.
+
+ topAttrs = { oldAttrs: { twitter: '@tomdale' }, newAttrs: { twitter: '@horsetomdale' } };
+
+ this.assertHooks(
+
+ 'after update',
+
+ // Sync hooks
+
+ ['the-top', 'didUpdateAttrs', topAttrs],
+ ['the-top', 'didReceiveAttrs', topAttrs],
+
+ ['the-top', 'willUpdate'],
+ ['the-top', 'willRender'],
+
+ // Async hooks
+
+ ['the-top', 'didUpdate'],
+ ['the-top', 'didRender']
+
+ );
+ }
+
+ ['@test passing values through attrs causes lifecycle hooks to fire if the attribute values have changed']() {
+ let { attr, invoke } = this.boundHelpers;
+
+ this.registerComponent('the-top', { template: strip`
+ <div>
+ Top: ${invoke('the-middle', { twitterTop: expr(attr('twitter')) })}
+ </div>`
+ });
+
+ this.registerComponent('the-middle', { template: strip`
+ <div>
+ Middle: ${invoke('the-bottom', { twitterMiddle: expr(attr('twitterTop')) })}
+ </div>`
+ });
+
+ this.registerComponent('the-bottom', { template: strip`
+ <div>
+ Bottom: {{${attr('twitterMiddle')}}}
+ </div>`
+ });
+
+ this.render(invoke('the-top', { twitter: expr('twitter') }), { twitter: '@tomdale' });
+
+ this.assertText('Top: Middle: Bottom: @tomdale');
+
+ let topAttrs = { twitter: '@tomdale' };
+ let middleAttrs = { twitterTop: '@tomdale' };
+ let bottomAttrs = { twitterMiddle: '@tomdale' };
+
+ this.assertHooks(
+
+ 'after initial render',
+
+ // Sync hooks
+
+ ['the-top', 'init'],
+ ['the-top', 'didInitAttrs', { attrs: topAttrs }],
+ ['the-top', 'didReceiveAttrs', { newAttrs: topAttrs }],
+ ['the-top', 'willRender'],
+
+ ['the-middle', 'init'],
+ ['the-middle', 'didInitAttrs', { attrs: middleAttrs }],
+ ['the-middle', 'didReceiveAttrs', { newAttrs: middleAttrs }],
+ ['the-middle', 'willRender'],
+
+ ['the-bottom', 'init'],
+ ['the-bottom', 'didInitAttrs', { attrs: bottomAttrs }],
+ ['the-bottom', 'didReceiveAttrs', { newAttrs: bottomAttrs }],
+ ['the-bottom', 'willRender'],
+
+ // Async hooks
+
+ ['the-bottom', 'didInsertElement'],
+ ['the-bottom', 'didRender'],
+
+ ['the-middle', 'didInsertElement'],
+ ['the-middle', 'didRender'],
+
+ ['the-top', 'didInsertElement'],
+ ['the-top', 'didRender']
+
+ );
+
+ this.runTask(() => set(this.context, 'twitter', '@horsetomdale'));
+
+ this.assertText('Top: Middle: Bottom: @horsetomdale');
+
+ // Because the `twitter` attr is used by the all of the components,
+ // the lifecycle hooks are invoked for all components.
+
+ topAttrs = { oldAttrs: { twitter: '@tomdale' }, newAttrs: { twitter: '@horsetomdale' } };
+ middleAttrs = { oldAttrs: { twitterTop: '@tomdale' }, newAttrs: { twitterTop: '@horsetomdale' } };
+ bottomAttrs = { oldAttrs: { twitterMiddle: '@tomdale' }, newAttrs: { twitterMiddle: '@horsetomdale' } };
+
+ this.assertHooks(
+
+ 'after updating (root)',
+
+ // Sync hooks
+
+ ['the-top', 'didUpdateAttrs', topAttrs],
+ ['the-top', 'didReceiveAttrs', topAttrs],
+
+ ['the-top', 'willUpdate'],
+ ['the-top', 'willRender'],
+
+ ['the-middle', 'didUpdateAttrs', middleAttrs],
+ ['the-middle', 'didReceiveAttrs', middleAttrs],
+
+ ['the-middle', 'willUpdate'],
+ ['the-middle', 'willRender'],
+
+ ['the-bottom', 'didUpdateAttrs', bottomAttrs],
+ ['the-bottom', 'didReceiveAttrs', bottomAttrs],
+
+ ['the-bottom', 'willUpdate'],
+ ['the-bottom', 'willRender'],
+
+ // Async hooks
+
+ ['the-bottom', 'didUpdate'],
+ ['the-bottom', 'didRender'],
+
+ ['the-middle', 'didUpdate'],
+ ['the-middle', 'didRender'],
+
+ ['the-top', 'didUpdate'],
+ ['the-top', 'didRender']
+
+ );
+
+ this.runTask(() => this.rerender());
+
+ this.assertText('Top: Middle: Bottom: @horsetomdale');
+
+ // In this case, because the attrs are passed down, all child components are invoked.
+
+ topAttrs = { oldAttrs: { twitter: '@horsetomdale' }, newAttrs: { twitter: '@horsetomdale' } };
+ middleAttrs = { oldAttrs: { twitterTop: '@horsetomdale' }, newAttrs: { twitterTop: '@horsetomdale' } };
+ bottomAttrs = { oldAttrs: { twitterMiddle: '@horsetomdale' }, newAttrs: { twitterMiddle: '@horsetomdale' } };
+
+ if (this.isHTMLBars) {
+ this.assertHooks(
+
+ 'after no-op rernder (root)',
+
+ // Sync hooks
+
+ ['the-top', 'didUpdateAttrs', topAttrs],
+ ['the-top', 'didReceiveAttrs', topAttrs],
+
+ ['the-top', 'willUpdate'],
+ ['the-top', 'willRender'],
+
+ ['the-middle', 'didUpdateAttrs', middleAttrs],
+ ['the-middle', 'didReceiveAttrs', middleAttrs],
+
+ ['the-middle', 'willUpdate'],
+ ['the-middle', 'willRender'],
+
+ ['the-bottom', 'didUpdateAttrs', bottomAttrs],
+ ['the-bottom', 'didReceiveAttrs', bottomAttrs],
+
+ ['the-bottom', 'willUpdate'],
+ ['the-bottom', 'willRender'],
+
+ // Async hooks
+
+ ['the-bottom', 'didUpdate'],
+ ['the-bottom', 'didRender'],
+
+ ['the-middle', 'didUpdate'],
+ ['the-middle', 'didRender'],
+
+ ['the-top', 'didUpdate'],
+ ['the-top', 'didRender']
+
+ );
+ } else {
+ this.assertHooks('after no-op rernder (root)');
+ }
+ }
+
+}
+
+moduleFor('Components test: lifecycle hooks (curly components)', class extends LifeCycleHooksTest {
+
+ get ComponentClass() {
+ return Component;
+ }
+
+ invocationFor(name, namedArgs = {}) {
+ let attrs = Object.keys(namedArgs).map(k => `${k}=${this.val(namedArgs[k])}`).join(' ');
+ return `{{${name} ${attrs}}}`;
+ }
+
+ attrFor(name) {
+ return `${name}`;
+ }
+
+ /* private */
+ val(value) {
+ if (value.isString) {
+ return JSON.stringify(value.value);
+ } else if (value.isExpr) {
+ return `(readonly ${value.value})`;
+ } else {
+ throw new Error(`Unknown value: ${value}`);
+ }
+ }
+
+});
+
+function bind(func, thisArg) {
+ return (...args) => func.apply(thisArg, args);
+}
+
+function string(value) {
+ return { isString: true, value };
+}
+
+function expr(value) {
+ return { isExpr: true, value };
+}
+
+function hook(name, hook, args) {
+ return { name, hook, args };
+}
+
+function json(serializable) {
+ return JSON.parse(JSON.stringify(serializable));
+} | true |
Other | emberjs | ember.js | 158158364999302d1309b2135f7b46218496007f.json | Implement remaining lifecycle hooks
The original implementation of the hooks in HTMLBars does a deeper walk
than necessary (using the AlwaysDirty validator), resulting in executing
the experimental "new hooks" too often.
In particular, hooks were executed downstream from the original call to
`rerender()` even if the rerendering component did not use `this.set()`
to update the arguments of downstream components.
Because Glimmer uses a pull-based model instead of a blunt push-based
model, we can avoid a deeper traversal than is necessary. | packages/ember-glimmer/tests/integration/components/will-destroy-element-hook-test.js | @@ -1,5 +1,5 @@
import { set } from 'ember-metal/property_set';
-import Component from 'ember-views/components/component';
+import { Component } from '../../utils/helpers';
import { moduleFor, RenderingTest } from '../../utils/test-case';
moduleFor('Component willDestroyElement hook', class extends RenderingTest { | true |
Other | emberjs | ember.js | 158158364999302d1309b2135f7b46218496007f.json | Implement remaining lifecycle hooks
The original implementation of the hooks in HTMLBars does a deeper walk
than necessary (using the AlwaysDirty validator), resulting in executing
the experimental "new hooks" too often.
In particular, hooks were executed downstream from the original call to
`rerender()` even if the rerendering component did not use `this.set()`
to update the arguments of downstream components.
Because Glimmer uses a pull-based model instead of a blunt push-based
model, we can avoid a deeper traversal than is necessary. | packages/ember-glimmer/tests/utils/abstract-test-case.js | @@ -98,6 +98,14 @@ export class TestCase {
this.assert = QUnit.config.current.assert;
}
+ get isHTMLBars() {
+ return packageName === 'htmlbars';
+ }
+
+ get isGlimmer() {
+ return packageName === 'glimmer';
+ }
+
teardown() {}
// The following methods require `this.element` to work
@@ -390,6 +398,10 @@ export class RenderingTest extends TestCase {
}
}
-export function strip([str]) {
+export function strip([...strings], ...values) {
+ let str = strings.map((string, index) => {
+ let interpolated = values[index];
+ return string + (interpolated !== undefined ? interpolated : '');
+ }).join('');
return str.split('\n').map(s => s.trim()).join('');
} | true |
Other | emberjs | ember.js | 158158364999302d1309b2135f7b46218496007f.json | Implement remaining lifecycle hooks
The original implementation of the hooks in HTMLBars does a deeper walk
than necessary (using the AlwaysDirty validator), resulting in executing
the experimental "new hooks" too often.
In particular, hooks were executed downstream from the original call to
`rerender()` even if the rerendering component did not use `this.set()`
to update the arguments of downstream components.
Because Glimmer uses a pull-based model instead of a blunt push-based
model, we can avoid a deeper traversal than is necessary. | packages/ember-glimmer/tests/utils/test-case.js | @@ -26,6 +26,11 @@ export class RenderingTest extends AbstractRenderingTest {
owner.registerOptionsForType('component', { singleton: false });
}
+ render(...args) {
+ super.render(...args);
+ this.renderer._root = this.component;
+ }
+
runTask(callback) {
super.runTask(() => {
callback(); | true |
Other | emberjs | ember.js | 158158364999302d1309b2135f7b46218496007f.json | Implement remaining lifecycle hooks
The original implementation of the hooks in HTMLBars does a deeper walk
than necessary (using the AlwaysDirty validator), resulting in executing
the experimental "new hooks" too often.
In particular, hooks were executed downstream from the original call to
`rerender()` even if the rerendering component did not use `this.set()`
to update the arguments of downstream components.
Because Glimmer uses a pull-based model instead of a blunt push-based
model, we can avoid a deeper traversal than is necessary. | packages/ember-htmlbars/tests/integration/component_lifecycle_test.js | @@ -316,7 +316,6 @@ styles.forEach(style => {
// Because the `twitter` attr is used by the all of the components,
// the lifecycle hooks are invoked for all components.
-
topAttrs = { oldAttrs: { twitter: '@tomdale' }, newAttrs: { twitter: '@hipstertomdale' } };
middleAttrs = { oldAttrs: { twitterTop: '@tomdale' }, newAttrs: { twitterTop: '@hipstertomdale' } };
bottomAttrs = { oldAttrs: { twitterMiddle: '@tomdale' }, newAttrs: { twitterMiddle: '@hipstertomdale' } }; | true |
Other | emberjs | ember.js | 168a72ac081f9544b8463d4c04d4b98fa0265d0a.json | Implement "old" lifecycle hooks
* `willInsertElement`
* `didInsertElement` | packages/ember-glimmer/lib/components/curly-component.js | @@ -100,7 +100,7 @@ class CurlyComponentManager {
}
didCreate({ component }) {
- // component.trigger('didInsertElement');
+ component.trigger('didInsertElement');
// component.trigger('didRender');
component._transitionTo('inDOM');
} | true |
Other | emberjs | ember.js | 168a72ac081f9544b8463d4c04d4b98fa0265d0a.json | Implement "old" lifecycle hooks
* `willInsertElement`
* `didInsertElement` | packages/ember-glimmer/lib/environment.js | @@ -162,4 +162,8 @@ export default class Environment extends GlimmerEnvironment {
let keyPath = args.named.get('key').value();
return createIterable(ref, keyPath);
}
+
+ didDestroy(destroyable) {
+ destroyable.destroy();
+ }
} | true |
Other | emberjs | ember.js | 168a72ac081f9544b8463d4c04d4b98fa0265d0a.json | Implement "old" lifecycle hooks
* `willInsertElement`
* `didInsertElement` | packages/ember-glimmer/tests/integration/components/will-destroy-element-hook-test.js | @@ -3,7 +3,7 @@ import Component from 'ember-views/components/component';
import { moduleFor, RenderingTest } from '../../utils/test-case';
moduleFor('Component willDestroyElement hook', class extends RenderingTest {
- ['@htmlbars it calls willDestroyElement when removed by if'](assert) {
+ ['@test it calls willDestroyElement when removed by if'](assert) {
let didInsertElementCount = 0;
let willDestroyElementCount = 0;
let FooBarComponent = Component.extend({ | true |
Other | emberjs | ember.js | 6065833fbde58fd29498846a79583503d5b2ab00.json | Fix a bug in the `(get)` helper's tag
Even if the source and path reference has not changed, the content could
still have changed, similar to how `PropertyReference` works. | package.json | @@ -38,7 +38,7 @@
"express": "^4.5.0",
"finalhandler": "^0.4.0",
"github": "^0.2.3",
- "glimmer-engine": "tildeio/glimmer#5918a481",
+ "glimmer-engine": "tildeio/glimmer#8182ab3",
"glob": "^5.0.13",
"htmlbars": "0.14.16",
"mocha": "^2.4.5", | true |
Other | emberjs | ember.js | 6065833fbde58fd29498846a79583503d5b2ab00.json | Fix a bug in the `(get)` helper's tag
Even if the source and path reference has not changed, the content could
still have changed, similar to how `PropertyReference` works. | packages/ember-glimmer/lib/helpers/get.js | @@ -1,5 +1,5 @@
import { GetHelperReference } from '../utils/references';
-import { isConst } from 'glimmer-reference';
+import { isConst, referenceFromParts } from 'glimmer-reference';
/**
@module ember
@@ -58,7 +58,8 @@ export default {
let propertyPathReference = args.positional.at(1); // bar in (get foo bar)
if (isConst(propertyPathReference)) {
- return sourceReference.get(propertyPathReference.value());
+ let parts = propertyPathReference.value().split('.');
+ return referenceFromParts(sourceReference, parts);
} else {
return new GetHelperReference(sourceReference, propertyPathReference);
} | true |
Other | emberjs | ember.js | 6065833fbde58fd29498846a79583503d5b2ab00.json | Fix a bug in the `(get)` helper's tag
Even if the source and path reference has not changed, the content could
still have changed, similar to how `PropertyReference` works. | packages/ember-glimmer/lib/utils/references.js | @@ -1,6 +1,6 @@
import { get } from 'ember-metal/property_get';
import { tagFor } from 'ember-metal/tags';
-import { CURRENT_TAG, CONSTANT_TAG, VOLATILE_TAG, ConstReference, DirtyableTag, UpdatableTag, combine, combineTagged } from 'glimmer-reference';
+import { CURRENT_TAG, CONSTANT_TAG, VOLATILE_TAG, ConstReference, DirtyableTag, UpdatableTag, combine, referenceFromParts } from 'glimmer-reference';
import { ConditionalReference as GlimmerConditionalReference } from 'glimmer-runtime';
import emberToBool from './to-bool';
import { RECOMPUTE_TAG } from '../helper';
@@ -115,20 +115,38 @@ export class GetHelperReference extends CachedReference {
super();
this.sourceReference = sourceReference;
this.pathReference = pathReference;
- this.tag = combineTagged([sourceReference, pathReference]);
- }
- isDirty() { return true; }
+ this.lastPath = null;
+ this.innerReference = null;
+
+ let innerTag = this.innerTag = new UpdatableTag(CURRENT_TAG);
+
+ this.tag = combine([sourceReference.tag, pathReference.tag, innerTag]);
+ }
compute() {
- let key = this.pathReference.value();
- let keyType = typeof key;
+ let { lastPath, innerReference, innerTag } = this;
+
+ let path = this.lastPath = this.pathReference.value();
+
+ if (path !== lastPath) {
+ if (path) {
+ let pathType = typeof path;
+
+ if (pathType === 'string') {
+ innerReference = this.innerReference = referenceFromParts(this.sourceReference, path.split('.'));
+ } else if (pathType === 'number') {
+ innerReference = this.innerReference = this.sourceReference.get(path);
+ }
- if (key && (keyType === 'string' || keyType === 'number')) {
- return this.sourceReference.get(key).value();
+ innerTag.update(innerReference.tag);
+ } else {
+ innerReference = this.innerReference = null;
+ innerTag.update(CONSTANT_TAG);
+ }
}
- return null;
+ return innerReference ? innerReference.value() : null;
}
get(propertyKey) { | true |
Other | emberjs | ember.js | c6f70be7c456eeb7b08aab30b39e48a344f0d8e2.json | Move namespace stuff off of Ember. | packages/ember-application/lib/system/application.js | @@ -2,11 +2,13 @@
@module ember
@submodule ember-application
*/
-import Ember from 'ember-metal'; // Ember.libraries, Ember.BOOTED, Ember.testing
+import Ember from 'ember-metal'; // Ember.libraries, Ember.testing
import { ENV } from 'ember-environment';
import { assert, debug, warn, deprecate } from 'ember-metal/debug';
import { get } from 'ember-metal/property_get';
-import Namespace from 'ember-runtime/system/namespace';
+import Namespace, {
+ setSearchDisabled as setNamespaceSearchDisabled
+} from 'ember-runtime/system/namespace';
import { runLoadHooks } from 'ember-runtime/system/lazy_load';
import run from 'ember-metal/run_loop';
import Controller from 'ember-runtime/controllers/controller';
@@ -738,7 +740,7 @@ const Application = Engine.extend({
if (!Ember.testing) {
// Eagerly name all classes that are already loaded
Namespace.processAll();
- Ember.BOOTED = true;
+ setNamespaceSearchDisabled(true);
}
// See documentation on `_autoboot()` for details
@@ -791,7 +793,7 @@ const Application = Engine.extend({
// This method must be moved to the application instance object
willDestroy() {
this._super(...arguments);
- Ember.BOOTED = false;
+ setNamespaceSearchDisabled(false);
this._booted = false;
this._bootPromise = null;
this._bootResolver = null; | true |
Other | emberjs | ember.js | c6f70be7c456eeb7b08aab30b39e48a344f0d8e2.json | Move namespace stuff off of Ember. | packages/ember-application/tests/system/application_test.js | @@ -1,6 +1,6 @@
/*globals EmberDev */
-import Ember from 'ember-metal/core'; // Ember.libraries, Ember.BOOTED
+import Ember from 'ember-metal/core'; // Ember.libraries
import { ENV, context } from 'ember-environment';
import run from 'ember-metal/run_loop';
import Application, { _resetLegacyAddonWarnings } from 'ember-application/system/application';
@@ -10,6 +10,7 @@ import View from 'ember-views/views/view';
import Controller from 'ember-runtime/controllers/controller';
import NoneLocation from 'ember-routing/location/none_location';
import EmberObject from 'ember-runtime/system/object';
+import { setSearchDisabled as setNamespaceSearchDisabled } from 'ember-runtime/system/namespace';
import EmberRoute from 'ember-routing/system/route';
import jQuery from 'ember-views/system/jquery';
import compile from 'ember-template-compiler/system/compile';
@@ -98,7 +99,7 @@ QUnit.test('acts like a namespace', function() {
app = lookup.TestApp = Application.create({ rootElement: '#two', router: false });
});
- Ember.BOOTED = false;
+ setNamespaceSearchDisabled(false);
app.Foo = EmberObject.extend();
equal(app.Foo.toString(), 'TestApp.Foo', 'Classes pick up their parent namespace');
}); | true |
Other | emberjs | ember.js | c6f70be7c456eeb7b08aab30b39e48a344f0d8e2.json | Move namespace stuff off of Ember. | packages/ember-metal/lib/index.js | @@ -124,6 +124,7 @@ import {
} from 'ember-metal/observer';
import {
IS_BINDING,
+ NAME_KEY,
Mixin,
aliasMethod,
_immediateObserver,
@@ -163,6 +164,7 @@ Ember._Cache = Cache;
Ember.generateGuid = generateGuid;
Ember.GUID_KEY = GUID_KEY;
+Ember.NAME_KEY = NAME_KEY;
Ember.platform = {
defineProperty: true,
hasPropertyAccessors: true | true |
Other | emberjs | ember.js | c6f70be7c456eeb7b08aab30b39e48a344f0d8e2.json | Move namespace stuff off of Ember. | packages/ember-metal/lib/mixin.js | @@ -6,7 +6,6 @@
@module ember
@submodule ember-metal
*/
-import Ember from 'ember-metal/core'; // warn, assert, wrap, et;
import EmberError from 'ember-metal/error';
import { debugSeal, assert, deprecate, runInDebug } from 'ember-metal/debug';
import assign from 'ember-metal/assign';
@@ -426,6 +425,8 @@ export function mixin(obj, ...args) {
return obj;
}
+export const NAME_KEY = GUID_KEY + '_name';
+
/**
The `Ember.Mixin` class allows you to create mixins, whose properties can be
added to other classes. For instance,
@@ -505,7 +506,7 @@ export default function Mixin(args, properties) {
this.ownerConstructor = undefined;
this._without = undefined;
this[GUID_KEY] = null;
- this[GUID_KEY + '_name'] = null;
+ this[NAME_KEY] = null;
debugSeal(this);
}
@@ -518,8 +519,15 @@ Mixin.applyPartial = function(obj) {
Mixin.finishPartial = finishPartial;
-// ES6TODO: this relies on a global state?
-Ember.anyUnprocessedMixins = false;
+let unprocessedFlag = false;
+
+export function hasUnprocessedMixins() {
+ return unprocessedFlag;
+}
+
+export function clearUnprocessedMixins() {
+ unprocessedFlag = false;
+}
/**
@method create
@@ -529,7 +537,7 @@ Ember.anyUnprocessedMixins = false;
*/
Mixin.create = function(...args) {
// ES6TODO: this relies on a global state?
- Ember.anyUnprocessedMixins = true;
+ unprocessedFlag = true;
var M = this;
return new M(args, undefined);
};
@@ -588,9 +596,7 @@ MixinPrototype.applyPartial = function(obj) {
return applyMixin(obj, [this], true);
};
-MixinPrototype.toString = function Mixin_toString() {
- return '(unknown mixin)';
-};
+MixinPrototype.toString = Object.toString;
function _detect(curMixin, targetMixin, seen) {
var guid = guidFor(curMixin); | true |
Other | emberjs | ember.js | c6f70be7c456eeb7b08aab30b39e48a344f0d8e2.json | Move namespace stuff off of Ember. | packages/ember-runtime/lib/index.js | @@ -10,7 +10,10 @@ import compare from 'ember-runtime/compare';
import copy from 'ember-runtime/copy';
import inject from 'ember-runtime/inject';
-import Namespace from 'ember-runtime/system/namespace';
+import Namespace, {
+ isSearchDisabled as isNamespaceSearchDisabled,
+ setSearchDisabled as setNamespaceSearchDisabled
+} from 'ember-runtime/system/namespace';
import EmberObject from 'ember-runtime/system/object';
import { Container, Registry, getOwner, setOwner } from 'ember-runtime/system/container';
import ArrayProxy from 'ember-runtime/system/array_proxy';
@@ -96,6 +99,11 @@ import { isArray, typeOf } from 'ember-runtime/utils';
import RegistryProxyMixin from 'ember-runtime/mixins/registry_proxy';
import ContainerProxyMixin from 'ember-runtime/mixins/container_proxy';
+import {
+ getStrings,
+ setStrings
+} from 'ember-runtime/string_registry';
+
// END IMPORTS
// BEGIN EXPORTS
@@ -200,10 +208,7 @@ Ember._ProxyMixin = _ProxyMixin;
Ember.RSVP = RSVP;
// END EXPORTS
-import {
- getStrings,
- setStrings
-} from 'ember-runtime/string_registry';
+
/**
Defines the hash of localized strings for the current language. Used by
the `Ember.String.loc()` helper. To localize, add string values to this
@@ -220,4 +225,25 @@ Object.defineProperty(Ember, 'STRINGS', {
set: setStrings
});
+/**
+ Whether searching on the global for new Namespace instances is enabled.
+
+ This is only exported here as to not break any addons. Given the new
+ visit API, you will have issues if you treat this as a indicator of
+ booted.
+
+ Internally this is only exposing a flag in Namespace.
+
+ @property BOOTED
+ @for Ember
+ @type Boolean
+ @private
+ */
+Object.defineProperty(Ember, 'BOOTED', {
+ configurable: false,
+ enumerable: false,
+ get: isNamespaceSearchDisabled,
+ set: setNamespaceSearchDisabled
+});
+
export default Ember; | true |
Other | emberjs | ember.js | c6f70be7c456eeb7b08aab30b39e48a344f0d8e2.json | Move namespace stuff off of Ember. | packages/ember-runtime/lib/system/namespace.js | @@ -2,19 +2,31 @@
@module ember
@submodule ember-runtime
*/
-
-// Ember.BOOTED, Ember.NAME_KEY, Ember.anyUnprocessedMixins
-import Ember from 'ember-metal/core';
+import Ember from 'ember-metal/core'; // Preloaded into namespaces
import { context } from 'ember-environment';
import { get } from 'ember-metal/property_get';
import {
- GUID_KEY,
guidFor
} from 'ember-metal/utils';
-import { Mixin } from 'ember-metal/mixin';
+import {
+ Mixin,
+ hasUnprocessedMixins,
+ clearUnprocessedMixins,
+ NAME_KEY
+} from 'ember-metal/mixin';
import EmberObject from 'ember-runtime/system/object';
+let searchDisabled = false;
+
+export function isSearchDisabled() {
+ return searchDisabled;
+}
+
+export function setSearchDisabled(flag) {
+ searchDisabled = !!flag;
+}
+
/**
A Namespace is an object usually used to contain other objects or methods
such as an application or framework. Create a namespace anytime you want
@@ -68,11 +80,13 @@ var Namespace = EmberObject.extend({
Namespace.reopenClass({
NAMESPACES: [Ember],
- NAMESPACES_BY_ID: {},
+ NAMESPACES_BY_ID: {
+ Ember: Ember
+ },
PROCESSED: false,
processAll: processAllNamespaces,
byName(name) {
- if (!Ember.BOOTED) {
+ if (!searchDisabled) {
processAllNamespaces();
}
@@ -154,23 +168,18 @@ function findNamespaces() {
}
}
-var NAME_KEY = Ember.NAME_KEY = GUID_KEY + '_name';
-
function superClassString(mixin) {
var superclass = mixin.superclass;
if (superclass) {
if (superclass[NAME_KEY]) {
return superclass[NAME_KEY];
- } else {
- return superClassString(superclass);
}
- } else {
- return;
+ return superClassString(superclass);
}
}
function classToString() {
- if (!Ember.BOOTED && !this[NAME_KEY]) {
+ if (!searchDisabled && !this[NAME_KEY]) {
processAllNamespaces();
}
@@ -195,7 +204,7 @@ function classToString() {
function processAllNamespaces() {
var unprocessedNamespaces = !Namespace.PROCESSED;
- var unprocessedMixins = Ember.anyUnprocessedMixins;
+ var unprocessedMixins = hasUnprocessedMixins();
if (unprocessedNamespaces) {
findNamespaces();
@@ -211,7 +220,7 @@ function processAllNamespaces() {
processNamespace([namespace.toString()], namespace, {});
}
- Ember.anyUnprocessedMixins = false;
+ clearUnprocessedMixins();
}
}
| true |
Other | emberjs | ember.js | c6f70be7c456eeb7b08aab30b39e48a344f0d8e2.json | Move namespace stuff off of Ember. | packages/ember-runtime/tests/system/namespace/base_test.js | @@ -1,21 +1,22 @@
-import Ember from 'ember-metal/core'; // Ember.BOOTED
import { context } from 'ember-environment';
import run from 'ember-metal/run_loop';
import {get} from 'ember-metal/property_get';
import EmberObject from 'ember-runtime/system/object';
-import Namespace from 'ember-runtime/system/namespace';
+import Namespace, {
+ setSearchDisabled as setNamespaceSearchDisabled
+} from 'ember-runtime/system/namespace';
-let originalLookup = context.lookup;
+const originalLookup = context.lookup;
let lookup;
QUnit.module('Namespace', {
setup() {
- Ember.BOOTED = false;
+ setNamespaceSearchDisabled(false);
lookup = context.lookup = {};
},
teardown() {
- Ember.BOOTED = false;
+ setNamespaceSearchDisabled(false);
for (var prop in lookup) {
if (lookup[prop]) { run(lookup[prop], 'destroy'); }
@@ -82,7 +83,7 @@ QUnit.test('A namespace can be assigned a custom name', function() {
});
QUnit.test('Calling namespace.nameClasses() eagerly names all classes', function() {
- Ember.BOOTED = true;
+ setNamespaceSearchDisabled(true);
var namespace = lookup.NS = Namespace.create();
| true |
Other | emberjs | ember.js | d01caaed94290713074e0294d0ee572ebe4ca690.json | Fix an invalid input test
cc @rwjblue | packages/ember-glimmer/tests/integration/input-test.js | @@ -110,7 +110,7 @@ moduleFor('Input element tests', class extends RenderingTest {
this.setComponentValue('hello');
- this.assertValue('hola', 'DOM is used');
+ this.assertValue('hello', 'DOM is used');
}
// private helpers and assertions | false |
Other | emberjs | ember.js | 681401d55c95330109f2a9f4419808c42c525df5.json | Update input element tests for glimmer 2 | packages/ember-glimmer/tests/integration/input-test.js | @@ -0,0 +1,114 @@
+import { RenderingTest, moduleFor } from '../utils/test-case';
+import { set } from 'ember-metal/property_set';
+
+const camelizeMap = {
+ tabindex: 'tabIndex',
+ maxlength: 'maxLength'
+};
+
+moduleFor('Input element tests', class extends RenderingTest {
+
+ runAttributeTest(attributeName, values) {
+ let template = `<input ${attributeName}={{value}}>`;
+ this.render(template, { value: values[0] });
+ this.assertAttributeHasValue(attributeName, values[0], `${attributeName} is set on initial render`);
+
+ this.runTask(() => this.rerender());
+ this.assertAttributeHasValue(attributeName, values[0], `${attributeName} is set on noop rerender`);
+
+ this.setComponentValue(values[1]);
+ this.assertAttributeHasValue(attributeName, values[1], `${attributeName} is set on rerender`);
+
+ this.setComponentValue(values[0]);
+ this.assertAttributeHasValue(attributeName, values[0], `${attributeName} can be set back to the initial value`);
+ }
+
+ ['@test input disabled attribute']() {
+ this.runAttributeTest('disabled', [false, true]);
+ }
+
+ ['@test input value attribute']() {
+ this.runAttributeTest('value', ['foo', 'bar']);
+ }
+
+ ['@test input placeholder attribute']() {
+ this.runAttributeTest('placeholder', ['placeholder', 'facebolder']);
+ }
+
+ ['@test input name attribute']() {
+ this.runAttributeTest('name', ['nam', 'name']);
+ }
+
+ ['@htmlbars input maxlength attribute']() {
+ this.runAttributeTest('maxlength', [2, 3]);
+ }
+
+ ['@test input size attribute']() {
+ this.runAttributeTest('size', [2, 3]);
+ }
+
+ ['@htmlbars input tabindex attribute']() {
+ this.runAttributeTest('tabindex', [2, 3]);
+ }
+
+ ['@test cursor position is not lost when updating content']() {
+ let template = `<input value={{value}}>`;
+ this.render(template, { value: 'hola' });
+
+ this.setDOMValue('hola');
+ this.setSelectionRange(1, 3);
+
+ this.setComponentValue('hola');
+ this.assertSelectionRange(1, 3);
+ }
+
+ ['@test input can be updated multiple times']() {
+ let template = `<input value={{value}}>`;
+ this.render(template, { value: 'hola' });
+
+ this.assertValue('hola', 'Value is initialised');
+
+ this.setComponentValue('');
+ this.assertValue('', 'Value is set in the DOM');
+
+ this.setDOMValue('hola');
+ this.setComponentValue('hola');
+ this.assertValue('hola', 'Value is updated the first time');
+
+ this.setComponentValue('');
+ this.assertValue('', 'Value is updated the second time');
+ }
+
+ // private helpers and assertions
+ setDOMValue(value) {
+ this.inputElement().value = value;
+ }
+
+ setComponentValue(value) {
+ this.runTask(() => set(this.context, 'value', value));
+ }
+
+ setSelectionRange(start, end) {
+ this.inputElement().selectionStart = start;
+ this.inputElement().selectionEnd = end;
+ }
+
+ inputElement() {
+ return this.element.querySelector('input');
+ }
+
+ assertValue(value, message) {
+ this.assertAttributeHasValue('value', value, message);
+ }
+
+ assertAttributeHasValue(attribute, value, message) {
+ let camelized = camelizeMap[attribute] || attribute;
+ this.assert.equal(this.inputElement()[camelized], value, `${attribute} ${message}`);
+ }
+
+ assertSelectionRange(start, end) {
+ this.assert.equal(this.inputElement().selectionStart, start);
+ this.assert.equal(this.inputElement().selectionEnd, end);
+ }
+
+}); | true |
Other | emberjs | ember.js | 681401d55c95330109f2a9f4419808c42c525df5.json | Update input element tests for glimmer 2 | packages/ember-htmlbars/tests/integration/input-test.js | @@ -0,0 +1 @@
+../../../ember-glimmer/tests/integration/input-test.js
\ No newline at end of file | true |
Other | emberjs | ember.js | 681401d55c95330109f2a9f4419808c42c525df5.json | Update input element tests for glimmer 2 | packages/ember-htmlbars/tests/integration/input_test.js | @@ -1,167 +0,0 @@
-import run from 'ember-metal/run_loop';
-import { set } from 'ember-metal/property_set';
-import View from 'ember-views/views/view';
-import { runAppend, runDestroy } from 'ember-runtime/tests/utils';
-import compile from 'ember-template-compiler/system/compile';
-import ComponentLookup from 'ember-views/component_lookup';
-import TextField from 'ember-views/views/text_field';
-import Checkbox from 'ember-views/views/checkbox';
-import EventDispatcher from 'ember-views/system/event_dispatcher';
-import buildOwner from 'container/tests/test-helpers/build-owner';
-import { OWNER } from 'container/owner';
-
-let view, controller, owner, $input, input;
-
-function commonSetup() {
- owner = buildOwner();
- owner.register('component:-text-field', TextField);
- owner.register('component:-checkbox', Checkbox);
- owner.register('component-lookup:main', ComponentLookup);
- owner.register('event_dispatcher:main', EventDispatcher);
-
- let dispatcher = owner.lookup('event_dispatcher:main');
- dispatcher.setup({}, '#qunit-fixture');
-}
-
-import isEnabled from 'ember-metal/features';
-if (!isEnabled('ember-glimmer')) {
- // jscs:disable
-
-QUnit.module('<input>', {
- setup() {
- commonSetup();
-
- controller = {
- value: 'hello',
- placeholder: 'Enter some text',
- name: 'some-name',
- max: 30,
- size: 30,
- tab: 5
- };
-
- view = View.extend({
- [OWNER]: owner,
- controller,
- template: compile(`<input value={{value}}
- disabled={{disabled}}
- placeholder={{placeholder}}
- name={{name}}
- maxlength={{max}}
- size={{size}}
- tabindex={{tab}}>`)
- }).create();
-
- runAppend(view);
-
- $input = view.$('input');
- input = $input[0];
- },
-
- teardown() {
- runDestroy(view);
- runDestroy(owner);
- }
-});
-
-QUnit.test('should insert a text field into DOM', function(assert) {
- assert.equal($input.length, 1, 'A single text field was inserted');
-});
-
-QUnit.test('should become disabled if the disabled attribute is true', function(assert) {
- assert.ok($input.is(':not(:disabled)'), 'There are no disabled text fields');
-
- run(_ => set(controller, 'disabled', true));
-
- assert.ok($input.is(':disabled'), 'The text field is disabled');
-
- run(_ => set(controller, 'disabled', false));
-
- assert.ok($input.is(':not(:disabled)'), 'There are no disabled text fields');
-});
-
-QUnit.test('input value is updated when setting value property of view', function(assert) {
- assert.equal($input.val(), 'hello', 'renders text field with value');
-
- let id = $input.prop('id');
-
- run(_ => set(controller, 'value', 'bye!'));
-
- assert.equal($input.val(), 'bye!', 'updates text field after value changes');
- assert.equal($input.prop('id'), id, 'the component hasn\'t changed');
-});
-
-QUnit.test('input placeholder is updated when setting placeholder property of view', function(assert) {
- assert.equal($input.attr('placeholder'), 'Enter some text', 'renders text field with placeholder');
-
- run(_ => set(controller, 'placeholder', 'Text, please enter it'));
-
- assert.equal($input.attr('placeholder'), 'Text, please enter it', 'updates text field after placeholder changes');
-});
-
-QUnit.test('input name is updated when setting name property of view', function(assert) {
- assert.equal($input.attr('name'), 'some-name', 'renders text field with name');
-
- run(_ => set(controller, 'name', 'other-name'));
-
- assert.equal($input.attr('name'), 'other-name', 'updates text field after name changes');
-});
-
-QUnit.test('input maxlength is updated when setting maxlength property of view', function(assert) {
- assert.equal($input.attr('maxlength'), '30', 'renders text field with maxlength');
-
- run(_ => set(controller, 'max', 40));
-
- assert.equal($input.attr('maxlength'), '40', 'updates text field after maxlength changes');
-});
-
-QUnit.test('input size is updated when setting size property of view', function(assert) {
- assert.equal($input.attr('size'), '30', 'renders text field with size');
-
- run(_ => set(controller, 'size', 40));
-
- assert.equal($input.attr('size'), '40', 'updates text field after size changes');
-});
-
-QUnit.test('input tabindex is updated when setting tabindex property of view', function(assert) {
- assert.equal($input.attr('tabindex'), '5', 'renders text field with the tabindex');
-
- run(_ => set(controller, 'tab', 3));
-
- assert.equal($input.attr('tabindex'), '3', 'updates text field after tabindex changes');
-});
-
-QUnit.test('cursor position is not lost when updating content', function(assert) {
- run(_ => {
- // Since we can't simulate an actual keypress we can not do a proper integration test.
- // Instead, we will simulate the underlying issue caused by the keypress by
- // desyncing the attr morph's last know value from the DOM and re-setting the
- // controller's value to the input's current value.
-
- input.value = 'hola';
- input.selectionStart = 1;
- input.selectionEnd = 3;
-
- set(controller, 'value', 'hola');
- });
-
- assert.equal(input.selectionStart, 1, 'cursor position was not lost');
- assert.equal(input.selectionEnd, 3, 'cursor position was not lost');
-});
-
-QUnit.test('input can be updated multiple times', function(assert) {
- assert.equal($input.val(), 'hello', 'precondition - renders text field with value');
-
- run(_ => set(controller, 'value', ''));
- assert.equal($input.val(), '', 'updates first time');
-
- // Simulates setting the input to the same value as it already is which won't cause a rerender
- run(_ => input.value = 'derp');
- run(_ => set(controller, 'value', 'derp'));
- assert.equal($input.val(), 'derp', 'updates second time');
-
- run(_ => set(controller, 'value', ''));
- assert.equal($input.val(), '', 'updates third time');
-});
-
-} | true |
Other | emberjs | ember.js | b1c3e11c42c2547dfb27c7eba0fa1aa458863499.json | Generalize the optimisation a little | packages/ember-glimmer/lib/ember-template-compiler/plugins/transform-has-block-syntax.js | @@ -25,10 +25,10 @@ export default function TransformHasBlockSyntax() {
this.syntax = null;
}
-const OLD_HAS_BLOCK = 'hasBlock';
-const NEW_HAS_BLOCK = 'has-block';
-const OLD_HAS_BLOCK_PARAMS = 'hasBlockParams';
-const NEW_HAS_BLOCK_PARAMS = 'has-block-params';
+const TRANSFORMATIONS = {
+ hasBlock: 'has-block',
+ hasBlockParams: 'has-block-params'
+};
/**
@private
@@ -40,28 +40,18 @@ TransformHasBlockSyntax.prototype.transform = function TransformHasBlockSyntax_t
traverse(ast, {
PathExpression(node) {
- if (node.original === OLD_HAS_BLOCK) {
- return b.sexpr(b.path(NEW_HAS_BLOCK));
- }
-
- if (node.original === OLD_HAS_BLOCK_PARAMS) {
- return b.sexpr(b.path(NEW_HAS_BLOCK_PARAMS));
+ if (TRANSFORMATIONS[node.original]) {
+ return b.sexpr(b.path(TRANSFORMATIONS[node.original]));
}
},
MustacheStatement(node) {
- if (node.path.original === OLD_HAS_BLOCK) {
- return b.mustache(b.path(NEW_HAS_BLOCK), node.params, node.hash, null, node.loc);
- }
- if (node.path.original === OLD_HAS_BLOCK_PARAMS) {
- return b.mustache(b.path(NEW_HAS_BLOCK_PARAMS), node.params, node.hash, null, node.loc);
+ if (TRANSFORMATIONS[node.path.original]) {
+ return b.mustache(b.path(TRANSFORMATIONS[node.path.original]), node.params, node.hash, null, node.loc);
}
},
SubExpression(node) {
- if (node.path.original === OLD_HAS_BLOCK) {
- return b.sexpr(b.path(NEW_HAS_BLOCK), node.params, node.hash);
- }
- if (node.path.original === OLD_HAS_BLOCK_PARAMS) {
- return b.sexpr(b.path(NEW_HAS_BLOCK_PARAMS), node.params, node.hash);
+ if (TRANSFORMATIONS[node.path.original]) {
+ return b.sexpr(b.path(TRANSFORMATIONS[node.path.original]), node.params, node.hash);
}
}
}); | false |
Other | emberjs | ember.js | bfa224201dea93efa012e6429db505d191a5167a.json | Add 2.5.1 to CHANGELOG.md.
[ci skip]
(cherry picked from commit 644c5a772788d4b225ef57f98b0ee958d64b7766) | CHANGELOG.md | @@ -11,6 +11,15 @@
- [#13285](https://github.com/emberjs/ember.js/pull/13285) [BUGFIX] Make `Enumerable#firstObject` read only.
- [#13289](https://github.com/emberjs/ember.js/pull/13289) [BUGFIX] Make `Enumerable#lastObject` read only.
+### 2.5.1 (April 21, 2016)
+
+- [#13310](https://github.com/emberjs/ember.js/pull/13310) [BUGFIX] Fix `mouseenter` typo in ember-testing helpers.
+- [#13333](https://github.com/emberjs/ember.js/pull/13333) [BUGFIX] Prevent the `toString` property from being added to the objects own
+ properties. Fixes scenarios where the list of own properties changed in debug builds.
+- [#13335](https://github.com/emberjs/ember.js/pull/13335) [BUGFIX] Ensure injected property assertion checks `container`. Fixes issues
+ with usage of objects created by older addons that are attempting to use `Ember.inject.service()`.
+- [#13344](https://github.com/emberjs/ember.js/pull/13344) [BUGFIX] Remove Ember.merge deprecation.
+
### 2.5.0 (April 11, 2016)
- [#13239](https://github.com/emberjs/ember.js/pull/13239) [BUGFIX] Prevent warnings for unknown feature flags | false |
Other | emberjs | ember.js | b1c4b6f27c98ac26833a13dbd2ac51985f9905db.json | Update route-recognizer to 0.1.10.
Fixes a number of bugs:
* [tildeio/route-recognizer#46](https://github.com/tildeio/route-recognizer/pull/46) Implement a smarter route match algorithm.
Fixes a number of route priority issues, specifically one around glob
route priority matching.
* [tildeio/route-recognizer#62](https://github.com/tildeio/route-recognizer/pull/62)
Handle malformed URI error. Prevents errors from being thrown (and
halting the boot of an app) when a malformed queryParam is present.
* General performance tweaks in:
* https://github.com/tildeio/route-recognizer/pull/76 Add benchmark
suite.
* https://github.com/tildeio/route-recognizer/pull/75 Pre-allocate
array lengths.
* https://github.com/tildeio/route-recognizer/pull/77 Cache results of
`State.get`.
* https://github.com/tildeio/route-recognizer/pull/78 Route result
should be of a fixed size.
* https://github.com/tildeio/route-recognizer/pull/79 Removes closures
around `eachChar`.
* https://github.com/tildeio/route-recognizer/pull/80 Fix State and
`charSpec` shaping.
Compare view:
https://github.com/tildeio/route-recognizer/compare/v0.1.5...v0.1.10 | package.json | @@ -46,7 +46,7 @@
"qunit-extras": "^1.5.0",
"qunitjs": "^1.22.0",
"rimraf": "^2.5.2",
- "route-recognizer": "0.1.5",
+ "route-recognizer": "0.1.10",
"rsvp": "~3.2.1",
"serve-static": "^1.10.0",
"simple-dom": "^0.3.0", | false |
Other | emberjs | ember.js | 1c77b908ec3f431b150db9a89e3f964a0d13e509.json | Remove extra whitespace from FEATURES.md | FEATURES.md | @@ -35,20 +35,20 @@ for a detailed explanation.
Deprecates `Route#serialize` and introduces a `serialize` option to the router DSL as a replacement (as per the [Route Serializers RFC](https://github.com/emberjs/rfcs/blob/master/text/0120-route-serializers.md)).
- * `ember-runtime-computed-uniq-by`
+* `ember-runtime-computed-uniq-by`
- Introduces a computed and enumerable method "uniqBy" that allows creation of a new enumerable with unique values as determined by the given property key.
+ Introduces a computed and enumerable method "uniqBy" that allows creation of a new enumerable with unique values as determined by the given property key.
- Example:
+ Example:
- ```
- comments: [
- {id: 1, comment: 'I\'m a duplicate comment!'},
- {id: 2, comment: 'Then you should be fixed!'},
- {id: 1, comment: 'I\'m a duplicate comment!'}
- ],
- dedupedComments: Ember.computed.uniqBy('comments', 'id')
- ```
+ ```
+ comments: [
+ {id: 1, comment: 'I\'m a duplicate comment!'},
+ {id: 2, comment: 'Then you should be fixed!'},
+ {id: 1, comment: 'I\'m a duplicate comment!'}
+ ],
+ dedupedComments: Ember.computed.uniqBy('comments', 'id')
+ ```
* `ember-improved-instrumentation`
| false |
Other | emberjs | ember.js | 0f71fe2374aaecb7cbaabe6050caf0c76d86d365.json | Update glimmer version, un-gate htmlSafe test | package.json | @@ -38,7 +38,7 @@
"express": "^4.5.0",
"finalhandler": "^0.4.0",
"github": "^0.2.3",
- "glimmer-engine": "tildeio/glimmer#2849de8",
+ "glimmer-engine": "tildeio/glimmer#b421a52",
"glob": "^5.0.13",
"htmlbars": "0.14.16",
"mocha": "^2.4.5", | true |
Other | emberjs | ember.js | 0f71fe2374aaecb7cbaabe6050caf0c76d86d365.json | Update glimmer version, un-gate htmlSafe test | packages/ember-glimmer/tests/integration/components/curly-components-test.js | @@ -877,7 +877,7 @@ moduleFor('Components test: curly components', class extends RenderingTest {
equalTokens(this.firstChild, expectedHtmlBold);
}
- ['@htmlbars should not escape HTML if string is a htmlSafe'](assert) {
+ ['@test should not escape HTML if string is a htmlSafe'](assert) {
let expectedHtmlBold = 'you need to be more <b>bold</b>';
let expectedHtmlItalic = 'you are so <i>super</i>';
let component; | true |
Other | emberjs | ember.js | e0fc791c95ffe88797f9e6755708f5b613296095.json | Fix toString to not add the property on the class
When calling `toString()` method on an Ember Object, it attaches the `toString` as a class property for the first time. This does not seem right since this should be on the prototype of the class. We could memoize the value on the class meta data.
In v2.5.0 and above, when calling `.set()` on an Ember Object, you end up also attaching the `toString()` property on the class. This [PR](https://github.com/emberjs/ember.js/commit/3a2486eb911ad77d2ab1a4324c1aacef08c156da) calls `toString()` on the object during setting any property. Therefore, when you walk through the object properties you end up getting an additional property on the object.
cc: @krisselden @chadhietala | .jshintrc | @@ -15,6 +15,7 @@
"throws",
"deepEqual",
"ok",
+ "notOk",
"strictEqual",
"expect",
"minispade", | true |
Other | emberjs | ember.js | e0fc791c95ffe88797f9e6755708f5b613296095.json | Fix toString to not add the property on the class
When calling `toString()` method on an Ember Object, it attaches the `toString` as a class property for the first time. This does not seem right since this should be on the prototype of the class. We could memoize the value on the class meta data.
In v2.5.0 and above, when calling `.set()` on an Ember Object, you end up also attaching the `toString()` property on the class. This [PR](https://github.com/emberjs/ember.js/commit/3a2486eb911ad77d2ab1a4324c1aacef08c156da) calls `toString()` on the object during setting any property. Therefore, when you walk through the object properties you end up getting an additional property on the object.
cc: @krisselden @chadhietala | packages/ember-runtime/lib/system/core_object.js | @@ -523,17 +523,12 @@ CoreObject.PrototypeMixin = Mixin.create({
var extension = hasToStringExtension ? ':' + this.toStringExtension() : '';
var ret = '<' + this.constructor.toString() + ':' + guidFor(this) + extension + '>';
- this.toString = makeToString(ret);
return ret;
}
});
CoreObject.PrototypeMixin.ownerConstructor = CoreObject;
-function makeToString(ret) {
- return function() { return ret; };
-}
-
CoreObject.__super__ = null;
var ClassMixinProps = { | true |
Other | emberjs | ember.js | e0fc791c95ffe88797f9e6755708f5b613296095.json | Fix toString to not add the property on the class
When calling `toString()` method on an Ember Object, it attaches the `toString` as a class property for the first time. This does not seem right since this should be on the prototype of the class. We could memoize the value on the class meta data.
In v2.5.0 and above, when calling `.set()` on an Ember Object, you end up also attaching the `toString()` property on the class. This [PR](https://github.com/emberjs/ember.js/commit/3a2486eb911ad77d2ab1a4324c1aacef08c156da) calls `toString()` on the object during setting any property. Therefore, when you walk through the object properties you end up getting an additional property on the object.
cc: @krisselden @chadhietala | packages/ember-runtime/tests/system/core_object_test.js | @@ -26,3 +26,14 @@ QUnit.test('works with new (> 1 arg)', function() {
equal(obj.other, undefined); // doesn't support multiple pojo' to the constructor
});
+
+QUnit.test('toString should be not be added as a property when calling toString()', function() {
+ var obj = new CoreObject({
+ firstName: 'Foo',
+ lastName: 'Bar'
+ });
+
+ obj.toString();
+
+ notOk(obj.hasOwnProperty('toString'), 'Calling toString() should not create a toString class property');
+}); | true |
Other | emberjs | ember.js | 618de4fa036ab33dc760343decd355ede7b822bb.json | Update build scripts for LTS [ci skip] | bin/bower_ember_build | @@ -35,8 +35,10 @@ case $TRAVIS_BRANCH in
CHANNEL="beta" ;;
"release" )
CHANNEL="release" ;;
+ "lts-2-4" )
+ CHANNEL="lts-2-4" ;;
"release-1-13" )
- CHANNEL="release-1-13" ;;
+ CHANNEL="release-1-13" ;;
"metal-views" )
CHANNEL="metal-views" ;;
"idempotent-rerender" ) | true |
Other | emberjs | ember.js | 618de4fa036ab33dc760343decd355ede7b822bb.json | Update build scripts for LTS [ci skip] | bin/publish_to_s3.js | @@ -24,6 +24,7 @@ publisher.currentBranch = function() {
master: 'canary',
beta: 'beta',
release: 'release',
+ 'lts-2-4': 'lts-2-4',
'release-1-13': 'release-1-13'
}[this.CURRENT_BRANCH] || process.env.BUILD_TYPE;
}; | true |
Other | emberjs | ember.js | c31c50ee0472894a76e320a4e4f70fc357b3b740.json | Make Enumerable#lastObject readOnly. | packages/ember-runtime/lib/mixins/array.js | @@ -209,7 +209,7 @@ export default Mixin.create(Enumerable, {
lastObject: computed(function() {
return objectAt(this, get(this, 'length') - 1);
- }),
+ }).readOnly(),
// optimized version from Enumerable
contains(obj) { | true |
Other | emberjs | ember.js | c31c50ee0472894a76e320a4e4f70fc357b3b740.json | Make Enumerable#lastObject readOnly. | packages/ember-runtime/lib/mixins/enumerable.js | @@ -211,7 +211,7 @@ var Enumerable = Mixin.create({
pushCtx(context);
return last;
- }),
+ }).readOnly(),
/**
Returns `true` if the passed object can be found in the receiver. The | true |
Other | emberjs | ember.js | c31c50ee0472894a76e320a4e4f70fc357b3b740.json | Make Enumerable#lastObject readOnly. | packages/ember-runtime/tests/suites/enumerable/lastObject.js | @@ -1,5 +1,6 @@
import {SuiteModuleBuilder} from 'ember-runtime/tests/suites/suite';
import {get} from 'ember-metal/property_get';
+import {set} from 'ember-metal/property_set';
var suite = SuiteModuleBuilder.create();
@@ -18,4 +19,15 @@ suite.test('returns undefined if enumerable is empty', function() {
equal(get(obj, 'lastObject'), undefined);
});
+suite.test('can not be set', function() {
+ var obj = this.newObject();
+ var ary = this.toArray(obj);
+
+ equal(get(obj, 'lastObject'), ary[ary.length - 1]);
+
+ throws(function() {
+ set(obj, 'lastObject', 'foo!');
+ }, /Cannot set read-only property "lastObject" on object/);
+});
+
export default suite; | true |
Other | emberjs | ember.js | 19668677884515f3fe469dab50be8b0b03791ba3.json | routing/history_location: Add code comments | packages/ember-routing/lib/location/history_location.js | @@ -64,17 +64,20 @@ export default EmberObject.extend({
@return url {String}
*/
getURL() {
- var rootURL = get(this, 'rootURL');
var location = get(this, 'location');
var path = location.pathname;
+
+ var rootURL = get(this, 'rootURL');
var baseURL = get(this, 'baseURL');
+ // remove trailing slashes if they exists
rootURL = rootURL.replace(/\/$/, '');
baseURL = baseURL.replace(/\/$/, '');
+ // remove baseURL and rootURL from path
var url = path.replace(baseURL, '').replace(rootURL, '');
- var search = location.search || '';
+ var search = location.search || '';
url += search;
url += this.getHash();
@@ -201,9 +204,12 @@ export default EmberObject.extend({
var baseURL = get(this, 'baseURL');
if (url !== '') {
+ // remove trailing slashes if they exists
rootURL = rootURL.replace(/\/$/, '');
baseURL = baseURL.replace(/\/$/, '');
} else if (baseURL.match(/^\//) && rootURL.match(/^\//)) {
+ // if baseURL and rootURL both start with a slash
+ // ... remove trailing slash from baseURL if it exists
baseURL = baseURL.replace(/\/$/, '');
}
| false |
Other | emberjs | ember.js | b273c005ce2a6550bc74f7adadc0ee171fc2e4a2.json | tests/blueprints: Use new testing API | node-tests/blueprints/acceptance-test-test.js | @@ -1,98 +1,85 @@
'use strict';
-var setupTestHooks = require('ember-cli-blueprint-test-helpers/lib/helpers/setup');
-var BlueprintHelpers = require('ember-cli-blueprint-test-helpers/lib/helpers/blueprint-helper');
-var generateAndDestroy = BlueprintHelpers.generateAndDestroy;
+var blueprintHelpers = require('ember-cli-blueprint-test-helpers/helpers');
+var setupTestHooks = blueprintHelpers.setupTestHooks;
+var emberNew = blueprintHelpers.emberNew;
+var emberGenerateDestroy = blueprintHelpers.emberGenerateDestroy;
+var modifyPackages = blueprintHelpers.modifyPackages;
+
+var chai = require('ember-cli-blueprint-test-helpers/chai');
+var expect = chai.expect;
describe('Acceptance: ember generate and destroy acceptance-test', function() {
setupTestHooks(this);
it('acceptance-test foo', function() {
- // pass any additional command line options in the arguments array
- return generateAndDestroy(['acceptance-test', 'foo'], {
- files: [
- {
- file: 'tests/acceptance/foo-test.js',
- contains: [
- "import { test } from 'qunit';",
- "moduleForAcceptance('Acceptance | foo');",
- "test('visiting /foo', function(assert) {",
- "visit('/foo');",
- "andThen(function() {",
- "assert.equal(currentURL(), '/foo');"
- ]
- }
- ]
- });
+ var args = ['acceptance-test', 'foo'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/acceptance/foo-test.js'))
+ .to.contain("import { test } from 'qunit';")
+ .to.contain("moduleForAcceptance('Acceptance | foo');")
+ .to.contain("test('visiting /foo', function(assert) {")
+ .to.contain("visit('/foo');")
+ .to.contain("andThen(function() {")
+ .to.contain("assert.equal(currentURL(), '/foo');");
+ }));
});
it('in-addon acceptance-test foo', function() {
- return generateAndDestroy(['acceptance-test', 'foo'], {
- target: 'addon',
- files: [
- {
- file: 'tests/acceptance/foo-test.js',
- contains: [
- "import { test } from 'qunit';",
- "moduleForAcceptance('Acceptance | foo');",
- "test('visiting /foo', function(assert) {",
- "visit('/foo');",
- "andThen(function() {",
- "assert.equal(currentURL(), '/foo');"
- ]
- },
- {
- file: 'app/acceptance-tests/foo.js',
- exists: false
- }
- ]
- });
+ var args = ['acceptance-test', 'foo'];
+
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/acceptance/foo-test.js'))
+ .to.contain("import { test } from 'qunit';")
+ .to.contain("moduleForAcceptance('Acceptance | foo');")
+ .to.contain("test('visiting /foo', function(assert) {")
+ .to.contain("visit('/foo');")
+ .to.contain("andThen(function() {")
+ .to.contain("assert.equal(currentURL(), '/foo');");
+
+ expect(_file('app/acceptance-tests/foo.js'))
+ .to.not.exist;
+ }));
});
it('in-addon acceptance-test foo/bar', function() {
- return generateAndDestroy(['acceptance-test', 'foo/bar'], {
- target: 'addon',
- files: [
- {
- file: 'tests/acceptance/foo/bar-test.js',
- contains: [
- "import { test } from 'qunit';",
- "moduleForAcceptance('Acceptance | foo/bar');",
- "test('visiting /foo/bar', function(assert) {",
- "visit('/foo/bar');",
- "andThen(function() {",
- "assert.equal(currentURL(), '/foo/bar');"
- ]
- },
- {
- file: 'app/acceptance-tests/foo/bar.js',
- exists: false
- }
- ]
- });
+ var args = ['acceptance-test', 'foo/bar'];
+
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/acceptance/foo/bar-test.js'))
+ .to.contain("import { test } from 'qunit';")
+ .to.contain("moduleForAcceptance('Acceptance | foo/bar');")
+ .to.contain("test('visiting /foo/bar', function(assert) {")
+ .to.contain("visit('/foo/bar');")
+ .to.contain("andThen(function() {")
+ .to.contain("assert.equal(currentURL(), '/foo/bar');");
+
+ expect(_file('app/acceptance-tests/foo/bar.js'))
+ .to.not.exist;
+ }));
});
it('acceptance-test foo for mocha', function() {
- // pass any additional command line options in the arguments array
- return generateAndDestroy(['acceptance-test', 'foo'], {
- packages: [
- { name: 'ember-cli-qunit', delete: true },
- { name: 'ember-cli-mocha', dev: true }
- ],
- files: [
- {
- file: 'tests/acceptance/foo-test.js',
- contains: [
- "import { describe, it, beforeEach, afterEach } from 'mocha';",
- "import { expect } from 'chai';",
- "describe('Acceptance | foo', function() {",
- "it('can visit /foo', function() {",
- "visit('/foo');",
- "andThen(function() {",
- "expect(currentURL()).to.equal('/foo');"
- ]
- }
- ]
- });
+ var args = ['acceptance-test', 'foo'];
+
+ return emberNew()
+ .then(() => modifyPackages([
+ {name: 'ember-cli-qunit', delete: true},
+ {name: 'ember-cli-mocha', dev: true}
+ ]))
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/acceptance/foo-test.js'))
+ .to.contain("import { describe, it, beforeEach, afterEach } from 'mocha';")
+ .to.contain("import { expect } from 'chai';")
+ .to.contain("describe('Acceptance | foo', function() {")
+ .to.contain("it('can visit /foo', function() {")
+ .to.contain("visit('/foo');")
+ .to.contain("andThen(function() {")
+ .to.contain("expect(currentURL()).to.equal('/foo');");
+ }));
});
}); | true |
Other | emberjs | ember.js | b273c005ce2a6550bc74f7adadc0ee171fc2e4a2.json | tests/blueprints: Use new testing API | node-tests/blueprints/component-addon-test.js | @@ -1,23 +1,23 @@
'use strict';
-var setupTestHooks = require('ember-cli-blueprint-test-helpers/lib/helpers/setup');
-var BlueprintHelpers = require('ember-cli-blueprint-test-helpers/lib/helpers/blueprint-helper');
-var generateAndDestroy = BlueprintHelpers.generateAndDestroy;
+var blueprintHelpers = require('ember-cli-blueprint-test-helpers/helpers');
+var setupTestHooks = blueprintHelpers.setupTestHooks;
+var emberNew = blueprintHelpers.emberNew;
+var emberGenerateDestroy = blueprintHelpers.emberGenerateDestroy;
+
+var chai = require('ember-cli-blueprint-test-helpers/chai');
+var expect = chai.expect;
describe('Acceptance: ember generate and destroy component-addon', function() {
setupTestHooks(this);
it('component-addon foo-bar', function() {
- // pass any additional command line options in the arguments array
- return generateAndDestroy(['component-addon', 'foo-bar'], {
- target: 'addon',
- // define files to assert, and their contents
- files: [
- {
- file: 'app/components/foo-bar.js',
- contents: "export { default } from 'my-addon/components/foo-bar';"
- }
- ]
- });
+ var args = ['component-addon', 'foo-bar'];
+
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/components/foo-bar.js'))
+ .to.contain("export { default } from 'my-addon/components/foo-bar';");
+ }));
});
}); | true |
Other | emberjs | ember.js | b273c005ce2a6550bc74f7adadc0ee171fc2e4a2.json | tests/blueprints: Use new testing API | node-tests/blueprints/component-test.js | @@ -1,1077 +1,823 @@
'use strict';
-var setupTestHooks = require('ember-cli-blueprint-test-helpers/lib/helpers/setup');
-var BlueprintHelpers = require('ember-cli-blueprint-test-helpers/lib/helpers/blueprint-helper');
-var generateAndDestroy = BlueprintHelpers.generateAndDestroy;
+var blueprintHelpers = require('ember-cli-blueprint-test-helpers/helpers');
+var setupTestHooks = blueprintHelpers.setupTestHooks;
+var emberNew = blueprintHelpers.emberNew;
+var emberGenerateDestroy = blueprintHelpers.emberGenerateDestroy;
+var modifyPackages = blueprintHelpers.modifyPackages;
+var setupPodConfig = blueprintHelpers.setupPodConfig;
+
+var chai = require('ember-cli-blueprint-test-helpers/chai');
+var expect = chai.expect;
describe('Acceptance: ember generate component', function() {
setupTestHooks(this);
it('component x-foo', function() {
- return generateAndDestroy(['component', 'x-foo'], {
- files:[
- {
- file: 'app/components/x-foo.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Component.extend({",
- "});"
- ]
- },
- {
- file: 'app/templates/components/x-foo.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'tests/integration/components/x-foo-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('x-foo'",
- "integration: true",
- "{{x-foo}}",
- "{{#x-foo}}"
- ]
- }
- ]
- });
+ var args = ['component', 'x-foo'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/components/x-foo.js')).to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("});");
+
+ expect(_file('app/templates/components/x-foo.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('tests/integration/components/x-foo-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{x-foo}}")
+ .to.contain("{{#x-foo}}");
+ }));
});
it('component foo/x-foo', function() {
- return generateAndDestroy(['component', 'foo/x-foo'], {
- files: [
- {
- file: 'app/components/foo/x-foo.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Component.extend({",
- "});"
- ]
- },
- {
- file: 'app/templates/components/foo/x-foo.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'tests/integration/components/foo/x-foo-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('foo/x-foo'",
- "integration: true",
- "{{foo/x-foo}}",
- "{{#foo/x-foo}}"
- ]
- }
- ]
- });
+ var args = ['component', 'foo/x-foo'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/components/foo/x-foo.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("});");
+
+ expect(_file('app/templates/components/foo/x-foo.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('tests/integration/components/foo/x-foo-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('foo/x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{foo/x-foo}}")
+ .to.contain("{{#foo/x-foo}}");
+ }));
});
it('component x-foo ignores --path option', function() {
- return generateAndDestroy(['component', 'x-foo', '--path', 'foo'], {
- files: [
- {
- file: 'app/components/x-foo.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Component.extend({",
- "});"
- ]
- },
- {
- file: 'app/templates/components/x-foo.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'tests/integration/components/x-foo-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('x-foo'",
- "integration: true",
- "{{x-foo}}",
- "{{#x-foo}}"
- ]
- }
- ]
- });
+ var args = ['component', 'x-foo', '--path', 'foo'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/components/x-foo.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("});");
+
+ expect(_file('app/templates/components/x-foo.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('tests/integration/components/x-foo-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{x-foo}}")
+ .to.contain("{{#x-foo}}");
+ }));
});
it('in-addon component x-foo', function() {
- return generateAndDestroy(['component', 'x-foo'], {
- target: 'addon',
- files: [
- {
- file:'addon/components/x-foo.js',
- contains: [
- "import Ember from 'ember';",
- "import layout from '../templates/components/x-foo';",
- "export default Ember.Component.extend({",
- "layout",
- "});"
- ]
- },
- {
- file:'addon/templates/components/x-foo.hbs',
- contains: "{{yield}}"
- },
- {
- file:'app/components/x-foo.js',
- contains: [
- "export { default } from 'my-addon/components/x-foo';"
- ]
- },
- {
- file:'tests/integration/components/x-foo-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('x-foo'",
- "integration: true",
- "{{x-foo}}",
- "{{#x-foo}}"
- ]
- }
- ]
- });
+ var args = ['component', 'x-foo'];
+
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('addon/components/x-foo.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("import layout from '../templates/components/x-foo';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("layout")
+ .to.contain("});");
+
+ expect(_file('addon/templates/components/x-foo.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('app/components/x-foo.js'))
+ .to.contain("export { default } from 'my-addon/components/x-foo';");
+
+ expect(_file('tests/integration/components/x-foo-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{x-foo}}")
+ .to.contain("{{#x-foo}}");
+ }));
});
it('in-addon component nested/x-foo', function() {
- return generateAndDestroy(['component', 'nested/x-foo'], {
- target: 'addon',
- files: [
- {
- file:'addon/components/nested/x-foo.js',
- contains: [
- "import Ember from 'ember';",
- "import layout from '../../templates/components/nested/x-foo';",
- "export default Ember.Component.extend({",
- "layout",
- "});"
- ]
- },
- {
- file:'addon/templates/components/nested/x-foo.hbs',
- contains: "{{yield}}"
- },
- {
- file:'app/components/nested/x-foo.js',
- contains: [
- "export { default } from 'my-addon/components/nested/x-foo';"
- ]
- },
- {
- file:'tests/integration/components/nested/x-foo-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('nested/x-foo'",
- "integration: true",
- "{{nested/x-foo}}",
- "{{#nested/x-foo}}"
- ]
- }
- ]
- });
+ var args = ['component', 'nested/x-foo'];
+
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('addon/components/nested/x-foo.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("import layout from '../../templates/components/nested/x-foo';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("layout")
+ .to.contain("});");
+
+ expect(_file('addon/templates/components/nested/x-foo.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('app/components/nested/x-foo.js'))
+ .to.contain("export { default } from 'my-addon/components/nested/x-foo';");
+
+ expect(_file('tests/integration/components/nested/x-foo-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('nested/x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{nested/x-foo}}")
+ .to.contain("{{#nested/x-foo}}");
+ }));
});
it('dummy component x-foo', function() {
- return generateAndDestroy(['component', 'x-foo', '--dummy'], {
- target: 'addon',
- files: [
- {
- file: 'tests/dummy/app/components/x-foo.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Component.extend({",
- "});"
- ]
- },
- {
- file: 'tests/dummy/app/templates/components/x-foo.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'app/components/x-foo.js',
- exists: false
- },
- {
- file: 'tests/unit/components/x-foo-test.js',
- exists: false
- }
- ]
- });
+ var args = ['component', 'x-foo', '--dummy'];
+
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/dummy/app/components/x-foo.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("});");
+
+ expect(_file('tests/dummy/app/templates/components/x-foo.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('app/components/x-foo.js'))
+ .to.not.exist;
+
+ expect(_file('tests/unit/components/x-foo-test.js'))
+ .to.not.exist;
+ }));
});
it('dummy component nested/x-foo', function() {
- return generateAndDestroy(['component', 'nested/x-foo', '--dummy'], {
- target: 'addon',
- files: [
- {
- file: 'tests/dummy/app/components/nested/x-foo.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Component.extend({",
- "});"
- ]
- },
- {
- file: 'tests/dummy/app/templates/components/nested/x-foo.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'app/components/nested/x-foo.js',
- exists: false
- },
- {
- file: 'tests/unit/components/nested/x-foo-test.js',
- exists: false
- }
- ]
- });
+ var args = ['component', 'nested/x-foo', '--dummy'];
+
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/dummy/app/components/nested/x-foo.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("});");
+
+ expect(_file('tests/dummy/app/templates/components/nested/x-foo.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('app/components/nested/x-foo.js'))
+ .to.not.exist;
+
+ expect(_file('tests/unit/components/nested/x-foo-test.js'))
+ .to.not.exist;
+ }));
});
it('in-repo-addon component x-foo', function() {
- return generateAndDestroy(['component', 'x-foo', '--in-repo-addon=my-addon'], {
- target: 'inRepoAddon',
- files: [
- {
- file: 'lib/my-addon/addon/components/x-foo.js',
- contains: [
- "import Ember from 'ember';",
- "import layout from '../templates/components/x-foo';",
- "export default Ember.Component.extend({",
- "layout",
- "});"
- ]
- },
- {
- file: 'lib/my-addon/addon/templates/components/x-foo.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'lib/my-addon/app/components/x-foo.js',
- contains: [
- "export { default } from 'my-addon/components/x-foo';"
- ]
- },
- {
- file: 'tests/integration/components/x-foo-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('x-foo'",
- "integration: true",
- "{{x-foo}}",
- "{{#x-foo}}"
- ]
- }
- ]
- });
+ var args = ['component', 'x-foo', '--in-repo-addon=my-addon'];
+
+ return emberNew({ target: 'in-repo-addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('lib/my-addon/addon/components/x-foo.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("import layout from '../templates/components/x-foo';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("layout")
+ .to.contain("});");
+
+ expect(_file('lib/my-addon/addon/templates/components/x-foo.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('lib/my-addon/app/components/x-foo.js'))
+ .to.contain("export { default } from 'my-addon/components/x-foo';");
+
+ expect(_file('tests/integration/components/x-foo-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{x-foo}}")
+ .to.contain("{{#x-foo}}");
+ }));
});
it('in-repo-addon component-test x-foo', function() {
- return generateAndDestroy(['component-test', 'x-foo', '--in-repo-addon=my-addon'], {
- target: 'inRepoAddon',
- files: [
- {
- file: 'tests/integration/components/x-foo-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('x-foo'",
- "integration: true",
- "{{x-foo}}",
- "{{#x-foo}}"
- ]
- }
- ]
- });
+ var args = ['component-test', 'x-foo', '--in-repo-addon=my-addon'];
+
+ return emberNew({ target: 'in-repo-addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/integration/components/x-foo-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{x-foo}}")
+ .to.contain("{{#x-foo}}");
+ }));
});
it('in-repo-addon component-test x-foo --unit', function() {
- return generateAndDestroy(['component-test', 'x-foo', '--in-repo-addon=my-addon', '--unit'], {
- target: 'inRepoAddon',
- files: [
- {
- file: 'tests/unit/components/x-foo-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "moduleForComponent('x-foo'",
- "unit: true"
- ]
- }
- ]
- });
+ var args = ['component-test', 'x-foo', '--in-repo-addon=my-addon', '--unit'];
+
+ return emberNew({ target: 'in-repo-addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/unit/components/x-foo-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("moduleForComponent('x-foo'")
+ .to.contain("unit: true");
+ }));
});
it('in-repo-addon component nested/x-foo', function() {
- return generateAndDestroy(['component', 'nested/x-foo', '--in-repo-addon=my-addon'], {
- target: 'inRepoAddon',
- files: [
- {
- file: 'lib/my-addon/addon/components/nested/x-foo.js',
- contains: [
- "import Ember from 'ember';",
- "import layout from '../../templates/components/nested/x-foo';",
- "export default Ember.Component.extend({",
- "layout",
- "});"
- ]
- },
- {
- file: 'lib/my-addon/addon/templates/components/nested/x-foo.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'lib/my-addon/app/components/nested/x-foo.js',
- contains: [
- "export { default } from 'my-addon/components/nested/x-foo';"
- ]
- },
- {
- file: 'tests/integration/components/nested/x-foo-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('nested/x-foo'",
- "integration: true"
- ]
- }
- ]
- });
- });
-/**
-* Pod tests
-*
-*/
+ var args = ['component', 'nested/x-foo', '--in-repo-addon=my-addon'];
+
+ return emberNew({ target: 'in-repo-addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('lib/my-addon/addon/components/nested/x-foo.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("import layout from '../../templates/components/nested/x-foo';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("layout")
+ .to.contain("});");
+
+ expect(_file('lib/my-addon/addon/templates/components/nested/x-foo.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('lib/my-addon/app/components/nested/x-foo.js'))
+ .to.contain("export { default } from 'my-addon/components/nested/x-foo';");
+
+ expect(_file('tests/integration/components/nested/x-foo-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('nested/x-foo'")
+ .to.contain("integration: true");
+ }));
+ });
+ /**
+ * Pod tests
+ *
+ */
it('component x-foo --pod', function() {
- return generateAndDestroy(['component', 'x-foo', '--pod'], {
- files: [
- {
- file: 'app/components/x-foo/component.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Component.extend({",
- "});"
- ]
- },
- {
- file: 'app/components/x-foo/template.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'tests/integration/components/x-foo/component-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('x-foo'",
- "integration: true"
- ]
- },
- ]
- });
+ var args = ['component', 'x-foo', '--pod'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/components/x-foo/component.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("});");
+
+ expect(_file('app/components/x-foo/template.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('tests/integration/components/x-foo/component-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('x-foo'")
+ .to.contain("integration: true");
+ }));
});
it('component x-foo --pod podModulePrefix', function() {
- return generateAndDestroy(['component', 'x-foo', '--pod'], {
- podModulePrefix: true,
- files: [
- {
- file: 'app/pods/components/x-foo/component.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Component.extend({",
- "});"
- ]
- },
- {
- file: 'app/pods/components/x-foo/template.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'tests/integration/pods/components/x-foo/component-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('x-foo'",
- "integration: true",
- "{{x-foo}}",
- "{{#x-foo}}"
- ]
- },
- ]
- });
+ var args = ['component', 'x-foo', '--pod'];
+
+ return emberNew()
+ .then(() => setupPodConfig({ podModulePrefix: true }))
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/pods/components/x-foo/component.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("});");
+
+ expect(_file('app/pods/components/x-foo/template.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('tests/integration/pods/components/x-foo/component-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{x-foo}}")
+ .to.contain("{{#x-foo}}");
+ }));
});
it('component foo/x-foo --pod', function() {
- return generateAndDestroy(['component', 'foo/x-foo', '--pod'], {
- files: [
- {
- file: 'app/components/foo/x-foo/component.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Component.extend({",
- "});"
- ]
- },
- {
- file: 'app/components/foo/x-foo/template.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'tests/integration/components/foo/x-foo/component-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('foo/x-foo'",
- "integration: true",
- "{{foo/x-foo}}",
- "{{#foo/x-foo}}"
- ]
- },
- ]
- });
+ var args = ['component', 'foo/x-foo', '--pod'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/components/foo/x-foo/component.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("});");
+
+ expect(_file('app/components/foo/x-foo/template.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('tests/integration/components/foo/x-foo/component-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('foo/x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{foo/x-foo}}")
+ .to.contain("{{#foo/x-foo}}");
+ }));
});
it('component foo/x-foo --pod podModulePrefix', function() {
- return generateAndDestroy(['component', 'foo/x-foo', '--pod'], {
- podModulePrefix: true,
- files: [
- {
- file: 'app/pods/components/foo/x-foo/component.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Component.extend({",
- "});"
- ]
- },
- {
- file: 'app/pods/components/foo/x-foo/template.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'tests/integration/pods/components/foo/x-foo/component-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('foo/x-foo'",
- "integration: true",
- "{{foo/x-foo}}",
- "{{#foo/x-foo}}"
- ]
- },
- ]
- });
+ var args = ['component', 'foo/x-foo', '--pod'];
+
+ return emberNew()
+ .then(() => setupPodConfig({ podModulePrefix: true }))
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/pods/components/foo/x-foo/component.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("});");
+
+ expect(_file('app/pods/components/foo/x-foo/template.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('tests/integration/pods/components/foo/x-foo/component-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('foo/x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{foo/x-foo}}")
+ .to.contain("{{#foo/x-foo}}");
+ }));
});
it('component x-foo --pod --path', function() {
- return generateAndDestroy(['component', 'x-foo', '--pod', '--path', 'bar'], {
- files: [
- {
- file: 'app/bar/x-foo/component.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Component.extend({",
- "});"
- ]
- },
- {
- file: 'app/bar/x-foo/template.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'tests/integration/bar/x-foo/component-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('bar/x-foo'",
- "integration: true",
- "{{bar/x-foo}}",
- "{{#bar/x-foo}}"
- ]
- },
- ]
- });
+ var args = ['component', 'x-foo', '--pod', '--path', 'bar'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/bar/x-foo/component.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("});");
+
+ expect(_file('app/bar/x-foo/template.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('tests/integration/bar/x-foo/component-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('bar/x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{bar/x-foo}}")
+ .to.contain("{{#bar/x-foo}}");
+ }));
});
it('component x-foo --pod --path podModulePrefix', function() {
- return generateAndDestroy(['component', 'x-foo', '--pod', '--path', 'bar'], {
- podModulePrefix: true,
- files: [
- {
- file: 'app/pods/bar/x-foo/component.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Component.extend({",
- "});"
- ]
- },
- {
- file: 'app/pods/bar/x-foo/template.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'tests/integration/pods/bar/x-foo/component-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('bar/x-foo'",
- "integration: true",
- "{{bar/x-foo}}",
- "{{#bar/x-foo}}"
- ]
- },
- ]
- });
+ var args = ['component', 'x-foo', '--pod', '--path', 'bar'];
+
+ return emberNew()
+ .then(() => setupPodConfig({ podModulePrefix: true }))
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/pods/bar/x-foo/component.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("});");
+
+ expect(_file('app/pods/bar/x-foo/template.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('tests/integration/pods/bar/x-foo/component-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('bar/x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{bar/x-foo}}")
+ .to.contain("{{#bar/x-foo}}");
+ }));
});
it('component foo/x-foo --pod --path', function() {
- return generateAndDestroy(['component', 'foo/x-foo', '--pod', '--path', 'bar'], {
- files: [
- {
- file: 'app/bar/foo/x-foo/component.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Component.extend({",
- "});"
- ]
- },
- {
- file: 'app/bar/foo/x-foo/template.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'tests/integration/bar/foo/x-foo/component-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('bar/foo/x-foo'",
- "integration: true",
- "{{bar/foo/x-foo}}",
- "{{#bar/foo/x-foo}}"
- ]
- },
- ]
- });
+ var args = ['component', 'foo/x-foo', '--pod', '--path', 'bar'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/bar/foo/x-foo/component.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("});");
+
+ expect(_file('app/bar/foo/x-foo/template.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('tests/integration/bar/foo/x-foo/component-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('bar/foo/x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{bar/foo/x-foo}}")
+ .to.contain("{{#bar/foo/x-foo}}");
+ }));
});
it('component foo/x-foo --pod --path podModulePrefix', function() {
- return generateAndDestroy(['component', 'foo/x-foo', '--pod', '--path', 'bar'], {
- podModulePrefix: true,
- files: [
- {
- file: 'app/pods/bar/foo/x-foo/component.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Component.extend({",
- "});"
- ]
- },
- {
- file: 'app/pods/bar/foo/x-foo/template.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'tests/integration/pods/bar/foo/x-foo/component-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "moduleForComponent('bar/foo/x-foo'",
- "integration: true",
- "{{bar/foo/x-foo}}",
- "{{#bar/foo/x-foo}}"
- ]
- },
- ]
- });
+ var args = ['component', 'foo/x-foo', '--pod', '--path', 'bar'];
+
+ return emberNew()
+ .then(() => setupPodConfig({ podModulePrefix: true }))
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/pods/bar/foo/x-foo/component.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("});");
+
+ expect(_file('app/pods/bar/foo/x-foo/template.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('tests/integration/pods/bar/foo/x-foo/component-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("moduleForComponent('bar/foo/x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{bar/foo/x-foo}}")
+ .to.contain("{{#bar/foo/x-foo}}");
+ }));
});
it('component x-foo --pod --path nested', function() {
- return generateAndDestroy(['component', 'x-foo', '--pod', '--path', 'bar/baz'], {
- files: [
- {
- file: 'app/bar/baz/x-foo/component.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Component.extend({",
- "});"
- ]
- },
- {
- file: 'app/bar/baz/x-foo/template.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'tests/integration/bar/baz/x-foo/component-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('bar/baz/x-foo'",
- "integration: true",
- "{{bar/baz/x-foo}}",
- "{{#bar/baz/x-foo}}"
- ]
- },
- ]
- });
+ var args = ['component', 'x-foo', '--pod', '--path', 'bar/baz'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/bar/baz/x-foo/component.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("});");
+
+ expect(_file('app/bar/baz/x-foo/template.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('tests/integration/bar/baz/x-foo/component-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('bar/baz/x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{bar/baz/x-foo}}")
+ .to.contain("{{#bar/baz/x-foo}}");
+ }));
});
it('component x-foo --pod --path nested podModulePrefix', function() {
- return generateAndDestroy(['component', 'x-foo', '--pod', '--path', 'bar/baz'], {
- podModulePrefix: true,
- files: [
- {
- file: 'app/pods/bar/baz/x-foo/component.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Component.extend({",
- "});"
- ]
- },
- {
- file: 'app/pods/bar/baz/x-foo/template.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'tests/integration/pods/bar/baz/x-foo/component-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('bar/baz/x-foo'",
- "integration: true",
- "{{bar/baz/x-foo}}",
- "{{#bar/baz/x-foo}}"
- ]
- },
- ]
- });
+ var args = ['component', 'x-foo', '--pod', '--path', 'bar/baz'];
+
+ return emberNew()
+ .then(() => setupPodConfig({ podModulePrefix: true }))
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/pods/bar/baz/x-foo/component.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("});");
+
+ expect(_file('app/pods/bar/baz/x-foo/template.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('tests/integration/pods/bar/baz/x-foo/component-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('bar/baz/x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{bar/baz/x-foo}}")
+ .to.contain("{{#bar/baz/x-foo}}");
+ }));
});
it('component foo/x-foo --pod --path nested', function() {
- return generateAndDestroy(['component', 'foo/x-foo', '--pod', '--path', 'bar/baz'], {
- files: [
- {
- file: 'app/bar/baz/foo/x-foo/component.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Component.extend({",
- "});"
- ]
- },
- {
- file: 'app/bar/baz/foo/x-foo/template.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'tests/integration/bar/baz/foo/x-foo/component-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('bar/baz/foo/x-foo'",
- "integration: true",
- "{{bar/baz/foo/x-foo}}",
- "{{#bar/baz/foo/x-foo}}"
- ]
- },
- ]
- });
+ var args = ['component', 'foo/x-foo', '--pod', '--path', 'bar/baz'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/bar/baz/foo/x-foo/component.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("});");
+
+ expect(_file('app/bar/baz/foo/x-foo/template.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('tests/integration/bar/baz/foo/x-foo/component-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('bar/baz/foo/x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{bar/baz/foo/x-foo}}")
+ .to.contain("{{#bar/baz/foo/x-foo}}");
+ }));
});
it('component foo/x-foo --pod --path nested podModulePrefix', function() {
- return generateAndDestroy(['component', 'foo/x-foo', '--pod', '--path', 'bar/baz'], {
- podModulePrefix: true,
- files: [
- {
- file: 'app/pods/bar/baz/foo/x-foo/component.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Component.extend({",
- "});"
- ]
- },
- {
- file: 'app/pods/bar/baz/foo/x-foo/template.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'tests/integration/pods/bar/baz/foo/x-foo/component-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('bar/baz/foo/x-foo'",
- "integration: true",
- "{{bar/baz/foo/x-foo}}",
- "{{#bar/baz/foo/x-foo}}"
- ]
- },
- ]
- });
+ var args = ['component', 'foo/x-foo', '--pod', '--path', 'bar/baz'];
+
+ return emberNew()
+ .then(() => setupPodConfig({ podModulePrefix: true }))
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/pods/bar/baz/foo/x-foo/component.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("});");
+
+ expect(_file('app/pods/bar/baz/foo/x-foo/template.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('tests/integration/pods/bar/baz/foo/x-foo/component-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('bar/baz/foo/x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{bar/baz/foo/x-foo}}")
+ .to.contain("{{#bar/baz/foo/x-foo}}");
+ }));
});
it('component x-foo --pod -no-path', function() {
- return generateAndDestroy(['component', 'x-foo', '--pod', '-no-path'], {
- files: [
- {
- file: 'app/x-foo/component.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Component.extend({",
- "});"
- ]
- },
- {
- file: 'app/x-foo/template.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'tests/integration/x-foo/component-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('x-foo'",
- "integration: true",
- "{{x-foo}}",
- "{{#x-foo}}"
- ]
- },
- ]
- });
+ var args = ['component', 'x-foo', '--pod', '-no-path'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/x-foo/component.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("});");
+
+ expect(_file('app/x-foo/template.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('tests/integration/x-foo/component-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{x-foo}}")
+ .to.contain("{{#x-foo}}");
+ }));
});
it('component x-foo --pod -no-path podModulePrefix', function() {
- return generateAndDestroy(['component', 'x-foo', '--pod', '-no-path'], {
- podModulePrefix: true,
- files: [
- {
- file: 'app/pods/x-foo/component.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Component.extend({",
- "});"
- ]
- },
- {
- file: 'app/pods/x-foo/template.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'tests/integration/pods/x-foo/component-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('x-foo'",
- "integration: true",
- "{{x-foo}}",
- "{{#x-foo}}"
- ]
- },
- ]
- });
+ var args = ['component', 'x-foo', '--pod', '-no-path'];
+
+ return emberNew()
+ .then(() => setupPodConfig({ podModulePrefix: true }))
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/pods/x-foo/component.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("});");
+
+ expect(_file('app/pods/x-foo/template.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('tests/integration/pods/x-foo/component-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{x-foo}}")
+ .to.contain("{{#x-foo}}");
+ }));
});
it('component foo/x-foo --pod -no-path', function() {
- return generateAndDestroy(['component', 'foo/x-foo', '--pod', '-no-path'], {
- files: [
- {
- file: 'app/foo/x-foo/component.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Component.extend({",
- "});"
- ]
- },
- {
- file: 'app/foo/x-foo/template.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'tests/integration/foo/x-foo/component-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('foo/x-foo'",
- "integration: true",
- "{{foo/x-foo}}",
- "{{#foo/x-foo}}"
- ]
- },
- ]
- });
+ var args = ['component', 'foo/x-foo', '--pod', '-no-path'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/foo/x-foo/component.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("});");
+
+ expect(_file('app/foo/x-foo/template.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('tests/integration/foo/x-foo/component-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('foo/x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{foo/x-foo}}")
+ .to.contain("{{#foo/x-foo}}");
+ }));
});
it('component foo/x-foo --pod -no-path podModulePrefix', function() {
- return generateAndDestroy(['component', 'foo/x-foo', '--pod', '-no-path'], {
- podModulePrefix: true,
- files: [
- {
- file: 'app/pods/foo/x-foo/component.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Component.extend({",
- "});"
- ]
- },
- {
- file: 'app/pods/foo/x-foo/template.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'tests/integration/pods/foo/x-foo/component-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('foo/x-foo'",
- "integration: true",
- "{{foo/x-foo}}",
- "{{#foo/x-foo}}"
- ]
- },
- ]
- });
+ var args = ['component', 'foo/x-foo', '--pod', '-no-path'];
+
+ return emberNew()
+ .then(() => setupPodConfig({ podModulePrefix: true }))
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/pods/foo/x-foo/component.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("});");
+
+ expect(_file('app/pods/foo/x-foo/template.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('tests/integration/pods/foo/x-foo/component-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('foo/x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{foo/x-foo}}")
+ .to.contain("{{#foo/x-foo}}");
+ }));
});
it('in-addon component x-foo --pod', function() {
- return generateAndDestroy(['component', 'x-foo', '--pod'], {
- target: 'addon',
- files: [
- {
- file: 'addon/components/x-foo/component.js',
- contains: [
- "import Ember from 'ember';",
- "import layout from './template';",
- "export default Ember.Component.extend({",
- "layout",
- "});"
- ]
- },
- {
- file: 'addon/components/x-foo/template.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'app/components/x-foo/component.js',
- contains: [
- "export { default } from 'my-addon/components/x-foo/component';"
- ]
- },
- {
- file: 'tests/integration/components/x-foo/component-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "moduleForComponent('x-foo'",
- "integration: true"
- ]
- }
- ]
- });
+ var args = ['component', 'x-foo', '--pod'];
+
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('addon/components/x-foo/component.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("import layout from './template';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("layout")
+ .to.contain("});");
+
+ expect(_file('addon/components/x-foo/template.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('app/components/x-foo/component.js'))
+ .to.contain("export { default } from 'my-addon/components/x-foo/component';");
+
+ expect(_file('tests/integration/components/x-foo/component-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("moduleForComponent('x-foo'")
+ .to.contain("integration: true");
+ }));
});
it('in-repo-addon component x-foo --pod', function() {
- return generateAndDestroy(['component', 'x-foo', '--in-repo-addon=my-addon', '--pod'], {
- target: 'inRepoAddon',
- files: [
- {
- file: 'lib/my-addon/addon/components/x-foo/component.js',
- contains: [
- "import Ember from 'ember';",
- "import layout from './template';",
- "export default Ember.Component.extend({",
- "layout",
- "});"
- ]
- },
- {
- file: 'lib/my-addon/addon/components/x-foo/template.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'lib/my-addon/app/components/x-foo/component.js',
- contains: [
- "export { default } from 'my-addon/components/x-foo/component';"
- ]
- },
- {
- file: 'tests/integration/components/x-foo/component-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "moduleForComponent('x-foo'",
- "integration: true"
- ]
- }
- ]
- });
+ var args = ['component', 'x-foo', '--in-repo-addon=my-addon', '--pod'];
+
+ return emberNew({ target: 'in-repo-addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('lib/my-addon/addon/components/x-foo/component.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("import layout from './template';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("layout")
+ .to.contain("});");
+
+ expect(_file('lib/my-addon/addon/components/x-foo/template.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('lib/my-addon/app/components/x-foo/component.js'))
+ .to.contain("export { default } from 'my-addon/components/x-foo/component';");
+
+ expect(_file('tests/integration/components/x-foo/component-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("moduleForComponent('x-foo'")
+ .to.contain("integration: true");
+ }));
});
it('in-repo-addon component nested/x-foo', function() {
- return generateAndDestroy(['component', 'nested/x-foo', '--in-repo-addon=my-addon', '--pod'], {
- target: 'inRepoAddon',
- files: [
- {
- file: 'lib/my-addon/addon/components/nested/x-foo/component.js',
- contains: [
- "import Ember from 'ember';",
- "import layout from './template';",
- "export default Ember.Component.extend({",
- "layout",
- "});"
- ]
- },
- {
- file: 'lib/my-addon/addon/components/nested/x-foo/template.hbs',
- contains: "{{yield}}"
- },
- {
- file: 'lib/my-addon/app/components/nested/x-foo/component.js',
- contains: [
- "export { default } from 'my-addon/components/nested/x-foo/component';"
- ]
- },
- {
- file: 'tests/integration/components/nested/x-foo/component-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "moduleForComponent('nested/x-foo'",
- "integration: true"
- ]
- }
- ]
- });
+ var args = ['component', 'nested/x-foo', '--in-repo-addon=my-addon', '--pod'];
+
+ return emberNew({ target: 'in-repo-addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('lib/my-addon/addon/components/nested/x-foo/component.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("import layout from './template';")
+ .to.contain("export default Ember.Component.extend({")
+ .to.contain("layout")
+ .to.contain("});");
+
+ expect(_file('lib/my-addon/addon/components/nested/x-foo/template.hbs'))
+ .to.contain("{{yield}}");
+
+ expect(_file('lib/my-addon/app/components/nested/x-foo/component.js'))
+ .to.contain("export { default } from 'my-addon/components/nested/x-foo/component';");
+
+ expect(_file('tests/integration/components/nested/x-foo/component-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("moduleForComponent('nested/x-foo'")
+ .to.contain("integration: true");
+ }));
});
it('component-test x-foo', function() {
- return generateAndDestroy(['component-test', 'x-foo'], {
- files: [
- {
- file: 'tests/integration/components/x-foo-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('x-foo'",
- "integration: true",
- "{{x-foo}}",
- "{{#x-foo}}"
- ]
- }
- ]
- });
+ var args = ['component-test', 'x-foo'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/integration/components/x-foo-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{x-foo}}")
+ .to.contain("{{#x-foo}}");
+ }));
});
it('component-test x-foo --unit', function() {
- return generateAndDestroy(['component-test', 'x-foo', '--unit'], {
- files: [
- {
- file: 'tests/unit/components/x-foo-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "moduleForComponent('x-foo'",
- "unit: true"
- ]
- }
- ]
- });
+ var args = ['component-test', 'x-foo', '--unit'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/unit/components/x-foo-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("moduleForComponent('x-foo'")
+ .to.contain("unit: true");
+ }));
});
it('in-addon component-test x-foo', function() {
- return generateAndDestroy(['component-test', 'x-foo'], {
- target: 'addon',
- files: [
- {
- file:'tests/integration/components/x-foo-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('x-foo'",
- "integration: true",
- "{{x-foo}}",
- "{{#x-foo}}"
- ]
- },
- {
- file: 'app/component-test/x-foo.js',
- exists: false
- }
- ]
- });
+ var args = ['component-test', 'x-foo'];
+
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/integration/components/x-foo-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('x-foo'")
+ .to.contain("integration: true")
+ .to.contain("{{x-foo}}")
+ .to.contain("{{#x-foo}}");
+
+ expect(_file('app/component-test/x-foo.js'))
+ .to.not.exist;
+ }));
});
it('in-addon component-test x-foo --unit', function() {
- return generateAndDestroy(['component-test', 'x-foo', '--unit'], {
- target: 'addon',
- files: [
- {
- file:'tests/unit/components/x-foo-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "moduleForComponent('x-foo'",
- "unit: true"
- ]
- },
- {
- file: 'app/component-test/x-foo.js',
- exists: false
- }
- ]
- });
+ var args = ['component-test', 'x-foo', '--unit'];
+
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/unit/components/x-foo-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("moduleForComponent('x-foo'")
+ .to.contain("unit: true");
+
+ expect(_file('app/component-test/x-foo.js'))
+ .to.not.exist;
+ }));
});
it('dummy component-test x-foo', function() {
- return generateAndDestroy(['component-test', 'x-foo', '--dummy'], {
- target: 'addon',
- files: [
- {
- file: 'tests/integration/components/x-foo-test.js',
- contains: [
- "import { moduleForComponent, test } from 'ember-qunit';",
- "import hbs from 'htmlbars-inline-precompile';",
- "moduleForComponent('x-foo'"
- ]
- },
- {
- file: 'app/component-test/x-foo.js',
- exists: false
- }
- ]
- });
+ var args = ['component-test', 'x-foo', '--dummy'];
+
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/integration/components/x-foo-test.js'))
+ .to.contain("import { moduleForComponent, test } from 'ember-qunit';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("moduleForComponent('x-foo'");
+
+ expect(_file('app/component-test/x-foo.js'))
+ .to.not.exist;
+ }));
});
it('component-test x-foo for mocha', function() {
- return generateAndDestroy(['component-test', 'x-foo'], {
- packages: [
- { name: 'ember-cli-qunit', delete: true },
- { name: 'ember-cli-mocha', dev: true }
- ],
- files: [
- {
- file: 'tests/integration/components/x-foo-test.js',
- contains: [
- "import { describeComponent, it } from 'ember-mocha';",
- "import hbs from 'htmlbars-inline-precompile';",
- "describeComponent('x-foo', 'Integration | Component | x foo'",
- "integration: true",
- "{{x-foo}}",
- "{{#x-foo}}"
- ]
- }
- ]
- });
+ var args = ['component-test', 'x-foo'];
+
+ return emberNew()
+ .then(() => modifyPackages([
+ {name: 'ember-cli-qunit', delete: true},
+ {name: 'ember-cli-mocha', dev: true}
+ ]))
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/integration/components/x-foo-test.js'))
+ .to.contain("import { describeComponent, it } from 'ember-mocha';")
+ .to.contain("import hbs from 'htmlbars-inline-precompile';")
+ .to.contain("describeComponent('x-foo', 'Integration | Component | x foo'")
+ .to.contain("integration: true")
+ .to.contain("{{x-foo}}")
+ .to.contain("{{#x-foo}}");
+ }));
});
it('component-test x-foo --unit for mocha', function() {
- return generateAndDestroy(['component-test', 'x-foo', '--unit'], {
- packages: [
- { name: 'ember-cli-qunit', delete: true },
- { name: 'ember-cli-mocha', dev: true }
- ],
- files: [
- {
- file: 'tests/unit/components/x-foo-test.js',
- contains: [
- "import { describeComponent, it } from 'ember-mocha';",
- "describeComponent('x-foo', 'Unit | Component | x foo",
- "unit: true"
- ]
- }
- ]
- });
+ var args = ['component-test', 'x-foo', '--unit'];
+
+ return emberNew()
+ .then(() => modifyPackages([
+ {name: 'ember-cli-qunit', delete: true},
+ {name: 'ember-cli-mocha', dev: true}
+ ]))
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/unit/components/x-foo-test.js'))
+ .to.contain("import { describeComponent, it } from 'ember-mocha';")
+ .to.contain("describeComponent('x-foo', 'Unit | Component | x foo")
+ .to.contain("unit: true");
+ }));
});
}); | true |
Other | emberjs | ember.js | b273c005ce2a6550bc74f7adadc0ee171fc2e4a2.json | tests/blueprints: Use new testing API | node-tests/blueprints/controller-test.js | @@ -1,346 +1,250 @@
'use strict';
-var setupTestHooks = require('ember-cli-blueprint-test-helpers/lib/helpers/setup');
-var BlueprintHelpers = require('ember-cli-blueprint-test-helpers/lib/helpers/blueprint-helper');
-var generateAndDestroy = BlueprintHelpers.generateAndDestroy;
+var blueprintHelpers = require('ember-cli-blueprint-test-helpers/helpers');
+var setupTestHooks = blueprintHelpers.setupTestHooks;
+var emberNew = blueprintHelpers.emberNew;
+var emberGenerateDestroy = blueprintHelpers.emberGenerateDestroy;
+var modifyPackages = blueprintHelpers.modifyPackages;
+var setupPodConfig = blueprintHelpers.setupPodConfig;
+
+var chai = require('ember-cli-blueprint-test-helpers/chai');
+var expect = chai.expect;
describe('Acceptance: ember generate and destroy controller', function() {
setupTestHooks(this);
it('controller foo', function() {
- return generateAndDestroy(['controller', 'foo'], {
- files: [
- {
- file: 'app/controllers/foo.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Controller.extend({\n});"
- ]
- },
- {
- file: 'tests/unit/controllers/foo-test.js',
- contains: [
- "import { moduleFor, test } from 'ember-qunit';",
- "moduleFor('controller:foo'"
- ]
- },
- ]
- });
+ var args = ['controller', 'foo'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/controllers/foo.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Controller.extend({\n});");
+
+ expect(_file('tests/unit/controllers/foo-test.js'))
+ .to.contain("import { moduleFor, test } from 'ember-qunit';")
+ .to.contain("moduleFor('controller:foo'");
+ }));
});
it('controller foo/bar', function() {
- return generateAndDestroy(['controller', 'foo/bar'], {
- files: [
- {
- file: 'app/controllers/foo/bar.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Controller.extend({\n});"
- ]
- },
- {
- file: 'tests/unit/controllers/foo/bar-test.js',
- contains: [
- "import { moduleFor, test } from 'ember-qunit';",
- "moduleFor('controller:foo/bar'"
- ]
- }
- ]
- });
+ var args = ['controller', 'foo/bar'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/controllers/foo/bar.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Controller.extend({\n});");
+
+ expect(_file('tests/unit/controllers/foo/bar-test.js'))
+ .to.contain("import { moduleFor, test } from 'ember-qunit';")
+ .to.contain("moduleFor('controller:foo/bar'");
+ }));
});
it('in-addon controller foo', function() {
- return generateAndDestroy(['controller', 'foo'], {
- target: 'addon',
- files: [
- {
- file: 'addon/controllers/foo.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Controller.extend({\n});"
- ]
- },
- {
- file: 'app/controllers/foo.js',
- contains: [
- "export { default } from 'my-addon/controllers/foo';"
- ]
- },
- {
- file: 'tests/unit/controllers/foo-test.js',
- contains: [
- "import { moduleFor, test } from 'ember-qunit';",
- "moduleFor('controller:foo'"
- ]
- }
- ]
- });
+ var args = ['controller', 'foo'];
+
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('addon/controllers/foo.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Controller.extend({\n});");
+
+ expect(_file('app/controllers/foo.js'))
+ .to.contain("export { default } from 'my-addon/controllers/foo';");
+
+ expect(_file('tests/unit/controllers/foo-test.js'))
+ .to.contain("import { moduleFor, test } from 'ember-qunit';")
+ .to.contain("moduleFor('controller:foo'");
+ }));
});
it('in-addon controller foo/bar', function() {
- return generateAndDestroy(['controller', 'foo/bar'], {
- target: 'addon',
- files: [
- {
- file: 'addon/controllers/foo/bar.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Controller.extend({\n});"
- ]
- },
- {
- file: 'app/controllers/foo/bar.js',
- contains: [
- "export { default } from 'my-addon/controllers/foo/bar';"
- ]
- },
- {
- file: 'tests/unit/controllers/foo/bar-test.js',
- contains: [
- "import { moduleFor, test } from 'ember-qunit';",
- "moduleFor('controller:foo/bar'"
- ]
- }
- ]
- });
+ var args = ['controller', 'foo/bar'];
+
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('addon/controllers/foo/bar.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Controller.extend({\n});");
+
+ expect(_file('app/controllers/foo/bar.js'))
+ .to.contain("export { default } from 'my-addon/controllers/foo/bar';");
+
+ expect(_file('tests/unit/controllers/foo/bar-test.js'))
+ .to.contain("import { moduleFor, test } from 'ember-qunit';")
+ .to.contain("moduleFor('controller:foo/bar'");
+ }));
});
it('dummy controller foo', function() {
- return generateAndDestroy(['controller', 'foo', '--dummy'], {
- target: 'addon',
- files: [
- {
- file: 'tests/dummy/app/controllers/foo.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Controller.extend({\n});"
- ]
- },
- {
- file: 'app/controllers/foo-test.js',
- exists: false
- },
- {
- file: 'tests/unit/controllers/foo-test.js',
- exists: false
- }
- ]
- });
+ var args = ['controller', 'foo', '--dummy'];
+
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/dummy/app/controllers/foo.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Controller.extend({\n});");
+
+ expect(_file('app/controllers/foo-test.js'))
+ .to.not.exist;
+
+ expect(_file('tests/unit/controllers/foo-test.js'))
+ .to.not.exist;
+ }));
});
it('dummy controller foo/bar', function() {
- return generateAndDestroy(['controller', 'foo/bar', '--dummy'], {
- target: 'addon',
- files: [
- {
- file: 'tests/dummy/app/controllers/foo/bar.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Controller.extend({\n});"
- ]
- },
- {
- file: 'app/controllers/foo/bar.js',
- exists: false
- },
- {
- file: 'tests/unit/controllers/foo/bar-test.js',
- exists: false
- }
- ]
- });
+ var args = ['controller', 'foo/bar', '--dummy'];
+
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/dummy/app/controllers/foo/bar.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Controller.extend({\n});");
+
+ expect(_file('app/controllers/foo/bar.js'))
+ .to.not.exist;
+
+ expect(_file('tests/unit/controllers/foo/bar-test.js'))
+ .to.not.exist;
+ }));
});
it('in-repo-addon controller foo', function() {
- return generateAndDestroy(['controller', 'foo', '--in-repo-addon=my-addon'], {
- target: 'inRepoAddon',
- files: [
- {
- file: 'lib/my-addon/addon/controllers/foo.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Controller.extend({\n});"
- ]
- },
- {
- file: 'lib/my-addon/app/controllers/foo.js',
- contains: [
- "export { default } from 'my-addon/controllers/foo';"
- ]
- },
- {
- file: 'tests/unit/controllers/foo-test.js',
- contains: [
- "import { moduleFor, test } from 'ember-qunit';",
- "moduleFor('controller:foo'"
- ]
- }
- ]
- });
+ var args = ['controller', 'foo', '--in-repo-addon=my-addon'];
+
+ return emberNew({ target: 'in-repo-addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('lib/my-addon/addon/controllers/foo.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Controller.extend({\n});");
+
+ expect(_file('lib/my-addon/app/controllers/foo.js'))
+ .to.contain("export { default } from 'my-addon/controllers/foo';");
+
+ expect(_file('tests/unit/controllers/foo-test.js'))
+ .to.contain("import { moduleFor, test } from 'ember-qunit';")
+ .to.contain("moduleFor('controller:foo'");
+ }));
});
it('in-repo-addon controller foo/bar', function() {
- return generateAndDestroy(['controller', 'foo/bar', '--in-repo-addon=my-addon'], {
- target: 'inRepoAddon',
- files: [
- {
- file: 'lib/my-addon/addon/controllers/foo/bar.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Controller.extend({\n});"
- ]
- },
- {
- file: 'lib/my-addon/app/controllers/foo/bar.js',
- contains: [
- "export { default } from 'my-addon/controllers/foo/bar';"
- ]
- },
- {
- file: 'tests/unit/controllers/foo/bar-test.js',
- contains: [
- "import { moduleFor, test } from 'ember-qunit';",
- "moduleFor('controller:foo/bar'"
- ]
- }
- ]
- });
+ var args = ['controller', 'foo/bar', '--in-repo-addon=my-addon'];
+
+ return emberNew({ target: 'in-repo-addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('lib/my-addon/addon/controllers/foo/bar.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Controller.extend({\n});");
+
+ expect(_file('lib/my-addon/app/controllers/foo/bar.js'))
+ .to.contain("export { default } from 'my-addon/controllers/foo/bar';");
+
+ expect(_file('tests/unit/controllers/foo/bar-test.js'))
+ .to.contain("import { moduleFor, test } from 'ember-qunit';")
+ .to.contain("moduleFor('controller:foo/bar'");
+ }));
});
-/**
-* Pod tests
-*
-*/
it('controller foo --pod', function() {
- return generateAndDestroy(['controller', 'foo', '--pod'], {
- files: [
- {
- file: 'app/foo/controller.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Controller.extend({\n});"
- ]
- },
- {
- file: 'tests/unit/foo/controller-test.js',
- contains: [
- "import { moduleFor, test } from 'ember-qunit';",
- "moduleFor('controller:foo'"
- ]
- }
- ]
- });
+ var args = ['controller', 'foo', '--pod'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/foo/controller.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Controller.extend({\n});");
+
+ expect(_file('tests/unit/foo/controller-test.js'))
+ .to.contain("import { moduleFor, test } from 'ember-qunit';")
+ .to.contain("moduleFor('controller:foo'");
+ }));
});
it('controller foo --pod podModulePrefix', function() {
- return generateAndDestroy(['controller', 'foo', '--pod'], {
- podModulePrefix: true,
- files: [
- {
- file: 'app/pods/foo/controller.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Controller.extend({\n});"
- ]
- },
- {
- file: 'tests/unit/pods/foo/controller-test.js',
- contains: [
- "import { moduleFor, test } from 'ember-qunit';",
- "moduleFor('controller:foo'"
- ]
- }
- ]
- });
+ var args = ['controller', 'foo', '--pod'];
+
+ return emberNew()
+ .then(() => setupPodConfig({ podModulePrefix: true }))
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/pods/foo/controller.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Controller.extend({\n});");
+
+ expect(_file('tests/unit/pods/foo/controller-test.js'))
+ .to.contain("import { moduleFor, test } from 'ember-qunit';")
+ .to.contain("moduleFor('controller:foo'");
+ }));
});
it('controller foo/bar --pod', function() {
- return generateAndDestroy(['controller', 'foo/bar', '--pod'], {
- files: [
- {
- file: 'app/foo/bar/controller.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Controller.extend({\n});"
- ]
- },
- {
- file: 'tests/unit/foo/bar/controller-test.js',
- contains: [
- "import { moduleFor, test } from 'ember-qunit';",
- "moduleFor('controller:foo/bar'"
- ]
- }
- ]
- });
+ var args = ['controller', 'foo/bar', '--pod'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/foo/bar/controller.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Controller.extend({\n});");
+
+ expect(_file('tests/unit/foo/bar/controller-test.js'))
+ .to.contain("import { moduleFor, test } from 'ember-qunit';")
+ .to.contain("moduleFor('controller:foo/bar'");
+ }));
});
it('controller foo/bar --pod podModulePrefix', function() {
- return generateAndDestroy(['controller', 'foo/bar', '--pod'], {
- podModulePrefix: true,
- files: [
- {
- file: 'app/pods/foo/bar/controller.js',
- contains: [
- "import Ember from 'ember';",
- "export default Ember.Controller.extend({\n});"
- ]
- },
- {
- file: 'tests/unit/pods/foo/bar/controller-test.js',
- contains: [
- "import { moduleFor, test } from 'ember-qunit';",
- "moduleFor('controller:foo/bar'"
- ]
- }
- ]
- });
+ var args = ['controller', 'foo/bar', '--pod'];
+
+ return emberNew()
+ .then(() => setupPodConfig({ podModulePrefix: true }))
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/pods/foo/bar/controller.js'))
+ .to.contain("import Ember from 'ember';")
+ .to.contain("export default Ember.Controller.extend({\n});");
+
+ expect(_file('tests/unit/pods/foo/bar/controller-test.js'))
+ .to.contain("import { moduleFor, test } from 'ember-qunit';")
+ .to.contain("moduleFor('controller:foo/bar'");
+ }));
});
it('controller-test foo', function() {
- return generateAndDestroy(['controller-test', 'foo'], {
- files: [
- {
- file: 'tests/unit/controllers/foo-test.js',
- contains: [
- "import { moduleFor, test } from 'ember-qunit';",
- "moduleFor('controller:foo'"
- ]
- },
- ]
- });
+ var args = ['controller-test', 'foo'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/unit/controllers/foo-test.js'))
+ .to.contain("import { moduleFor, test } from 'ember-qunit';")
+ .to.contain("moduleFor('controller:foo'");
+ }));
});
it('in-addon controller-test foo', function() {
- return generateAndDestroy(['controller-test', 'foo'], {
- target: 'addon',
- files: [
- {
- file: 'tests/unit/controllers/foo-test.js',
- contains: [
- "import { moduleFor, test } from 'ember-qunit';",
- "moduleFor('controller:foo'"
- ]
- }
- ]
- });
+ var args = ['controller-test', 'foo'];
+
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/unit/controllers/foo-test.js'))
+ .to.contain("import { moduleFor, test } from 'ember-qunit';")
+ .to.contain("moduleFor('controller:foo'");
+ }));
});
it('controller-test foo for mocha', function() {
- return generateAndDestroy(['controller-test', 'foo'], {
- packages: [
- { name: 'ember-cli-qunit', delete: true },
- { name: 'ember-cli-mocha', dev: true }
- ],
- files: [
- {
- file: 'tests/unit/controllers/foo-test.js',
- contains: [
- "import { describeModule, it } from 'ember-mocha';",
- "describeModule('controller:foo', 'Unit | Controller | foo'"
- ]
- }
- ]
- });
+ var args = ['controller-test', 'foo'];
+
+ return emberNew()
+ .then(() => modifyPackages([
+ {name: 'ember-cli-qunit', delete: true},
+ {name: 'ember-cli-mocha', dev: true}
+ ]))
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/unit/controllers/foo-test.js'))
+ .to.contain("import { describeModule, it } from 'ember-mocha';")
+ .to.contain("describeModule('controller:foo', 'Unit | Controller | foo'");
+ }));
});
}); | true |
Other | emberjs | ember.js | b273c005ce2a6550bc74f7adadc0ee171fc2e4a2.json | tests/blueprints: Use new testing API | node-tests/blueprints/helper-addon-test.js | @@ -1,24 +1,23 @@
'use strict';
-var setupTestHooks = require('ember-cli-blueprint-test-helpers/lib/helpers/setup');
-var BlueprintHelpers = require('ember-cli-blueprint-test-helpers/lib/helpers/blueprint-helper');
-var generateAndDestroy = BlueprintHelpers.generateAndDestroy;
+var blueprintHelpers = require('ember-cli-blueprint-test-helpers/helpers');
+var setupTestHooks = blueprintHelpers.setupTestHooks;
+var emberNew = blueprintHelpers.emberNew;
+var emberGenerateDestroy = blueprintHelpers.emberGenerateDestroy;
+
+var chai = require('ember-cli-blueprint-test-helpers/chai');
+var expect = chai.expect;
describe('Acceptance: ember generate and destroy helper-addon', function() {
setupTestHooks(this);
it('in-addon helper-addon foo-bar', function() {
- return generateAndDestroy(['helper-addon', 'foo-bar'], {
- target: 'addon',
- files: [
- {
- file: 'app/helpers/foo-bar.js',
- contains: [
- "export { default, fooBar } from 'my-addon/helpers/foo-bar';"
- ]
- },
- ]
- });
- });
+ var args = ['helper-addon', 'foo-bar'];
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/helpers/foo-bar.js'))
+ .to.contain("export { default, fooBar } from 'my-addon/helpers/foo-bar';");
+ }));
+ });
}); | true |
Other | emberjs | ember.js | b273c005ce2a6550bc74f7adadc0ee171fc2e4a2.json | tests/blueprints: Use new testing API | node-tests/blueprints/helper-test.js | @@ -1,304 +1,252 @@
'use strict';
-var setupTestHooks = require('ember-cli-blueprint-test-helpers/lib/helpers/setup');
-var BlueprintHelpers = require('ember-cli-blueprint-test-helpers/lib/helpers/blueprint-helper');
-var generateAndDestroy = BlueprintHelpers.generateAndDestroy;
+var blueprintHelpers = require('ember-cli-blueprint-test-helpers/helpers');
+var setupTestHooks = blueprintHelpers.setupTestHooks;
+var emberNew = blueprintHelpers.emberNew;
+var emberGenerateDestroy = blueprintHelpers.emberGenerateDestroy;
+var modifyPackages = blueprintHelpers.modifyPackages;
+var setupPodConfig = blueprintHelpers.setupPodConfig;
+
+var chai = require('ember-cli-blueprint-test-helpers/chai');
+var expect = chai.expect;
describe('Acceptance: ember generate and destroy helper', function() {
setupTestHooks(this);
it('helper foo/bar-baz', function() {
- return generateAndDestroy(['helper', 'foo/bar-baz'], {
- files: [
- {
- file: 'app/helpers/foo/bar-baz.js',
- contains: "import Ember from 'ember';\n\n" +
- "export function fooBarBaz(params/*, hash*/) {\n" +
- " return params;\n" +
- "}\n\n" +
- "export default Ember.Helper.helper(fooBarBaz);"
- },
- {
- file: 'tests/unit/helpers/foo/bar-baz-test.js',
- contains: "import { fooBarBaz } from 'my-app/helpers/foo/bar-baz';"
- }
- ]
- });
+ var args = ['helper', 'foo/bar-baz'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/helpers/foo/bar-baz.js'))
+ .to.contain("import Ember from 'ember';\n\n" +
+ "export function fooBarBaz(params/*, hash*/) {\n" +
+ " return params;\n" +
+ "}\n\n" +
+ "export default Ember.Helper.helper(fooBarBaz);");
+
+ expect(_file('tests/unit/helpers/foo/bar-baz-test.js'))
+ .to.contain("import { fooBarBaz } from 'my-app/helpers/foo/bar-baz';");
+ }));
});
it('in-addon helper foo-bar', function() {
- return generateAndDestroy(['helper', 'foo-bar'], {
- target: 'addon',
- files: [
- {
- file: 'addon/helpers/foo-bar.js',
- contains: "import Ember from 'ember';\n\n" +
- "export function fooBar(params/*, hash*/) {\n" +
- " return params;\n" +
- "}\n\n" +
- "export default Ember.Helper.helper(fooBar);"
- },
- {
- file: 'app/helpers/foo-bar.js',
- contains: [
- "export { default, fooBar } from 'my-addon/helpers/foo-bar';"
- ]
- },
- {
- file: 'tests/unit/helpers/foo-bar-test.js',
- contains: "import { fooBar } from 'dummy/helpers/foo-bar';"
- }
- ]
- });
+ var args = ['helper', 'foo-bar'];
+
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('addon/helpers/foo-bar.js'))
+ .to.contain("import Ember from 'ember';\n\n" +
+ "export function fooBar(params/*, hash*/) {\n" +
+ " return params;\n" +
+ "}\n\n" +
+ "export default Ember.Helper.helper(fooBar);");
+
+ expect(_file('app/helpers/foo-bar.js'))
+ .to.contain("export { default, fooBar } from 'my-addon/helpers/foo-bar';");
+ expect(_file('tests/unit/helpers/foo-bar-test.js'))
+ .to.contain("import { fooBar } from 'dummy/helpers/foo-bar';");
+ }));
});
it('in-addon helper foo/bar-baz', function() {
- return generateAndDestroy(['helper', 'foo/bar-baz'], {
- target: 'addon',
- files: [
- {
- file: 'addon/helpers/foo/bar-baz.js',
- contains: "import Ember from 'ember';\n\n" +
- "export function fooBarBaz(params/*, hash*/) {\n" +
- " return params;\n" +
- "}\n\n" +
- "export default Ember.Helper.helper(fooBarBaz);"
- },
- {
- file: 'app/helpers/foo/bar-baz.js',
- contains: [
- "export { default, fooBarBaz } from 'my-addon/helpers/foo/bar-baz';"
- ]
- },
- {
- file: 'tests/unit/helpers/foo/bar-baz-test.js',
- contains: "import { fooBarBaz } from 'dummy/helpers/foo/bar-baz';"
- }
- ]
- });
+ var args = ['helper', 'foo/bar-baz'];
+
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('addon/helpers/foo/bar-baz.js'))
+ .to.contain("import Ember from 'ember';\n\n" +
+ "export function fooBarBaz(params/*, hash*/) {\n" +
+ " return params;\n" +
+ "}\n\n" +
+ "export default Ember.Helper.helper(fooBarBaz);");
+
+ expect(_file('app/helpers/foo/bar-baz.js'))
+ .to.contain("export { default, fooBarBaz } from 'my-addon/helpers/foo/bar-baz';");
+ expect(_file('tests/unit/helpers/foo/bar-baz-test.js'))
+ .to.contain("import { fooBarBaz } from 'dummy/helpers/foo/bar-baz';");
+ }));
});
it('dummy helper foo-bar', function() {
- return generateAndDestroy(['helper', 'foo-bar', '--dummy'], {
- target: 'addon',
- files: [
- {
- file: 'tests/dummy/app/helpers/foo-bar.js',
- contains: "import Ember from 'ember';\n\n" +
- "export function fooBar(params/*, hash*/) {\n" +
- " return params;\n" +
- "}\n\n" +
- "export default Ember.Helper.helper(fooBar);"
- },
- {
- file: 'app/helpers/foo-bar.js',
- exists: false
- },
- {
- file: 'tests/unit/helpers/foo-bar-test.js',
- exists: false
- }
- ]
- });
+ var args = ['helper', 'foo-bar', '--dummy'];
+
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/dummy/app/helpers/foo-bar.js'))
+ .to.contain("import Ember from 'ember';\n\n" +
+ "export function fooBar(params/*, hash*/) {\n" +
+ " return params;\n" +
+ "}\n\n" +
+ "export default Ember.Helper.helper(fooBar);");
+
+ expect(_file('app/helpers/foo-bar.js'))
+ .to.not.exist;
+ expect(_file('tests/unit/helpers/foo-bar-test.js'))
+ .to.not.exist;
+ }));
});
it('dummy helper foo/bar-baz', function() {
- return generateAndDestroy(['helper', 'foo/bar-baz', '--dummy'], {
- target: 'addon',
- files: [
- {
- file: 'tests/dummy/app/helpers/foo/bar-baz.js',
- contains: "import Ember from 'ember';\n\n" +
- "export function fooBarBaz(params/*, hash*/) {\n" +
- " return params;\n" +
- "}\n\n" +
- "export default Ember.Helper.helper(fooBarBaz);"
- },
- {
- file: 'app/helpers/foo/bar-baz.js',
- exists: false
- },
- {
- file: 'tests/unit/helpers/foo/bar-baz-test.js',
- exists: false
- }
- ]
- });
+ var args = ['helper', 'foo/bar-baz', '--dummy'];
+
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/dummy/app/helpers/foo/bar-baz.js'))
+ .to.contain("import Ember from 'ember';\n\n" +
+ "export function fooBarBaz(params/*, hash*/) {\n" +
+ " return params;\n" +
+ "}\n\n" +
+ "export default Ember.Helper.helper(fooBarBaz);");
+
+ expect(_file('app/helpers/foo/bar-baz.js'))
+ .to.not.exist;
+ expect(_file('tests/unit/helpers/foo/bar-baz-test.js'))
+ .to.not.exist;
+ }));
});
it('in-repo-addon helper foo-bar', function() {
- return generateAndDestroy(['helper', 'foo-bar', '--in-repo-addon=my-addon'], {
- target: 'inRepoAddon',
- files: [
- {
- file: 'lib/my-addon/addon/helpers/foo-bar.js',
- contains: "import Ember from 'ember';\n\n" +
- "export function fooBar(params/*, hash*/) {\n" +
- " return params;\n" +
- "}\n\n" +
- "export default Ember.Helper.helper(fooBar);"
- },
- {
- file: 'lib/my-addon/app/helpers/foo-bar.js',
- contains: [
- "export { default, fooBar } from 'my-addon/helpers/foo-bar';"
- ]
- },
- {
- file: 'tests/unit/helpers/foo-bar-test.js',
- contains: "import { fooBar } from 'my-app/helpers/foo-bar';"
- }
- ]
- });
+ var args = ['helper', 'foo-bar', '--in-repo-addon=my-addon'];
+
+ return emberNew({ target: 'in-repo-addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('lib/my-addon/addon/helpers/foo-bar.js'))
+ .to.contain("import Ember from 'ember';\n\n" +
+ "export function fooBar(params/*, hash*/) {\n" +
+ " return params;\n" +
+ "}\n\n" +
+ "export default Ember.Helper.helper(fooBar);");
+
+ expect(_file('lib/my-addon/app/helpers/foo-bar.js'))
+ .to.contain("export { default, fooBar } from 'my-addon/helpers/foo-bar';");
+ expect(_file('tests/unit/helpers/foo-bar-test.js'))
+ .to.contain("import { fooBar } from 'my-app/helpers/foo-bar';");
+ }));
});
it('in-repo-addon helper foo/bar-baz', function() {
- return generateAndDestroy(['helper', 'foo/bar-baz', '--in-repo-addon=my-addon'], {
- target: 'inRepoAddon',
- files: [
- {
- file: 'lib/my-addon/addon/helpers/foo/bar-baz.js',
- contains: "import Ember from 'ember';\n\n" +
- "export function fooBarBaz(params/*, hash*/) {\n" +
- " return params;\n" +
- "}\n\n" +
- "export default Ember.Helper.helper(fooBarBaz);"
- },
- {
- file: 'lib/my-addon/app/helpers/foo/bar-baz.js',
- contains: [
- "export { default, fooBarBaz } from 'my-addon/helpers/foo/bar-baz';"
- ]
- },
- {
- file: 'tests/unit/helpers/foo/bar-baz-test.js',
- contains: "import { fooBarBaz } from 'my-app/helpers/foo/bar-baz';"
- }
- ]
- });
+ var args = ['helper', 'foo/bar-baz', '--in-repo-addon=my-addon'];
+
+ return emberNew({ target: 'in-repo-addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('lib/my-addon/addon/helpers/foo/bar-baz.js'))
+ .to.contain("import Ember from 'ember';\n\n" +
+ "export function fooBarBaz(params/*, hash*/) {\n" +
+ " return params;\n" +
+ "}\n\n" +
+ "export default Ember.Helper.helper(fooBarBaz);");
+
+ expect(_file('lib/my-addon/app/helpers/foo/bar-baz.js'))
+ .to.contain("export { default, fooBarBaz } from 'my-addon/helpers/foo/bar-baz';");
+ expect(_file('tests/unit/helpers/foo/bar-baz-test.js'))
+ .to.contain("import { fooBarBaz } from 'my-app/helpers/foo/bar-baz';");
+ }));
});
-/**
-* Pod tests
-*
-*/
it('helper foo-bar --pod', function() {
- return generateAndDestroy(['helper', 'foo-bar', '--pod'], {
- files: [
- {
- file: 'app/helpers/foo-bar.js',
- contains: "import Ember from 'ember';\n\n" +
- "export function fooBar(params/*, hash*/) {\n" +
- " return params;\n" +
- "}\n\n" +
- "export default Ember.Helper.helper(fooBar);"
- },
- {
- file: 'tests/unit/helpers/foo-bar-test.js',
- contains: "import { fooBar } from 'my-app/helpers/foo-bar';"
- }
- ]
- });
+ var args = ['helper', 'foo-bar', '--pod'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/helpers/foo-bar.js'))
+ .to.contain("import Ember from 'ember';\n\n" +
+ "export function fooBar(params/*, hash*/) {\n" +
+ " return params;\n" +
+ "}\n\n" +
+ "export default Ember.Helper.helper(fooBar);");
+
+ expect(_file('tests/unit/helpers/foo-bar-test.js'))
+ .to.contain("import { fooBar } from 'my-app/helpers/foo-bar';");
+ }));
});
it('helper foo-bar --pod podModulePrefix', function() {
- return generateAndDestroy(['helper', 'foo-bar', '--pod'], {
- podModulePrefix: true,
- files: [
- {
- file: 'app/helpers/foo-bar.js',
- contains: "import Ember from 'ember';\n\n" +
- "export function fooBar(params/*, hash*/) {\n" +
- " return params;\n" +
- "}\n\n" +
- "export default Ember.Helper.helper(fooBar);"
- },
- {
- file: 'tests/unit/helpers/foo-bar-test.js',
- contains: "import { fooBar } from 'my-app/helpers/foo-bar';"
- }
- ]
- });
+ var args = ['helper', 'foo-bar', '--pod'];
+
+ return emberNew()
+ .then(() => setupPodConfig({ podModulePrefix: true }))
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/helpers/foo-bar.js'))
+ .to.contain("import Ember from 'ember';\n\n" +
+ "export function fooBar(params/*, hash*/) {\n" +
+ " return params;\n" +
+ "}\n\n" +
+ "export default Ember.Helper.helper(fooBar);");
+
+ expect(_file('tests/unit/helpers/foo-bar-test.js'))
+ .to.contain("import { fooBar } from 'my-app/helpers/foo-bar';");
+ }));
});
it('helper foo/bar-baz --pod', function() {
- return generateAndDestroy(['helper', 'foo/bar-baz', '--pod'], {
- files: [
- {
- file: 'app/helpers/foo/bar-baz.js',
- contains: "import Ember from 'ember';\n\n" +
- "export function fooBarBaz(params/*, hash*/) {\n" +
- " return params;\n" +
- "}\n\n" +
- "export default Ember.Helper.helper(fooBarBaz);"
- },
- {
- file: 'tests/unit/helpers/foo/bar-baz-test.js',
- contains: "import { fooBarBaz } from 'my-app/helpers/foo/bar-baz';"
- }
- ]
- });
+ var args = ['helper', 'foo/bar-baz', '--pod'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/helpers/foo/bar-baz.js'))
+ .to.contain("import Ember from 'ember';\n\n" +
+ "export function fooBarBaz(params/*, hash*/) {\n" +
+ " return params;\n" +
+ "}\n\n" +
+ "export default Ember.Helper.helper(fooBarBaz);");
+
+ expect(_file('tests/unit/helpers/foo/bar-baz-test.js'))
+ .to.contain("import { fooBarBaz } from 'my-app/helpers/foo/bar-baz';");
+ }));
});
it('helper foo/bar-baz --pod podModulePrefix', function() {
- return generateAndDestroy(['helper', 'foo/bar-baz', '--pod'], {
- podModulePrefix: true,
- files: [
- {
- file: 'app/helpers/foo/bar-baz.js',
- contains: "import Ember from 'ember';\n\n" +
- "export function fooBarBaz(params/*, hash*/) {\n" +
- " return params;\n" +
- "}\n\n" +
- "export default Ember.Helper.helper(fooBarBaz);"
- },
- {
- file: 'tests/unit/helpers/foo/bar-baz-test.js',
- contains: "import { fooBarBaz } from 'my-app/helpers/foo/bar-baz';"
- }
- ]
- });
+ var args = ['helper', 'foo/bar-baz', '--pod'];
+
+ return emberNew()
+ .then(() => setupPodConfig({ podModulePrefix: true }))
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/helpers/foo/bar-baz.js'))
+ .to.contain("import Ember from 'ember';\n\n" +
+ "export function fooBarBaz(params/*, hash*/) {\n" +
+ " return params;\n" +
+ "}\n\n" +
+ "export default Ember.Helper.helper(fooBarBaz);");
+
+ expect(_file('tests/unit/helpers/foo/bar-baz-test.js'))
+ .to.contain("import { fooBarBaz } from 'my-app/helpers/foo/bar-baz';");
+ }));
});
it('helper-test foo/bar-baz', function() {
- return generateAndDestroy(['helper-test', 'foo/bar-baz'], {
- files: [
- {
- file: 'tests/unit/helpers/foo/bar-baz-test.js',
- contains: "import { fooBarBaz } from 'my-app/helpers/foo/bar-baz';"
- }
- ]
- });
+ var args = ['helper-test', 'foo/bar-baz'];
+
+ return emberNew()
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/unit/helpers/foo/bar-baz-test.js'))
+ .to.contain("import { fooBarBaz } from 'my-app/helpers/foo/bar-baz';");
+ }));
});
it('in-addon helper-test foo-bar', function() {
- return generateAndDestroy(['helper-test', 'foo-bar'], {
- target: 'addon',
- files: [
- {
- file: 'tests/unit/helpers/foo-bar-test.js',
- contains: "import { fooBar } from 'dummy/helpers/foo-bar';"
- }
- ]
- });
+ var args = ['helper-test', 'foo-bar'];
+
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/unit/helpers/foo-bar-test.js'))
+ .to.contain("import { fooBar } from 'dummy/helpers/foo-bar';");
+ }));
});
it('helper-test foo/bar-baz for mocha', function() {
- return generateAndDestroy(['helper-test', 'foo/bar-baz'], {
- packages: [
- { name: 'ember-cli-qunit', delete: true },
- { name: 'ember-cli-mocha', dev: true }
- ],
- files: [
- {
- file: 'tests/unit/helpers/foo/bar-baz-test.js',
- contains: [
- "import { describe, it } from 'mocha';",
- "import { fooBarBaz } from 'my-app/helpers/foo/bar-baz';",
- "describe('Unit | Helper | foo/bar baz', function() {"
- ]
- }
- ]
- });
+ var args = ['helper-test', 'foo/bar-baz'];
+
+ return emberNew()
+ .then(() => modifyPackages([
+ {name: 'ember-cli-qunit', delete: true},
+ {name: 'ember-cli-mocha', dev: true}
+ ]))
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('tests/unit/helpers/foo/bar-baz-test.js'))
+ .to.contain("import { describe, it } from 'mocha';")
+ .to.contain("import { fooBarBaz } from 'my-app/helpers/foo/bar-baz';")
+ .to.contain("describe('Unit | Helper | foo/bar baz', function() {");
+ }));
});
}); | true |
Other | emberjs | ember.js | b273c005ce2a6550bc74f7adadc0ee171fc2e4a2.json | tests/blueprints: Use new testing API | node-tests/blueprints/initializer-addon-test.js | @@ -1,24 +1,23 @@
'use strict';
-var setupTestHooks = require('ember-cli-blueprint-test-helpers/lib/helpers/setup');
-var BlueprintHelpers = require('ember-cli-blueprint-test-helpers/lib/helpers/blueprint-helper');
-var generateAndDestroy = BlueprintHelpers.generateAndDestroy;
+var blueprintHelpers = require('ember-cli-blueprint-test-helpers/helpers');
+var setupTestHooks = blueprintHelpers.setupTestHooks;
+var emberNew = blueprintHelpers.emberNew;
+var emberGenerateDestroy = blueprintHelpers.emberGenerateDestroy;
+
+var chai = require('ember-cli-blueprint-test-helpers/chai');
+var expect = chai.expect;
describe('Acceptance: ember generate and destroy initializer-addon', function() {
setupTestHooks(this);
it('initializer-addon foo', function() {
- // pass any additional command line options in the arguments array
- return generateAndDestroy(['initializer-addon', 'foo'], {
- // define files to assert, and their contents
- target: 'addon',
- files: [
- {
- file: 'app/initializers/foo.js',
- contains: "export { default, initialize } from 'my-addon/initializers/foo';"
- }
- ]
- });
- });
+ var args = ['initializer-addon', 'foo'];
+ return emberNew({ target: 'addon' })
+ .then(() => emberGenerateDestroy(args, _file => {
+ expect(_file('app/initializers/foo.js'))
+ .to.contain("export { default, initialize } from 'my-addon/initializers/foo';");
+ }));
+ });
}); | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.