Ember.Application Class
An instance of Ember.Application
is the starting point for every Ember
application. It helps to instantiate, initialize and coordinate the many
objects that make up your app.
Each Ember app has one and only one Ember.Application
object. In fact, the
very first thing you should do in your application is create the instance:
window.App = Ember.Application.create();
Typically, the application object is the only global variable. All other
classes in your app should be properties on the Ember.Application
instance,
which highlights its first role: a global namespace.
For example, if you define a view class, it might look like this:
App.MyView = Ember.View.extend();
By default, calling Ember.Application.create()
will automatically initialize
your application by calling the Ember.Application.initialize()
method. If
you need to delay initialization, you can call your app's deferReadiness()
method. When you are ready for your app to be initialized, call its
advanceReadiness()
method.
You can define a ready
method on the Ember.Application
instance, which
will be run by Ember when the application is initialized.
Because Ember.Application
inherits from Ember.Namespace
, any classes
you create will have useful string representations when calling toString()
.
See the Ember.Namespace
documentation for more information.
While you can think of your Ember.Application
as a container that holds the
other classes in your application, there are several other responsibilities
going on under-the-hood that you may want to understand.
Event Delegation
Ember uses a technique called event delegation. This allows the framework
to set up a global, shared event listener instead of requiring each view to
do it manually. For example, instead of each view registering its own
mousedown
listener on its associated element, Ember sets up a mousedown
listener on the body
.
If a mousedown
event occurs, Ember will look at the target of the event and
start walking up the DOM node tree, finding corresponding views and invoking
their mouseDown
method as it goes.
Ember.Application
has a number of default events that it listens for, as
well as a mapping from lowercase events to camel-cased view method names. For
example, the keypress
event causes the keyPress
method on the view to be
called, the dblclick
event causes doubleClick
to be called, and so on.
If there is a bubbling browser event that Ember does not listen for by
default, you can specify custom events and their corresponding view method
names by setting the application's customEvents
property:
let App = Ember.Application.create({
customEvents: {
// add support for the paste event
paste: 'paste'
}
});
To prevent Ember from setting up a listener for a default event,
specify the event name with a null
value in the customEvents
property:
let App = Ember.Application.create({
customEvents: {
// prevent listeners for mouseenter/mouseleave events
mouseenter: null,
mouseleave: null
}
});
By default, the application sets up these event listeners on the document body. However, in cases where you are embedding an Ember application inside an existing page, you may want it to set up the listeners on an element inside the body.
For example, if only events inside a DOM element with the ID of ember-app
should be delegated, set your application's rootElement
property:
let App = Ember.Application.create({
rootElement: '#ember-app'
});
The rootElement
can be either a DOM element or a jQuery-compatible selector
string. Note that views appended to the DOM outside the root element will
not receive events. If you specify a custom root element, make sure you only
append views inside it!
To learn more about the events Ember components use, see components/handling-events.
Initializers
Libraries on top of Ember can add initializers, like so:
Ember.Application.initializer({
name: 'api-adapter',
initialize: function(application) {
application.register('api-adapter:main', ApiAdapter);
}
});
Initializers provide an opportunity to access the internal registry, which organizes the different components of an Ember application. Additionally they provide a chance to access the instantiated application. Beyond being used for libraries, initializers are also a great way to organize dependency injection or setup in your own application.
Routing
In addition to creating your application's router, Ember.Application
is
also responsible for telling the router when to start routing. Transitions
between routes can be logged with the LOG_TRANSITIONS
flag, and more
detailed intra-transition logging can be logged with
the LOG_TRANSITIONS_INTERNAL
flag:
let App = Ember.Application.create({
LOG_TRANSITIONS: true, // basic logging of successful transitions
LOG_TRANSITIONS_INTERNAL: true // detailed logging of all routing steps
});
By default, the router will begin trying to translate the current URL into
application state once the browser emits the DOMContentReady
event. If you
need to defer routing, you can call the application's deferReadiness()
method. Once routing can begin, call the advanceReadiness()
method.
If there is any setup required before routing begins, you can implement a
ready()
method on your app that will be invoked immediately before routing
begins.
Item Index
Methods
- _lazyInjections
- _onLookup
- _prepareForGlobalsMode
- _scheduledDestroy
- addObserver
- advanceReadiness
- beginPropertyChanges
- boot
- buildInstance
- buildRegistry static
- cacheFor
- decrementProperty
- deferReadiness
- destroy
- didBecomeReady
- domReady
- endPropertyChanges
- ensureInitializers
- get
- getProperties
- getWithDefault
- hasObserverFor
- hasRegistration
- incrementProperty
- init
- initializer
- inject
- instanceInitializer
- notifyPropertyChange
- propertyDidChange
- propertyWillChange
- register
- registeredOption
- registeredOptions
- registeredOptionsForType
- registerOption
- registerOptions
- registerOptionsForType
- removeObserver
- reopen
- reopenClass
- reset
- resolveRegistration
- resolverFor
- runInitializers
- runInstanceInitializers
- set
- setProperties
- toggleProperty
- toString
- unregister
- visit
- waitForDOMReady
- willDestroy
Properties
Events
Methods
_lazyInjections
()
Object
private
Returns:
_onLookup
()
private
_prepareForGlobalsMode
()
private
Enable the legacy globals mode by allowing this application to act
as a global namespace. See the docs on the _globalsMode
property
for details.
Most of these features are already deprecated in 1.x, so we can stop using them internally and try to remove them.
_scheduledDestroy
()
private
destroy
method.
addObserver
-
key
-
target
-
method
context
parameter:
`
javascript
fooDidChange: function(sender, key, value, rev) { };
`
The sender is the object that changed. The key is the property that
changes. The value property is currently reserved and unused. The rev
is the last property revision of the object when it changed, which you can
use to detect if the key value has really changed or not.
If you pass a context
parameter, the context will be passed before the
revision like so:
`
javascript
fooDidChange: function(sender, key, value, context, rev) { };
`
Usually you will not need the value, context or revision parameters at
the end. In this case, it is common to write observer methods that take
only a sender and key value as parameters or, if you aren't interested in
any of these values, to write an observer that has no parameters at all.
advanceReadiness
()
public
Call advanceReadiness
after any asynchronous setup logic has completed.
Each call to deferReadiness
must be matched by a call to advanceReadiness
or the application will never become ready and routing will not begin.
beginPropertyChanges
()
Ember.Observable
private
endPropertyChanges()
to deliver the deferred change notifications and end
deferring.
Returns:
boot
()
PromiseInitialize the application and return a promise that resolves with the Ember.Application
object when the boot process is complete.
Run any application initializers and run the application load hook. These hooks may choose to defer readiness. For example, an authentication hook might want to defer readiness until the auth token has been retrieved.
By default, this method is called automatically on "DOM ready"; however, if autoboot
is disabled, this is automatically called when the first application instance is
created via visit
.
Returns:
buildInstance
()
Ember.ApplicationInstance
private
Create an ApplicationInstance for this application.
Returns:
the application instance
buildRegistry
-
namespace
This creates a registry with the default Ember naming conventions.
It also configures the registry:
- registered views are created every time they are looked up (they are not singletons)
- registered templates are not factories; the registered value is returned directly.
- the router receives the application as its
namespace
property - all controllers receive the router as their
target
andcontrollers
properties - all controllers receive the application as their
namespace
property - the application view receives the application controller as its
controller
property - the application view receives the application template as its
defaultTemplate
property
Parameters:
-
namespace
Ember.Applicationthe application for which to build the registry
Returns:
the built registry
cacheFor
-
keyName
Parameters:
-
keyName
String
Returns:
decrementProperty
-
keyName
-
decrement
`
javascript
player.decrementProperty('lives');
orc.decrementProperty('health', 5);
`
Parameters:
-
keyName
StringThe name of the property to decrement -
decrement
NumberThe amount to decrement by. Defaults to 1
Returns:
deferReadiness
()
public
Use this to defer readiness until some condition is true.
Example:
let App = Ember.Application.create();
App.deferReadiness();
// Ember.$ is a reference to the jQuery object/function
Ember.$.getJSON('/auth-token', function(token) {
App.token = token;
App.advanceReadiness();
});
This allows you to perform asynchronous setup logic and defer booting your application until the setup has finished.
However, if the setup requires a loading UI, it might be better to use the router for this purpose.
destroy
()
Ember.Object
public
isDestroyed
flag and removing its
metadata, which effectively destroys observers and bindings.
If you try to set a property on a destroyed object, an exception will be
raised.
Note that destruction is scheduled for the end of the run loop and does not
happen immediately. It will set an isDestroying flag immediately.
Returns:
didBecomeReady
()
private
domReady
()
private
This is the autoboot flow:
- Boot the app by calling
this.boot()
- Create an instance (or use the
__deprecatedInstance__
in globals mode) - Boot the instance by calling
instance.boot()
- Invoke the
App.ready()
callback - Kick-off routing on the instance
Ideally, this is all we would need to do:
_autoBoot() {
this.boot().then(() => {
let instance = (this._globalsMode) ? this.__deprecatedInstance__ : this.buildInstance();
return instance.boot();
}).then((instance) => {
App.ready();
instance.startRouting();
});
}
Unfortunately, we cannot actually write this because we need to participate
in the "synchronous" boot process. While the code above would work fine on
the initial boot (i.e. DOM ready), when App.reset()
is called, we need to
boot a new instance synchronously (see the documentation on _bootSync()
for details).
Because of this restriction, the actual logic of this method is located
inside didBecomeReady()
.
endPropertyChanges
()
Ember.Observable
private
beginPropertyChanges()
at the beginning of the changes to defer change
notifications. When you are done making changes, call this method to
deliver the deferred change notifications and end deferring.
Returns:
ensureInitializers
()
private
get
-
keyName
object[keyName]
or object.keyName
,
however it supports both computed properties and the unknownProperty
handler.
Because get
unifies the syntax for accessing all these kinds
of properties, it can make many refactorings easier, such as replacing a
simple property with a computed property, or vice versa.
### Computed Properties
Computed properties are methods defined with the property
modifier
declared at the end, such as:
`
javascript
fullName: Ember.computed('firstName', 'lastName', function() {
return this.get('firstName') + ' ' + this.get('lastName');
})
`
When you call get
on a computed property, the function will be
called and the return value will be returned instead of the function
itself.
### Unknown Properties
Likewise, if you try to call get
on a property whose value is
undefined
, the unknownProperty()
method will be called on the object.
If this method returns any value other than undefined
, it will be returned
instead. This allows you to implement "virtual" properties that are
not defined upfront.
Parameters:
-
keyName
StringThe property to retrieve
Returns:
getProperties
-
list
getProperties
with a list of strings or an array:
`
javascript
record.getProperties('firstName', 'lastName', 'zipCode');
// { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
`
is equivalent to:
`
javascript
record.getProperties(['firstName', 'lastName', 'zipCode']);
// { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
`
Parameters:
-
list
String... | Arrayof keys to get
Returns:
getWithDefault
-
keyName
-
defaultValue
undefined
.
`
javascript
person.getWithDefault('lastName', 'Doe');
`
Parameters:
-
keyName
StringThe name of the property to retrieve -
defaultValue
ObjectThe value to return if the property value is undefined
Returns:
hasObserverFor
-
key
true
if the object currently has observers registered for a
particular key. You can use this method to potentially defer performing
an expensive action until someone begins observing a particular property
on the object.
Parameters:
-
key
StringKey to check
Returns:
hasRegistration
-
fullName
Parameters:
-
fullName
String
Returns:
incrementProperty
-
keyName
-
increment
`
javascript
person.incrementProperty('age');
team.incrementProperty('score', 2);
`
Parameters:
-
keyName
StringThe name of the property to increment -
increment
NumberThe amount to increment by. Defaults to 1
Returns:
init
()
public
`
javascript
const Person = Ember.Object.extend({
init() {
alert(Name is ${this.get('name')}
);
}
});
let steve = Person.create({
name: "Steve"
});
// alerts 'Name is Steve'.
`
NOTE: If you do override init
for a framework class like Ember.View
,
be sure to call this._super(...arguments)
in your
init
declaration! If you don't, Ember may not have an opportunity to
do important setup work, and you'll see strange behavior in your
application.
initializer
()
private
inject
-
factoryNameOrType
-
property
-
injectionName
`
javascript
let App = Ember.Application.create();
let Session = Ember.Object.extend({ isAuthenticated: false });
// A factory must be registered before it can be injected
App.register('session:main', Session);
// Inject 'session:main' onto all factories of the type 'controller'
// with the name 'session'
App.inject('controller', 'session', 'session:main');
App.IndexController = Ember.Controller.extend({
isLoggedIn: Ember.computed.alias('session.isAuthenticated')
});
`
Injections can also be performed on specific factories.
`
javascript
App.inject(`
It is important to note that injections can only be performed on
classes that are instantiated by Ember itself. Instantiating a class
directly (via create
or new
) bypasses the dependency injection
system.
**Note:** Ember-Data instantiates its models in a unique manner, and consequently
injections onto models (or all models) will not work as expected. Injections
on models can be enabled by setting EmberENV.MODEL_FACTORY_INJECTIONS
to true
.
instanceInitializer
()
private
notifyPropertyChange
-
keyName
propertyWillChange
and propertyDidChange
in
succession.
Parameters:
-
keyName
StringThe property key to be notified about.
Returns:
propertyDidChange
-
keyName
get()
or set()
on it. In this case, you can use this
method and propertyWillChange()
instead. Calling these two methods
together will notify all observers that the property has potentially
changed value.
Note that you must always call propertyWillChange
and propertyDidChange
as a pair. If you do not, it may get the property change groups out of
order and cause notifications to be delivered more often than you would
like.
Parameters:
-
keyName
StringThe property key that has just changed.
Returns:
propertyWillChange
-
keyName
get()
or set()
on it. In this case, you can use this
method and propertyDidChange()
instead. Calling these two methods
together will notify all observers that the property has potentially
changed value.
Note that you must always call propertyWillChange
and propertyDidChange
as a pair. If you do not, it may get the property change groups out of
order and cause notifications to be delivered more often than you would
like.
Parameters:
-
keyName
StringThe property key that is about to change.
Returns:
register
-
fullName
-
factory
-
options
inject
) or for service lookup. Each factory is registered with
a full name including two parts: type:name
.
A simple example:
`
javascript
let App = Ember.Application.create();
App.Orange = Ember.Object.extend();
App.register('fruit:favorite', App.Orange);
`
Ember will resolve factories from the App
namespace automatically.
For example App.CarsController
will be discovered and returned if
an application requests controller:cars
.
An example of registering a controller with a non-standard name:
`
javascript
let App = Ember.Application.create();
let Session = Ember.Controller.extend();
App.register('controller:session', Session);
// The Session controller can now be treated like a normal controller,
// despite its non-standard name.
App.ApplicationController = Ember.Controller.extend({
needs: ['session']
});
`
Registered factories are **instantiated** by having create
called on them. Additionally they are **singletons**, each time
they are looked up they return the same instance.
Some examples modifying that default behavior:
`
javascript
let App = Ember.Application.create();
App.Person = Ember.Object.extend();
App.Orange = Ember.Object.extend();
App.Email = Ember.Object.extend();
App.session = Ember.Object.create();
App.register('model:user', App.Person, { singleton: false });
App.register('fruit:favorite', App.Orange);
App.register('communication:main', App.Email, { singleton: false });
App.register('session', App.session, { instantiate: false });
`
registeredOption
-
fullName
-
optionName
Returns:
registeredOptions
-
fullName
Parameters:
-
fullName
String
Returns:
registeredOptionsForType
-
type
Parameters:
-
type
String
Returns:
registerOption
-
fullName
-
optionName
-
options
registerOptions
-
fullName
-
options
Parameters:
-
fullName
String -
options
Object
registerOptionsForType
-
type
-
options
`
javascript
let App = Ember.Application.create();
let appInstance = App.buildInstance();
// if all of type connection
must not be singletons
appInstance.registerOptionsForType('connection', { singleton: false });
appInstance.register('connection:twitter', TwitterConnection);
appInstance.register('connection:facebook', FacebookConnection);
let twitter = appInstance.lookup('connection:twitter');
let twitter2 = appInstance.lookup('connection:twitter');
twitter === twitter2; // => false
let facebook = appInstance.lookup('connection:facebook');
let facebook2 = appInstance.lookup('connection:facebook');
facebook === facebook2; // => false
`
Parameters:
-
type
String -
options
Object
removeObserver
-
key
-
target
-
method
addObserver()
and your
target will no longer receive notifications.
reopen
()
public
`
javascript
const MyObject = Ember.Object.extend({
name: 'an object'
});
o = MyObject.create();
o.get('name'); // 'an object'
MyObject.reopen({
say(msg){
console.log(msg);
}
})
o2 = MyObject.create();
o2.say("hello"); // logs "hello"
o.say("goodbye"); // logs "goodbye"
`
To add functions and properties to the constructor itself,
see reopenClass
reopenClass
()
public
`
javascript
const MyObject = Ember.Object.extend({
name: 'an object'
});
MyObject.reopenClass({
canBuild: false
});
MyObject.canBuild; // false
o = MyObject.create();
`
In other words, this creates static properties and functions for the class.
These are only available on the class and not on any instance of that class.
`
javascript
const Person = Ember.Object.extend({
name: "",
sayHello() {
alert("Hello. My name is " + this.get('name'));
}
});
Person.reopenClass({
species: "Homo sapiens",
createPerson(newPersonsName){
return Person.create({
name:newPersonsName
});
}
});
let tom = Person.create({
name: "Tom Dale"
});
let yehuda = Person.createPerson("Yehuda Katz");
tom.sayHello(); // "Hello. My name is Tom Dale"
yehuda.sayHello(); // "Hello. My name is Yehuda Katz"
alert(Person.species); // "Homo sapiens"
`
Note that species
and createPerson
are *not* valid on the tom
and yehuda
variables. They are only valid on Person
.
To add functions and properties to instances of
a constructor by extending the constructor's prototype
see reopen
reset
()
public
Reset the application. This is typically used only in tests. It cleans up the application in the following order:
- Deactivate existing routes
- Destroy all objects in the container
- Create a new application container
- Re-route to the existing url
Typical Example:
let App;
run(function() {
App = Ember.Application.create();
});
module('acceptance test', {
setup: function() {
App.reset();
}
});
test('first test', function() {
// App is freshly reset
});
test('second test', function() {
// App is again freshly reset
});
Advanced Example:
Occasionally you may want to prevent the app from initializing during setup. This could enable extra configuration, or enable asserting prior to the app becoming ready.
let App;
run(function() {
App = Ember.Application.create();
});
module('acceptance test', {
setup: function() {
run(function() {
App.reset();
App.deferReadiness();
});
}
});
test('first test', function() {
ok(true, 'something before app is initialized');
run(function() {
App.advanceReadiness();
});
ok(true, 'something after app is initialized');
});
resolveRegistration
-
fullName
Parameters:
-
fullName
String
Returns:
resolverFor
-
namespace
Ember.TEMPLATES
* other names are looked up on the application after classifying the name.
For example, controller:post
looks up App.PostController
by default.
* if the default lookup fails, look for registered classes on the container
This allows the application to register default injections in the container
that could be overridden by the normal naming convention.
Parameters:
-
namespace
Ember.Namespacethe namespace to look for classes
Returns:
runInitializers
()
private
runInstanceInitializers
()
private
set
-
keyName
-
value
`
javascript
record.set("key", value);
`
This method is generally very similar to calling object["key"] = value
or
object.key = value
, except that it provides support for computed
properties, the setUnknownProperty()
method and property observers.
### Computed Properties
If you try to set a value on a key that has a computed property handler
defined (see the get()
method for an example), then set()
will call
that method, passing both the value and key instead of simply changing
the value itself. This is useful for those times when you need to
implement a property that is composed of one or more member
properties.
### Unknown Properties
If you try to set a value on a key that is undefined in the target
object, then the setUnknownProperty()
handler will be called instead. This
gives you an opportunity to implement complex "virtual" properties that
are not predefined on the object. If setUnknownProperty()
returns
undefined, then set()
will simply set the value on the object.
### Property Observers
In addition to changing the property, set()
will also register a property
change with the object. Unless you have placed this call inside of a
beginPropertyChanges()
and endPropertyChanges(),
any "local" observers
(i.e. observer methods declared on the same object), will be called
immediately. Any "remote" observers (i.e. observer methods declared on
another object) will be placed in a queue and called at a later time in a
coalesced manner.
Parameters:
-
keyName
StringThe property to set -
value
ObjectThe value to set ornull
.
Returns:
setProperties
-
hash
beginPropertyChanges
and endPropertyChanges
batch, so
observers will be buffered.
`
javascript
record.setProperties({ firstName: 'Charles', lastName: 'Jolley' });
`
Parameters:
-
hash
Objectthe hash of keys and values to set
Returns:
toggleProperty
-
keyName
`
javascript
starship.toggleProperty('warpDriveEngaged');
`
Parameters:
-
keyName
StringThe name of the property to toggle
Returns:
toString
()
String
public
toString
typically does, in a generic way for all Ember
objects.
`
javascript
const Person = Ember.Object.extend()
person = Person.create()
person.toString() //=> "`
If the object's class is not defined on an Ember namespace, it will
indicate it is a subclass of the registered superclass:
`
javascript
const Student = Person.extend()
let student = Student.create()
student.toString() //=> "<(subclass of Person):ember1025>"
`
If the method toStringExtension
is defined, its return value will be
included in the output.
`
javascript
const Teacher = Person.extend({
toStringExtension() {
return this.get('fullName');
}
});
teacher = Teacher.create()
teacher.toString(); //=> "`
Returns:
unregister
-
fullName
`
javascript
let App = Ember.Application.create();
let User = Ember.Object.extend();
App.register('model:user', User);
App.resolveRegistration('model:user').create() instanceof User //=> true
App.unregister('model:user')
App.resolveRegistration('model:user') === undefined //=> true
`
Parameters:
-
fullName
String
visit
-
url
-
options
Boot a new instance of Ember.ApplicationInstance
for the current
application and navigate it to the given url
. Returns a Promise
that
resolves with the instance when the initial routing and rendering is
complete, or rejects with any error that occured during the boot process.
When autoboot
is disabled, calling visit
would first cause the
application to boot, which runs the application initializers.
This method also takes a hash of boot-time configuration options for
customizing the instance's behavior. See the documentation on
Ember.ApplicationInstance.BootOptions
for details.
Ember.ApplicationInstance.BootOptions
is an interface class that exists
purely to document the available options; you do not need to construct it
manually. Simply pass a regular JavaScript object containing of the
desired options:
MyApp.visit("/", { location: "none", rootElement: "#container" });
Supported Scenarios
While the BootOptions
class exposes a large number of knobs, not all
combinations of them are valid; certain incompatible combinations might
result in unexpected behavior.
For example, booting the instance in the full browser environment
while specifying a foriegn document
object (e.g. { isBrowser: true, document: iframe.contentDocument }
) does not work correctly today,
largely due to Ember's jQuery dependency.
Currently, there are three officially supported scenarios/configurations. Usages outside of these scenarios are not guaranteed to work, but please feel free to file bug reports documenting your experience and any issues you encountered to help expand support.
Browser Applications (Manual Boot)
The setup is largely similar to how Ember works out-of-the-box. Normally,
Ember will boot a default instance for your Application on "DOM ready".
However, you can customize this behavior by disabling autoboot
.
For example, this allows you to render a miniture demo of your application into a specific area on your marketing website:
import MyApp from 'my-app';
$(function() {
let App = MyApp.create({ autoboot: false });
let options = {
// Override the router's location adapter to prevent it from updating
// the URL in the address bar
location: 'none',
// Override the default rootElement
on the app to render into a
// specific div
on the page
rootElement: '#demo'
};
// Start the app at the special demo URL
App.visit('/demo', options);
});
Or perhaps you might want to boot two instances of your app on the same page for a split-screen multiplayer experience:
import MyApp from 'my-app';
$(function() {
let App = MyApp.create({ autoboot: false });
let sessionId = MyApp.generateSessionID();
let player1 = App.visit(/matches/join?name=Player+1&session=${sessionId}
, { rootElement: '#left', location: 'none' });
let player2 = App.visit(/matches/join?name=Player+2&session=${sessionId}
, { rootElement: '#right', location: 'none' });
Promise.all([player1, player2]).then(() => {
// Both apps have completed the initial render
$('#loading').fadeOut();
});
});
Do note that each app instance maintains their own registry/container, so they will run in complete isolation by default.
Server-Side Rendering (also known as FastBoot)
This setup allows you to run your Ember app in a server environment using Node.js and render its content into static HTML for SEO purposes.
const HTMLSerializer = new SimpleDOM.HTMLSerializer(SimpleDOM.voidMap);
function renderURL(url) {
let dom = new SimpleDOM.Document();
let rootElement = dom.body;
let options = { isBrowser: false, document: dom, rootElement: rootElement };
return MyApp.visit(options).then(instance => {
try {
return HTMLSerializer.serialize(rootElement.firstChild);
} finally {
instance.destroy();
}
});
}
In this scenario, because Ember does not have access to a global document
object in the Node.js environment, you must provide one explicitly. In practice,
in the non-browser environment, the stand-in document
object only need to
implement a limited subset of the full DOM API. The SimpleDOM
library is known
to work.
Since there is no access to jQuery in the non-browser environment, you must also
specify a DOM Element
object in the same document
for the rootElement
option
(as opposed to a selector string like "body"
).
See the documentation on the isBrowser
, document
and rootElement
properties
on Ember.ApplicationInstance.BootOptions
for details.
Server-Side Resource Discovery
This setup allows you to run the routing layer of your Ember app in a server environment using Node.js and completely disable rendering. This allows you to simulate and discover the resources (i.e. AJAX requests) needed to fufill a given request and eagerly "push" these resources to the client.
import BrowserNetworkService from 'app/services/network/browser';
import NodeNetworkService from 'app/services/network/node';
// Inject a (hypothetical) service for abstracting all AJAX calls and use
// the appropiate implementaion on the client/server. This also allows the
// server to log all the AJAX calls made during a particular request and use
// that for resource-discovery purpose.
export function initialize(application) {
if (window) { // browser
application.register('service:network', BrowserNetworkService);
} else { // node
application.register('service:network', NodeNetworkService);
}
application.inject('route', 'network', 'service:network');
};
export default {
name: 'network-service',
initialize: initialize
};
import Ember from 'ember';
// An example of how the (hypothetical) service is used in routes.
export default Ember.Route.extend({
model(params) {
return this.network.fetch(/api/posts/${params.post_id}.json
);
},
afterModel(post) {
if (post.isExternalContent) {
return this.network.fetch(/api/external/?url=${post.externalURL}
);
} else {
return post;
}
}
});
// Finally, put all the pieces together
function discoverResourcesFor(url) {
return MyApp.visit(url, { isBrowser: false, shouldRender: false }).then(instance => {
let networkService = instance.lookup('service:network');
return networkService.requests; // => { "/api/posts/123.json": "..." }
});
}
Parameters:
-
url
StringThe initial URL to navigate to
-
options
Ember.ApplicationInstance.BootOptions
Returns:
waitForDOMReady
()
private
Automatically kick-off the boot process for the application once the DOM has become ready.
The initialization itself is scheduled on the actions queue which ensures that code-loading finishes before booting.
If you are asynchronously loading code, you should call deferReadiness()
to defer booting, and then call advanceReadiness()
once all of your code
has finished loading.
willDestroy
()
public
Properties
_globalsMode
Boolean
private
Whether the application should be configured for the legacy "globals mode". Under this mode, the Application object serves as a global namespace for all classes.
let App = Ember.Application.create({
...
});
App.Router.reopen({
location: 'none'
});
App.Router.map({
...
});
App.MyComponent = Ember.Component.extend({
...
});
This flag also exposes other internal APIs that assumes the existence of
a special "default instance", like App.__container__.lookup(...)
.
This option is currently not configurable, its value is derived from
the autoboot
flag – disabling autoboot
also implies opting-out of
globals mode support, although they are ultimately orthogonal concerns.
Some of the global modes features are already deprecated in 1.x. The existence of this flag is to untangle the globals mode code paths from the autoboot code paths, so that these legacy features can be reviewed for deprecation/removal separately.
Forcing the (autoboot=true, _globalsMode=false) here and running the tests would reveal all the places where we are still relying on these legacy behavior internally (mostly just tests).
Default: true
_initializersRan
Unknown
private
autoboot
Boolean
private
Whether the application should automatically start routing and render
templates to the rootElement
on DOM ready. While default by true,
other environments such as FastBoot or a testing harness can set this
property to false
and control the precise timing and behavior of the boot
process.
Default: true
concatenatedProperties
Array
public
classNames
property of Ember.View
.
Here is some sample code showing the difference between a concatenated
property and a normal one:
`
javascript
const Bar = Ember.Object.extend({
// Configure which properties to concatenate
concatenatedProperties: ['concatenatedProperty'],
someNonConcatenatedProperty: ['bar'],
concatenatedProperty: ['bar']
});
const FooBar = Bar.extend({
someNonConcatenatedProperty: ['foo'],
concatenatedProperty: ['foo']
});
let fooBar = FooBar.create();
fooBar.get('someNonConcatenatedProperty'); // ['foo']
fooBar.get('concatenatedProperty'); // ['bar', 'foo']
`
This behavior extends to object creation as well. Continuing the
above example:
`
javascript
let fooBar = FooBar.create({
someNonConcatenatedProperty: ['baz'],
concatenatedProperty: ['baz']
})
fooBar.get('someNonConcatenatedProperty'); // ['baz']
fooBar.get('concatenatedProperty'); // ['bar', 'foo', 'baz']
`
Adding a single property that is not an array will just add it in the array:
`
javascript
let fooBar = FooBar.create({
concatenatedProperty: 'baz'
})
view.get('concatenatedProperty'); // ['bar', 'foo', 'baz']
`
Using the concatenatedProperties
property, we can tell Ember to mix the
content of the properties.
In Ember.Component
the classNames
, classNameBindings
and
attributeBindings
properties are concatenated.
This feature is available for you to use throughout the Ember object model,
although typical app developers are likely to use it infrequently. Since
it changes expectations about behavior of properties, you should properly
document its usage in each individual concatenated property (to not
mislead your users to think they can override the property in a subclass).
Default: null
customEvents
Object
public
The DOM events for which the event dispatcher should listen.
By default, the application's Ember.EventDispatcher
listens
for a set of standard DOM events, such as mousedown
and
keyup
, and delegates them to your application's Ember.View
instances.
If you would like additional bubbling events to be delegated to your
views, set your Ember.Application
's customEvents
property
to a hash containing the DOM event name as the key and the
corresponding view method name as the value. Setting an event to
a value of null
will prevent a default event listener from being
added for that event.
To add new events to be listened to:
let App = Ember.Application.create({
customEvents: {
// add support for the paste event
paste: 'paste'
}
});
To prevent default events from being listened to:
let App = Ember.Application.create({
customEvents: {
// remove support for mouseenter / mouseleave events
mouseenter: null,
mouseleave: null
}
});
Default: null
eventDispatcher
Ember.EventDispatcher
public
The Ember.EventDispatcher
responsible for delegating events to this
application's views.
The event dispatcher is created by the application at initialization time
and sets up event listeners on the DOM element described by the
application's rootElement
property.
See the documentation for Ember.EventDispatcher
for more information.
Default: null
isDestroyed
Unknown
public
true
the observers and bindings were already
removed by the effect of calling the destroy()
method.
Default: false
isDestroying
Unknown
public
destroy()
method has been called.
The object stays intact until the end of the run loop at which point
the isDestroyed
flag is set.
Default: false
mergedProperties
Array
public
queryParams
property of routes.
Here is some sample code showing the difference between a merged
property and a normal one:
`
javascript
const Bar = Ember.Object.extend({
// Configure which properties are to be merged
mergedProperties: ['mergedProperty'],
someNonMergedProperty: {
nonMerged: 'superclass value of nonMerged'
},
mergedProperty: {
page: {replace: false},
limit: {replace: true}
}
});
const FooBar = Bar.extend({
someNonMergedProperty: {
completelyNonMerged: 'subclass value of nonMerged'
},
mergedProperty: {
limit: {replace: false}
}
});
let fooBar = FooBar.create();
fooBar.get('someNonMergedProperty');
// => { completelyNonMerged: 'subclass value of nonMerged' }
//
// Note the entire object, including the nonMerged property of
// the superclass object, has been replaced
fooBar.get('mergedProperty');
// => {
// page: {replace: false},
// limit: {replace: false}
// }
//
// Note the page remains from the superclass, and the
// limit
property's value of false
has been merged from
// the subclass.
`
This behavior is not available during object create
calls. It is only
available at extend
time.
In Ember.Route
the queryParams
property is merged.
This feature is available for you to use throughout the Ember object model,
although typical app developers are likely to use it infrequently. Since
it changes expectations about behavior of properties, you should properly
document its usage in each individual merged property (to not
mislead your users to think they can override the property in a subclass).
Default: null
resolver
Unknown
deprecated
public
Ember.DefaultResolver
rootElement
DOMElement
public
The root DOM element of the Application. This can be specified as an element or a jQuery-compatible selector string.
This is the element that will be passed to the Application's,
eventDispatcher
, which sets up the listeners for event delegation. Every
view in your application should be a child of the element you specify here.
Default: 'body'
Events
ready
public
Called when the Application has become ready, immediately before routing begins. The call will be delayed until the DOM has become ready.