{{title}}
+{{body}}
+ {{render "author" author}}
+- Job @@ -7,29 +7,29 @@ {{#if job.id}} {{#if job.repo.slug}} - {{#linkTo "job" repo job}}{{job.number}}{{/linkTo}} + {{#link-to "job" repo job}}{{job.number}}{{/link-to}} {{/if}} {{/if}}
- {{t jobs.state}}
- {{capitalize job.state}}
- {{t jobs.finished_at}} -
- {{formatTime job.finishedAt}} +
- {{formatTime job.finishedAt}}
- {{t jobs.duration}} -
- {{formatDuration job.duration}} +
- {{formatDuration job.duration}}
- {{t jobs.commit}} -
- {{formatCommit commit}} +
- {{formatCommit commit}} {{#if build.pullRequest}}
- {{t builds.pull_request}} -
- #{{build.pullRequestNumber}} {{build.pullRequestTitle}} +
- #{{build.pullRequestNumber}} {{build.pullRequestTitle}} {{else}} {{#if commit.compareUrl}}
- {{t jobs.compare}} -
- {{pathFrom commit.compareUrl}} +
- {{pathFrom commit.compareUrl}} {{/if}} {{/if}} {{#if commit.authorName}} diff --git a/assets/scripts/app/templates/layouts/top.hbs b/assets/scripts/app/templates/layouts/top.hbs index e883d6aa..0f583cf6 100644 --- a/assets/scripts/app/templates/layouts/top.hbs +++ b/assets/scripts/app/templates/layouts/top.hbs @@ -1,10 +1,10 @@ -{{#linkTo "index.current"}} +{{#link-to "index.current"}}
- - {{#linkTo "index.current"}}{{t layouts.top.home}}{{/linkTo}} + {{#link-to "index.current"}}{{t layouts.top.home}}{{/link-to}}
- {{t layouts.top.blog}} @@ -29,13 +29,13 @@
- Travis CI for Private Repositories -
- +
-
{{#if signedOut}} {{t layouts.top.github_login}} {{/if}} {{#if signedIn}} - {{#linkTo "profile" class="signed-in"}}
{{userName}}{{/linkTo}} + {{#link-to "profile" class="signed-in"}}
- - {{#linkTo "profile.index" class="signed-in"}}{{t layouts.top.accounts}}{{/linkTo}} + {{#link-to "profile.index" class="signed-in"}}{{t layouts.top.accounts}}{{/link-to}}
-
{{t layouts.top.sign_out}}
diff --git a/assets/scripts/app/templates/no_owned_repos.hbs b/assets/scripts/app/templates/no_owned_repos.hbs
index ca925208..534f3481 100644
--- a/assets/scripts/app/templates/no_owned_repos.hbs
+++ b/assets/scripts/app/templates/no_owned_repos.hbs
@@ -11,7 +11,7 @@
Step 1: Enabling your projectsdiff --git a/assets/scripts/app/templates/profile/accounts.hbs b/assets/scripts/app/templates/profile/accounts.hbs index 56f5610b..09c3a2df 100644 --- a/assets/scripts/app/templates/profile/accounts.hbs +++ b/assets/scripts/app/templates/profile/accounts.hbs @@ -2,14 +2,14 @@
- Start by going to your {{#linkTo "profile.index"}}profile{{/linkTo}} and enable one of your projects. We've been + Start by going to your {{#link-to "profile.index"}}profile{{/link-to}} and enable one of your projects. We've been synchronizing all repositories you have administrative access to. Pick one and flip the switch next to it.
- +
-
Accounts
- +
-
{{#with view.account}} {{#if login}} - {{#linkTo "account.index" this}}Repositories{{/linkTo}} + {{#link-to "account.index" this}}Repositories{{/link-to}} {{/if}} {{/with}}
{{#if view.displayUser}}
- - +
-
- {{#linkTo "account.profile" view.account}}Profile{{/linkTo}} + {{#link-to "account.profile" view.account}}Profile{{/link-to}}
{{/if}}
diff --git a/assets/scripts/app/templates/profile/tabs/hooks.hbs b/assets/scripts/app/templates/profile/tabs/hooks.hbs
index dc920183..8aec75ac 100644
--- a/assets/scripts/app/templates/profile/tabs/hooks.hbs
+++ b/assets/scripts/app/templates/profile/tabs/hooks.hbs
@@ -17,13 +17,13 @@
- - {{hook.slug}} +
-
+ {{hook.slug}}
{{#if hook.isSaving}}{{/if}}
{{hook.description}}
- + {{#if hook.active}} ON @@ -54,8 +54,8 @@-
{{#each hook in unAdminisetableHooks}}
-
- - {{hook.slug}} +
-
+ {{hook.slug}}
{{hook.description}}
{{/each}}
diff --git a/assets/scripts/app/templates/profile/tabs/user.hbs b/assets/scripts/app/templates/profile/tabs/user.hbs
index b42239c8..d926d3f2 100644
--- a/assets/scripts/app/templates/profile/tabs/user.hbs
+++ b/assets/scripts/app/templates/profile/tabs/user.hbs
@@ -1,4 +1,4 @@
- - - {{user.login}} + {{user.login}}
-
{{t queue}}: {{queue.name}}
--
+
- +
-
{{t layouts.application.my_repositories}}
- - +
-
{{t layouts.application.recent}}
- - +
-
{{t layouts.application.search}}
-
+ {{bind-attr class="view.canCancelBuild::disabled"}}>
{{/if}}
{{#if view.displayCancelJob}}
-
+ {{bind-attr class="view.canCancelJob::disabled"}}>
{{/if}}
{{#if view.displayRequeueBuild}}
-
+ {{bind-attr class="view.canRequeueBuild::disabled"}}>
{{/if}}
{{#if view.displayRequeueJob}}
-
+ {{bind-attr class="view.canRequeueJob::disabled"}}>
{{/if}}
{{!TODO: for some reason showDownloadLog, which just delegates to jobIdForLog
does not refresh 'if' properly, need further investigation}}
{{#if view.jobIdForLog}}
-
-
+
{{/if}}
{{#if view.displayCodeClimate}}
-
+ {{bind-attr class=":open-popup"}}>
diff --git a/assets/scripts/app/templates/repos/show/tabs.hbs b/assets/scripts/app/templates/repos/show/tabs.hbs
index b1671c2f..e94d49e3 100644
--- a/assets/scripts/app/templates/repos/show/tabs.hbs
+++ b/assets/scripts/app/templates/repos/show/tabs.hbs
@@ -1,58 +1,58 @@
- +
-
{{#if repo.slug}} - {{#linkTo "repo" repo currentWhen="repo.index"}} + {{#link-to "repo" repo currentWhen="repo.index"}} {{t repositories.tabs.current}} - {{/linkTo}} + {{/link-to}} {{/if}}
- - +
-
{{#if repo.slug}} - {{#linkTo "builds" repo}} + {{#link-to "builds" repo}} {{t repositories.tabs.build_history}} - {{/linkTo}} + {{/link-to}} {{/if}}
- - +
-
{{#if repo.slug}} - {{#linkTo "pullRequests" repo}} + {{#link-to "pullRequests" repo}} {{t repositories.tabs.pull_requests}} - {{/linkTo}} + {{/link-to}} {{/if}}
- - +
-
{{#if repo.slug}} - {{#linkTo "branches" repo}} + {{#link-to "branches" repo}} {{t repositories.tabs.branches}} - {{/linkTo}} + {{/link-to}} {{/if}}
- - +
-
{{#if build.id}} {{#if repo.slug}} - {{#linkTo "build" repo build}} + {{#link-to "build" repo build}} {{t repositories.tabs.build}} #{{build.number}} - {{/linkTo}} + {{/link-to}} {{/if}} {{/if}}
- - +
-
{{#if job.id}} {{#if repo.slug}} - {{#linkTo "job" repo job}} + {{#link-to "job" repo job}} {{t repositories.tabs.job}} #{{job.number}} - {{/linkTo}} + {{/link-to}} {{/if}} {{/if}}
diff --git a/assets/scripts/app/templates/repos/show/tools.hbs b/assets/scripts/app/templates/repos/show/tools.hbs index f6368253..5c3523c4 100644 --- a/assets/scripts/app/templates/repos/show/tools.hbs +++ b/assets/scripts/app/templates/repos/show/tools.hbs @@ -6,7 +6,7 @@ - + {{bind-attr class=":open-popup view.canRegenerateKey::disabled"}}> Regenerate Key @@ -14,7 +14,7 @@
- {{post.title}} + {{/each}} + {{/with}} + ``` + + Without the `as` operator, it would be impossible to reference `user.name` in the example above. + @method with @for Ember.Handlebars.helpers @param {Function} context @param {Hash} options @return {String} HTML string */ -EmberHandlebars.registerHelper('with', function(context, options) { +EmberHandlebars.registerHelper('with', function withHelper(context, options) { if (arguments.length === 4) { - var keywordName, path, rootPath, normalized; + var keywordName, path, rootPath, normalized, contextPath; Ember.assert("If you pass more than one argument to the with helper, it must be in the form #with foo as bar", arguments[1] === "as"); options = arguments[3]; @@ -25784,8 +36740,12 @@ EmberHandlebars.registerHelper('with', function(context, options) { Ember.assert("You must pass a block to the with helper", options.fn && options.fn !== Handlebars.VM.noop); + var localizedOptions = o_create(options); + localizedOptions.data = o_create(options.data); + localizedOptions.data.keywords = o_create(options.data.keywords || {}); + if (Ember.isGlobalPath(path)) { - Ember.bind(options.data.keywords, keywordName, path); + contextPath = path; } else { normalized = normalizePath(this, path, options.data); path = normalized.path; @@ -25794,14 +36754,14 @@ EmberHandlebars.registerHelper('with', function(context, options) { // This is a workaround for the fact that you cannot bind separate objects // together. When we implement that functionality, we should use it here. var contextKey = Ember.$.expando + Ember.guidFor(rootPath); - options.data.keywords[contextKey] = rootPath; - + localizedOptions.data.keywords[contextKey] = rootPath; // if the path is '' ("this"), just bind directly to the current context - var contextPath = path ? contextKey + '.' + path : contextKey; - Ember.bind(options.data.keywords, keywordName, contextPath); + contextPath = path ? contextKey + '.' + path : contextKey; } - return bind.call(this, path, options, true, exists); + Ember.bind(localizedOptions.data.keywords, keywordName, contextPath); + + return bind.call(this, path, localizedOptions, true, exists); } else { Ember.assert("You must pass exactly one argument to the with helper", arguments.length === 2); Ember.assert("You must pass a block to the with helper", options.fn && options.fn !== Handlebars.VM.noop); @@ -25819,7 +36779,7 @@ EmberHandlebars.registerHelper('with', function(context, options) { @param {Hash} options @return {String} HTML string */ -EmberHandlebars.registerHelper('if', function(context, options) { +EmberHandlebars.registerHelper('if', function ifHelper(context, options) { Ember.assert("You must pass exactly one argument to the if helper", arguments.length === 2); Ember.assert("You must pass a block to the if helper", options.fn && options.fn !== Handlebars.VM.noop); @@ -25833,7 +36793,7 @@ EmberHandlebars.registerHelper('if', function(context, options) { @param {Hash} options @return {String} HTML string */ -EmberHandlebars.registerHelper('unless', function(context, options) { +EmberHandlebars.registerHelper('unless', function unlessHelper(context, options) { Ember.assert("You must pass exactly one argument to the unless helper", arguments.length === 2); Ember.assert("You must pass a block to the unless helper", options.fn && options.fn !== Handlebars.VM.noop); @@ -25968,7 +36928,11 @@ EmberHandlebars.registerHelper('unless', function(context, options) { @param {Hash} options @return {String} HTML string */ +<<<<<<< HEAD EmberHandlebars.registerHelper('bind-attr', function(options) { +======= +EmberHandlebars.registerHelper('bind-attr', function bindAttrHelper(options) { +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 var attrs = options.hash; @@ -26014,7 +36978,9 @@ EmberHandlebars.registerHelper('bind-attr', function(options) { observer = function observer() { var result = handlebarsGet(ctx, path, options); - Ember.assert(fmt("Attributes must be numbers, strings or booleans, not %@", [result]), result === null || result === undefined || typeof result === 'number' || typeof result === 'string' || typeof result === 'boolean'); + Ember.assert(fmt("Attributes must be numbers, strings or booleans, not %@", [result]), + result === null || result === undefined || typeof result === 'number' || + typeof result === 'string' || typeof result === 'boolean'); var elem = view.$("[data-bindattr-" + dataId + "='" + dataId + "']"); @@ -26064,11 +37030,19 @@ EmberHandlebars.registerHelper('bind-attr', function(options) { @param {Hash} options @return {String} HTML string */ +<<<<<<< HEAD EmberHandlebars.registerHelper('bindAttr', EmberHandlebars.helpers['bind-attr']); /** @private +======= +EmberHandlebars.registerHelper('bindAttr', function bindAttrHelper() { + Ember.warn("The 'bindAttr' view helper is deprecated in favor of 'bind-attr'"); + return EmberHandlebars.helpers['bind-attr'].apply(this, arguments); +}); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 +/** Helper that, given a space-separated string of property paths and a context, returns an array of class names. Calling this method also has the side effect of setting up observers at those property paths, such that if they @@ -26080,6 +37054,7 @@ EmberHandlebars.registerHelper('bindAttr', EmberHandlebars.helpers['bind-attr']) "fooBar"). If the value is a string, it will add that string as the class. Otherwise, it will not add any new class name. + @private @method bindClasses @for Ember.Handlebars @param {Ember.Object} context The context from which to lookup properties @@ -26327,7 +37302,7 @@ EmberHandlebars.ViewHelper = Ember.Object.create({ return 'templateData.keywords.' + path; } else if (Ember.isGlobalPath(path)) { return null; - } else if (path === 'this') { + } else if (path === 'this' || path === '') { return '_parentView.context'; } else { return '_parentView.context.' + path; @@ -26546,7 +37521,7 @@ EmberHandlebars.ViewHelper = Ember.Object.create({ @param {Hash} options @return {String} HTML string */ -EmberHandlebars.registerHelper('view', function(path, options) { +EmberHandlebars.registerHelper('view', function viewHelper(path, options) { Ember.assert("The view helper only takes a single argument", arguments.length <= 2); // If no path is provided, treat path param as options. @@ -26564,8 +37539,6 @@ EmberHandlebars.registerHelper('view', function(path, options) { (function() { -/*globals Handlebars */ - // TODO: Don't require all of this module /** @module ember @@ -26696,7 +37669,7 @@ var get = Ember.get, handlebarsGet = Ember.Handlebars.get, fmt = Ember.String.fm @return {String} HTML string @deprecated Use `{{each}}` helper instead. */ -Ember.Handlebars.registerHelper('collection', function(path, options) { +Ember.Handlebars.registerHelper('collection', function collectionHelper(path, options) { Ember.deprecate("Using the {{collection}} helper without specifying a class has been deprecated as the {{each}} helper now supports the same functionality.", path !== 'collection'); // If no path is provided, treat path param as options. @@ -26727,10 +37700,21 @@ Ember.Handlebars.registerHelper('collection', function(path, options) { if (hash.itemView) { var controller = data.keywords.controller; - Ember.assert('You specified an itemView, but the current context has no container to look the itemView up in. This probably means that you created a view manually, instead of through the container. Instead, use container.lookup("view:viewName"), which will properly instantiate your view.', controller && controller.container); + Ember.assert('You specified an itemView, but the current context has no ' + + 'container to look the itemView up in. This probably means ' + + 'that you created a view manually, instead of through the ' + + 'container. Instead, use container.lookup("view:viewName"), ' + + 'which will properly instantiate your view.', + controller && controller.container); var container = controller.container; itemViewClass = container.resolve('view:' + hash.itemView); +<<<<<<< HEAD Ember.assert('You specified the itemView ' + hash.itemView + ", but it was not found at " + container.describe("view:" + hash.itemView) + " (and it was not registered in the container)", !!itemViewClass); +======= + Ember.assert('You specified the itemView ' + hash.itemView + ", but it was " + + "not found at " + container.describe("view:" + hash.itemView) + + " (and it was not registered in the container)", !!itemViewClass); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 } else if (hash.itemViewClass) { itemViewClass = handlebarsGet(collectionPrototype, hash.itemViewClass, options); } else { @@ -26764,7 +37748,7 @@ Ember.Handlebars.registerHelper('collection', function(path, options) { } var emptyViewClass; - if (inverse && inverse !== Handlebars.VM.noop) { + if (inverse && inverse !== Ember.Handlebars.VM.noop) { emptyViewClass = get(collectionPrototype, 'emptyViewClass'); emptyViewClass = emptyViewClass.extend({ template: inverse, @@ -26819,13 +37803,13 @@ var handlebarsGet = Ember.Handlebars.get; @param {String} property @return {String} HTML string */ -Ember.Handlebars.registerHelper('unbound', function(property, fn) { +Ember.Handlebars.registerHelper('unbound', function unboundHelper(property, fn) { var options = arguments[arguments.length - 1], helper, context, out; if (arguments.length > 2) { // Unbound helper call. options.data.isUnbound = true; - helper = Ember.Handlebars.helpers[arguments[0]] || Ember.Handlebars.helperMissing; + helper = Ember.Handlebars.helpers[arguments[0]] || Ember.Handlebars.helpers.helperMissing; out = helper.apply(this, Array.prototype.slice.call(arguments, 1)); delete options.data.isUnbound; return out; @@ -26846,7 +37830,7 @@ Ember.Handlebars.registerHelper('unbound', function(property, fn) { @submodule ember-handlebars */ -var handlebarsGet = Ember.Handlebars.get, normalizePath = Ember.Handlebars.normalizePath; +var get = Ember.get, handlebarsGet = Ember.Handlebars.get, normalizePath = Ember.Handlebars.normalizePath; /** `log` allows you to output the value of a variable in the current rendering @@ -26860,7 +37844,11 @@ var handlebarsGet = Ember.Handlebars.get, normalizePath = Ember.Handlebars.norma @for Ember.Handlebars.helpers @param {String} property */ +<<<<<<< HEAD Ember.Handlebars.registerHelper('log', function(property, options) { +======= +Ember.Handlebars.registerHelper('log', function logHelper(property, options) { +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 var context = (options.contexts && options.contexts.length) ? options.contexts[0] : this, normalized = normalizePath(context, property, options.data), pathRoot = normalized.root, @@ -26876,14 +37864,44 @@ Ember.Handlebars.registerHelper('log', function(property, options) { {{debugger}} ``` + Before invoking the `debugger` statement, there + are a few helpful variables defined in the + body of this helper that you can inspect while + debugging that describe how and where this + helper was invoked: + + - templateContext: this is most likely a controller + from which this template looks up / displays properties + - typeOfTemplateContext: a string description of + what the templateContext is + + For example, if you're wondering why a value `{{foo}}` + isn't rendering as expected within a template, you + could place a `{{debugger}}` statement, and when + the `debugger;` breakpoint is hit, you can inspect + `templateContext`, determine if it's the object you + expect, and/or evaluate expressions in the console + to perform property lookups on the `templateContext`: + + ``` + > templateContext.get('foo') // -> "
- + Great Hamster Photos + + ``` -(function() { -/** -@module ember -@submodule ember-routing -*/ + To override this option for your entire application, see + "Overriding Application-wide Defaults". + ### Disabling the `link-to` helper + By default `{{link-to}}` is enabled. + any passed value to `disabled` helper property will disable the `link-to` helper. + + static use: the `disabled` option: + + ```handlebars + {{#link-to 'photoGallery' disabled=true}} + Great Hamster Photos + {{/link-to}} + ``` + + dynamic use: the `disabledWhen` option: + + ```handlebars + {{#link-to 'photoGallery' disabledWhen=controller.someProperty}} + Great Hamster Photos + {{/link-to}} + ``` + + any passed value to `disabled` will disable it except `undefined`. + to ensure that only `true` disable the `link-to` helper you can + override the global behaviour of `Ember.LinkView`. + + ```javascript + Ember.LinkView.reopen({ + disabled: Ember.computed(function(key, value) { + if (value !== undefined) { + this.set('_isDisabled', value === true); + } + return value === true ? get(this, 'disabledClass') : false; + }) + }); + ``` + + see "Overriding Application-wide Defaults" for more. + + ### Handling `href` + `{{link-to}}` will use your application's Router to + fill the element's `href` property with a url that + matches the path to the supplied `routeName` for your + routers's configured `Location` scheme, which defaults + to Ember.HashLocation. + + ### Handling current route + `{{link-to}}` will apply a CSS class name of 'active' + when the application's current route matches + the supplied routeName. For example, if the application's + current route is 'photoGallery.recent' the following + use of `{{link-to}}`: + + ```handlebars + {{#link-to 'photoGallery.recent'}} + Great Hamster Photos from the last week + {{/link-to}} + ``` + + will result in +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + + ```html + + Great Hamster Photos + + ``` + +<<<<<<< HEAD var get = Ember.get, set = Ember.set; Ember.onLoad('Ember.Handlebars', function(Handlebars) { /** @@ -34208,9 +47902,216 @@ Ember.onLoad('Ember.Handlebars', function(Handlebars) { options.hash.currentViewBinding = '_view.outletSource._outlets.' + property; return Handlebars.helpers.view.call(this, outletContainerClass, options); +======= + The CSS class name used for active classes can be customized + for a single use of `{{link-to}}` by passing an `activeClass` + option: + + ```handlebars + {{#link-to 'photoGallery.recent' activeClass="current-url"}} + Great Hamster Photos from the last week + {{/link-to}} + ``` + + ```html + + Great Hamster Photos + + ``` + + To override this option for your entire application, see + "Overriding Application-wide Defaults". + + ### Supplying a model + An optional model argument can be used for routes whose + paths contain dynamic segments. This argument will become + the model context of the linked route: + + ```javascript + App.Router.map(function() { + this.resource("photoGallery", {path: "hamster-photos/:photo_id"}); + }); + ``` + + ```handlebars + {{#link-to 'photoGallery' aPhoto}} + {{aPhoto.title}} + {{/link-to}} + ``` + + ```html + + Tomster + + ``` + + ### Supplying multiple models + For deep-linking to route paths that contain multiple + dynamic segments, multiple model arguments can be used. + As the router transitions through the route path, each + supplied model argument will become the context for the + route with the dynamic segments: + + ```javascript + App.Router.map(function() { + this.resource("photoGallery", {path: "hamster-photos/:photo_id"}, function() { + this.route("comment", {path: "comments/:comment_id"}); + }); + }); + ``` + This argument will become the model context of the linked route: + + ```handlebars + {{#link-to 'photoGallery.comment' aPhoto comment}} + {{comment.body}} + {{/link-to}} + ``` + + ```html + + A+++ would snuggle again. + + ``` + + ### Supplying an explicit dynamic segment value + If you don't have a model object available to pass to `{{link-to}}`, + an optional string or integer argument can be passed for routes whose + paths contain dynamic segments. This argument will become the value + of the dynamic segment: + + ```javascript + App.Router.map(function() { + this.resource("photoGallery", {path: "hamster-photos/:photo_id"}); + }); + ``` + + ```handlebars + {{#link-to 'photoGallery' aPhotoId}} + {{aPhoto.title}} + {{/link-to}} + ``` + + ```html + + Tomster + + ``` + + When transitioning into the linked route, the `model` hook will + be triggered with parameters including this passed identifier. + + ### Allowing Default Action + + By default the `{{link-to}}` helper prevents the default browser action + by calling `preventDefault()` as this sort of action bubbling is normally + handled internally and we do not want to take the browser to a new URL (for + example). + + If you need to override this behavior specify `preventDefault=false` in + your template: + + ```handlebars + {{#link-to 'photoGallery' aPhotoId preventDefault=false}} + {{aPhotoId.title}} + {{/link-to}} + ``` + + ### Overriding attributes + You can override any given property of the Ember.LinkView + that is generated by the `{{link-to}}` helper by passing + key/value pairs, like so: + + ```handlebars + {{#link-to aPhoto tagName='li' title='Following this link will change your life' classNames='pic sweet'}} + Uh-mazing! + {{/link-to}} + ``` + + See [Ember.LinkView](/api/classes/Ember.LinkView.html) for a + complete list of overrideable properties. Be sure to also + check out inherited properties of `LinkView`. + + ### Overriding Application-wide Defaults + ``{{link-to}}`` creates an instance of Ember.LinkView + for rendering. To override options for your entire + application, reopen Ember.LinkView and supply the + desired values: + + ``` javascript + Ember.LinkView.reopen({ + activeClass: "is-active", + tagName: 'li' + }) + ``` + + It is also possible to override the default event in + this manner: + + ``` javascript + Ember.LinkView.reopen({ + eventName: 'customEventName' + }); + ``` + + @method link-to + @for Ember.Handlebars.helpers + @param {String} routeName + @param {Object} [context]* + @param [options] {Object} Handlebars key/value pairs of options, you can override any property of Ember.LinkView + @return {String} HTML string + @see {Ember.LinkView} + */ + Ember.Handlebars.registerHelper('link-to', function linkToHelper(name) { + var options = [].slice.call(arguments, -1)[0], + params = [].slice.call(arguments, 0, -1), + hash = options.hash; + + hash.disabledBinding = hash.disabledWhen; + + if (!options.fn) { + var linkTitle = params.shift(); + var linkType = options.types.shift(); + var context = this; + if (linkType === 'ID') { + options.linkTextPath = linkTitle; + options.fn = function() { + return Ember.Handlebars.get(context, linkTitle, options); + }; + } else { + options.fn = function() { + return linkTitle; + }; + } + } + + hash.parameters = { + context: this, + options: options, + params: params + }; + + return Ember.Handlebars.helpers.view.call(this, LinkView, options); + }); + + /** + See [link-to](/api/classes/Ember.Handlebars.helpers.html#method_link-to) + + @method linkTo + @for Ember.Handlebars.helpers + @deprecated + @param {String} routeName + @param {Object} [context]* + @return {String} HTML string + */ + Ember.Handlebars.registerHelper('linkTo', function linkToHelper() { + Ember.warn("The 'linkTo' view helper is deprecated in favor of 'link-to'"); + return Ember.Handlebars.helpers['link-to'].apply(this, arguments); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 }); }); + + })(); @@ -34223,6 +48124,7 @@ Ember.onLoad('Ember.Handlebars', function(Handlebars) { var get = Ember.get, set = Ember.set; Ember.onLoad('Ember.Handlebars', function(Handlebars) { +<<<<<<< HEAD /** Calling ``{{render}}`` from within a template will insert another @@ -34356,9 +48258,24 @@ Ember.onLoad('Ember.Handlebars', function(Handlebars) { }); })(); +======= + /** + @module ember + @submodule ember-routing + */ + Handlebars.OutletView = Ember.ContainerView.extend(Ember._Metamorph); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + /** + The `outlet` helper is a placeholder that the router will fill in with + the appropriate template based on the current state of the application. + ``` handlebars + {{outlet}} + ``` + +<<<<<<< HEAD (function() { /** @module ember @@ -34490,6 +48407,100 @@ Ember.onLoad('Ember.Handlebars', function(Handlebars) { ``` Will result in the following rendered HTML +======= + By default, a template based on Ember's naming conventions will be rendered + into the `outlet` (e.g. `App.PostsRoute` will render the `posts` template). + + You can render a different template by using the `render()` method in the + route's `renderTemplate` hook. The following will render the `favoritePost` + template into the `outlet`. + + ``` javascript + App.PostsRoute = Ember.Route.extend({ + renderTemplate: function() { + this.render('favoritePost'); + } + }); + ``` + + You can create custom named outlets for more control. + + ``` handlebars + {{outlet 'favoritePost'}} + {{outlet 'posts'}} + ``` + + Then you can define what template is rendered into each outlet in your + route. + + + ``` javascript + App.PostsRoute = Ember.Route.extend({ + renderTemplate: function() { + this.render('favoritePost', { outlet: 'favoritePost' }); + this.render('posts', { outlet: 'posts' }); + } + }); + ``` + + You can specify the view that the outlet uses to contain and manage the + templates rendered into it. + + ``` handlebars + {{outlet view='sectionContainer'}} + ``` + + ``` javascript + App.SectionContainer = Ember.ContainerView.extend({ + tagName: 'section', + classNames: ['special'] + }); + ``` + + @method outlet + @for Ember.Handlebars.helpers + @param {String} property the property on the controller + that holds the view for this outlet + @return {String} HTML string + */ + Handlebars.registerHelper('outlet', function outletHelper(property, options) { + + var outletSource, + container, + viewName, + viewClass, + viewFullName; + + if (property && property.data && property.data.isRenderData) { + options = property; + property = 'main'; + } + + container = options.data.view.container; + + outletSource = options.data.view; + while (!outletSource.get('template.isTop')) { + outletSource = outletSource.get('_parentView'); + } + + // provide controller override + viewName = options.hash.view; + + if (viewName) { + viewFullName = 'view:' + viewName; + Ember.assert("Using a quoteless view parameter with {{outlet}} is not supported. Please update to quoted usage '{{outlet \"" + viewName + "\"}}.", options.hashTypes.view !== 'ID'); + Ember.assert("The view name you supplied '" + viewName + "' did not resolve to a view.", container.has(viewFullName)); + } + + viewClass = viewName ? container.lookupFactory(viewFullName) : options.hash.viewClass || Handlebars.OutletView; + + options.data.view.set('outletSource', outletSource); + options.hash.currentViewBinding = '_view.outletSource._outlets.' + property; + + return Handlebars.helpers.view.call(this, viewClass, options); + }); +}); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 ```html
-
{{#each job in queue}}
{{#view Travis.QueueItemView jobBinding="job"}}
{{#if job.repo.slug}}
- {{#linkTo "job" job.repo job}}
+ {{#link-to "job" job.repo job}}
{{job.repo.slug}}
#{{job.number}}
- {{/linkTo}}
+ {{/link-to}}
{{/if}}
{{/view}}
{{else}}
diff --git a/assets/scripts/app/templates/repos/list.hbs b/assets/scripts/app/templates/repos/list.hbs
index 378891fc..09e0cdd9 100644
--- a/assets/scripts/app/templates/repos/list.hbs
+++ b/assets/scripts/app/templates/repos/list.hbs
@@ -11,22 +11,22 @@
{{#if slug}} - {{#linkTo "repo" this class="slug"}}{{slug}}{{/linkTo}} + {{#link-to "repo" this class="slug"}}{{slug}}{{/link-to}} {{/if}}{{#with lastBuildHash}} {{#if repo.slug}} - {{#linkTo "build" repo id class="last_build"}}{{number}}{{/linkTo}} + {{#link-to "build" repo id class="last_build"}}{{number}}{{/link-to}} {{/if}} {{/with}}{{t repositories.duration}}: - {{formatDuration lastBuildDuration}} + {{formatDuration lastBuildDuration}}
{{t repositories.finished_at}}: - {{formatTime lastBuildFinishedAt}} + {{formatTime lastBuildFinishedAt}}
diff --git a/assets/scripts/app/templates/repos/list/tabs.hbs b/assets/scripts/app/templates/repos/list/tabs.hbs index 3511bef4..04d03fa3 100644 --- a/assets/scripts/app/templates/repos/list/tabs.hbs +++ b/assets/scripts/app/templates/repos/list/tabs.hbs @@ -1,13 +1,13 @@-
-
+{{#if view.isEmpty}} {{view Travis.ReposEmptyView}} {{else}} {{#if repo.isLoaded}} {{#with repo}}-diff --git a/assets/scripts/app/templates/repos/show/actions.hbs b/assets/scripts/app/templates/repos/show/actions.hbs index 181d23e6..362c9536 100644 --- a/assets/scripts/app/templates/repos/show/actions.hbs +++ b/assets/scripts/app/templates/repos/show/actions.hbs @@ -3,39 +3,39 @@ {{#if view.displayCancelBuild}}{{#linkTo "repo" this}}{{slug}}{{/linkTo}}
-+
{{#link-to "repo" this}}{{slug}}{{/link-to}}
+{{view Travis.RepoShowToolsView}}-
-
+
Integrating Code Climate's test coverage reporting with your test suite on Travis CI allows to track changes in coverage over time. If you haven't tried it out already, sign +======= + {{bind-attr href="Travis.config.code_climate_url"}}" target="_blank">sign +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 up today to improve your code's quality. New customers get 20% off for the first three months!
diff --git a/assets/scripts/app/templates/status_images.hbs b/assets/scripts/app/templates/status_images.hbs index f5dc5c0a..0f832f2b 100644 --- a/assets/scripts/app/templates/status_images.hbs +++ b/assets/scripts/app/templates/status_images.hbs @@ -9,25 +9,25 @@- +
- +
- +
- +
- +
- +
diff --git a/assets/scripts/app/templates/workers/list.hbs b/assets/scripts/app/templates/workers/list.hbs index 6f41d33e..a9387fe9 100644 --- a/assets/scripts/app/templates/workers/list.hbs +++ b/assets/scripts/app/templates/workers/list.hbs @@ -14,9 +14,9 @@ {{#if worker.isWorking}} {{#if worker.jobId}} - {{#linkTo "job" worker.repo worker.jobId}} + {{#link-to "job" worker.repo worker.jobId}} {{view.display}} - {{/linkTo}} + {{/link-to}} {{/if}} {{else}} {{view.display}} diff --git a/assets/scripts/app/views/repo/show.coffee b/assets/scripts/app/views/repo/show.coffee index a27a0b29..5deaf914 100644 --- a/assets/scripts/app/views/repo/show.coffee +++ b/assets/scripts/app/views/repo/show.coffee @@ -37,7 +37,7 @@ Travis.reopen tabBinding: 'controller.tab' contextBinding: 'controller' - # hrm. how to parametrize bindAttr? + # hrm. how to parametrize bind-attr? classCurrent: (-> 'active' if @get('tab') == 'current' ).property('tab') diff --git a/assets/scripts/app/views/top.coffee b/assets/scripts/app/views/top.coffee index ac9e8d24..fe5d7aea 100644 --- a/assets/scripts/app/views/top.coffee +++ b/assets/scripts/app/views/top.coffee @@ -4,7 +4,7 @@ tabBinding: 'controller.tab' - # hrm. how to parametrize bindAttr? + # hrm. how to parametrize bind-attr? classHome: (-> 'active' if @get('tab') == 'home' ).property('tab') diff --git a/assets/scripts/vendor/ember.js b/assets/scripts/vendor/ember.js index 735ee4b1..c5b93786 100644 --- a/assets/scripts/vendor/ember.js +++ b/assets/scripts/vendor/ember.js @@ -1,3 +1,4 @@ +<<<<<<< HEAD // ========================================================================== // Project: Ember - JavaScript Application Framework // Copyright: Copyright 2011-2013 Tilde Inc. and contributors @@ -6,6 +7,17 @@ // License: Licensed under MIT license // See https://raw.github.com/emberjs/ember.js/master/LICENSE // ========================================================================== +======= +/*! + * @overview Ember - JavaScript Application Framework + * @copyright Copyright 2011-2014 Tilde Inc. and contributors + * Portions Copyright 2006-2011 Strobe Inc. + * Portions Copyright 2008-2011 Apple Inc. All rights reserved. + * @license Licensed under MIT license + * See https://raw.github.com/emberjs/ember.js/master/LICENSE + * @version 1.3.0 + */ +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 // Version: 1.2.0 @@ -32,7 +44,20 @@ if ('undefined' === typeof Ember) { } } -Ember.ENV = 'undefined' === typeof ENV ? {} : ENV; +// This needs to be kept in sync with the logic in +// `packages/ember-metal/lib/core.js`. +// +// This is duplicated here to ensure that `Ember.ENV` +// is setup even if `Ember` is not loaded yet. +if (Ember.ENV) { + // do nothing if Ember.ENV is already setup +} else if ('undefined' !== typeof EmberENV) { + Ember.ENV = EmberENV; +} else if('undefined' !== typeof ENV) { + Ember.ENV = ENV; +} else { + Ember.ENV = {}; +} if (!('MANDATORY_SETTER' in Ember.ENV)) { Ember.ENV.MANDATORY_SETTER = true; // default to true for debug dist @@ -184,6 +209,7 @@ if (!Ember.testing) { })(); +<<<<<<< HEAD // ========================================================================== // Project: Ember - JavaScript Application Framework // Copyright: Copyright 2011-2013 Tilde Inc. and contributors @@ -192,12 +218,23 @@ if (!Ember.testing) { // License: Licensed under MIT license // See https://raw.github.com/emberjs/ember.js/master/LICENSE // ========================================================================== +======= +/*! + * @overview Ember - JavaScript Application Framework + * @copyright Copyright 2011-2014 Tilde Inc. and contributors + * Portions Copyright 2006-2011 Strobe Inc. + * Portions Copyright 2008-2011 Apple Inc. All rights reserved. + * @license Licensed under MIT license + * See https://raw.github.com/emberjs/ember.js/master/LICENSE + * @version 1.3.0 + */ +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 // Version: 1.2.0 (function() { -var define, requireModule; +var define, requireModule, require, requirejs; (function() { var registry = {}, seen = {}; @@ -206,36 +243,52 @@ var define, requireModule; registry[name] = { deps: deps, callback: callback }; }; - requireModule = function(name) { + requirejs = require = requireModule = function(name) { + requirejs._eak_seen = registry; + if (seen[name]) { return seen[name]; } seen[name] = {}; - var mod, deps, callback, reified, exports; - - mod = registry[name]; - - if (!mod) { - throw new Error("Module '" + name + "' not found."); + if (!registry[name]) { + throw new Error("Could not find module " + name); } - deps = mod.deps; - callback = mod.callback; - reified = []; + var mod = registry[name], + deps = mod.deps, + callback = mod.callback, + reified = [], + exports; for (var i=0, l=deps.length; i>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + + ```javascript + function(item, index, enumerable); + ``` + + - `item` is the current item in the iteration. + - `index` is the current index in the iteration. + - `enumerable` is the enumerable object itself. + + It should return the `true` or `false`. + + Note that in addition to a callback, you can also pass an optional target + object that will be set as `this` on the context. This is a good way + to give your iterator function access to the current object. + + Example Usage: + + ```javascript + if (people.every(isEngineer)) { Paychecks.addBigBonus(); } + ``` + + @method every + @param {Function} callback The callback to execute + @param {Object} [target] The target object to use + @return {Boolean} + */ + every: function(callback, target) { + return !this.find(function(x, idx, i) { + return !callback.call(target, x, idx, i); + }); + }, + + /** + @method everyBy + @param {String} key the property to test + @param {String} [value] optional value to test against. + @deprecated Use `isEvery` instead + @return {Boolean} + */ + everyBy: Ember.aliasMethod('isEvery'), + + /** + @method everyProperty + @param {String} key the property to test + @param {String} [value] optional value to test against. + @deprecated Use `isEvery` instead + @return {Boolean} + */ + everyProperty: Ember.aliasMethod('isEvery'), + + /** + Returns `true` if the passed property resolves to `true` for all items in + the enumerable. This method is often simpler/faster than using a callback. + + @method isEvery + @param {String} key the property to test + @param {String} [value] optional value to test against. + @return {Boolean} + */ + isEvery: function(key, value) { + return this.every(iter.apply(this, arguments)); + }, + + /** + Returns `true` if the passed function returns true for any item in the + enumeration. This corresponds with the `some()` method in JavaScript 1.6. + + The callback method you provide should have the following signature (all + parameters are optional): + + ```javascript + function(item, index, enumerable); + ``` + + - `item` is the current item in the iteration. + - `index` is the current index in the iteration. + - `enumerable` is the enumerable object itself. + + It should return the `true` to include the item in the results, `false` + otherwise. + + Note that in addition to a callback, you can also pass an optional target + object that will be set as `this` on the context. This is a good way + to give your iterator function access to the current object. + + Usage Example: + + ```javascript + if (people.any(isManager)) { Paychecks.addBiggerBonus(); } + ``` + + @method any + @param {Function} callback The callback to execute + @param {Object} [target] The target object to use + @return {Boolean} `true` if the passed function returns `true` for any item + */ +<<<<<<< HEAD + capitalize: function(str) { + return str.charAt(0).toUpperCase() + str.substr(1); + } +}; + + + +})(); + +======= + any: function(callback, target) { + var found = this.find(function(x, idx, i) { + return !!callback.call(target, x, idx, i); + }); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + + return typeof found !== 'undefined'; + }, + + /** + Returns `true` if the passed function returns true for any item in the + enumeration. This corresponds with the `some()` method in JavaScript 1.6. + + The callback method you provide should have the following signature (all + parameters are optional): + + ```javascript + function(item, index, enumerable); + ``` + + - `item` is the current item in the iteration. + - `index` is the current index in the iteration. + - `enumerable` is the enumerable object itself. + +<<<<<<< HEAD + +if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.String) { + + /** + See [Ember.String.fmt](/api/classes/Ember.String.html#method_fmt). +======= + It should return the `true` to include the item in the results, `false` + otherwise. + + Note that in addition to a callback, you can also pass an optional target + object that will be set as `this` on the context. This is a good way + to give your iterator function access to the current object. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + + Usage Example: + +<<<<<<< HEAD + /** + See [Ember.String.w](/api/classes/Ember.String.html#method_w). +======= + ```javascript + if (people.some(isManager)) { Paychecks.addBiggerBonus(); } + ``` +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + + @method some + @param {Function} callback The callback to execute + @param {Object} [target] The target object to use + @return {Boolean} `true` if the passed function returns `true` for any item + @deprecated Use `any` instead + */ + some: Ember.aliasMethod('any'), + + /** +<<<<<<< HEAD + See [Ember.String.loc](/api/classes/Ember.String.html#method_loc). +======= + Returns `true` if the passed property resolves to `true` for any item in + the enumerable. This method is often simpler/faster than using a callback. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + + @method isAny + @param {String} key the property to test + @param {String} [value] optional value to test against. + @return {Boolean} `true` if the passed function returns `true` for any item + */ + isAny: function(key, value) { + return this.any(iter.apply(this, arguments)); + }, + + /** +<<<<<<< HEAD + See [Ember.String.camelize](/api/classes/Ember.String.html#method_camelize). + + @method camelize + @for String +======= + @method anyBy + @param {String} key the property to test + @param {String} [value] optional value to test against. + @return {Boolean} `true` if the passed function returns `true` for any item + @deprecated Use `isAny` instead +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + */ + anyBy: Ember.aliasMethod('isAny'), + + /** +<<<<<<< HEAD + See [Ember.String.decamelize](/api/classes/Ember.String.html#method_decamelize). + + @method decamelize + @for String +======= + @method someProperty + @param {String} key the property to test + @param {String} [value] optional value to test against. + @return {Boolean} `true` if the passed function returns `true` for any item + @deprecated Use `isAny` instead +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + */ + someProperty: Ember.aliasMethod('isAny'), + + /** +<<<<<<< HEAD + See [Ember.String.dasherize](/api/classes/Ember.String.html#method_dasherize). +======= + This will combine the values of the enumerator into a single value. It + is a useful way to collect a summary value from an enumeration. This + corresponds to the `reduce()` method defined in JavaScript 1.8. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + + The callback method you provide should have the following signature (all + parameters are optional): + +<<<<<<< HEAD + /** + See [Ember.String.underscore](/api/classes/Ember.String.html#method_underscore). +======= + ```javascript + function(previousValue, item, index, enumerable); + ``` +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + + - `previousValue` is the value returned by the last call to the iterator. + - `item` is the current item in the iteration. + - `index` is the current index in the iteration. + - `enumerable` is the enumerable object itself. + +<<<<<<< HEAD + /** + See [Ember.String.classify](/api/classes/Ember.String.html#method_classify). +======= + Return the new cumulative value. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + + In addition to the callback you can also pass an `initialValue`. An error + will be raised if you do not pass an initial value and the enumerator is + empty. + +<<<<<<< HEAD + /** + See [Ember.String.capitalize](/api/classes/Ember.String.html#method_capitalize). +======= + Note that unlike the other methods, this method does not allow you to + pass a target object to set as this for the callback. It's part of the + spec. Sorry. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + + @method reduce + @param {Function} callback The callback to execute + @param {Object} initialValue Initial value for the reduce + @param {String} reducerProperty internal use only. + @return {Object} The reduced value. + */ +<<<<<<< HEAD + String.prototype.capitalize = function() { + return capitalize(this); + }; + + +} +======= + reduce: function(callback, initialValue, reducerProperty) { + if (typeof callback !== "function") { throw new TypeError(); } +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + + var ret = initialValue; + + this.forEach(function(item, i) { + ret = callback.call(null, ret, item, i, this, reducerProperty); + }, this); + + return ret; + }, + + /** + Invokes the named method on every object in the receiver that + implements it. This method corresponds to the implementation in + Prototype 1.6. + + @method invoke + @param {String} methodName the name of the method + @param {Object...} args optional arguments to pass as well. + @return {Array} return values from calling invoke. + */ + invoke: function(methodName) { + var args, ret = Ember.A(); + if (arguments.length>1) args = a_slice.call(arguments, 1); + +<<<<<<< HEAD +var get = Ember.get, + set = Ember.set, + slice = Array.prototype.slice, + getProperties = Ember.getProperties; + +/** + ## Overview + + This mixin provides properties and property observing functionality, core + features of the Ember object model. + + Properties and observers allow one object to observe changes to a + property on another object. This is one of the fundamental ways that + models, controllers and views communicate with each other in an Ember + application. + + Any object that has this mixin applied can be used in observer + operations. That includes `Ember.Object` and most objects you will + interact with as you write your Ember application. + + Note that you will not generally apply this mixin to classes yourself, + but you will use the features provided by this module frequently, so it + is important to understand how to use it. + + ## Using `get()` and `set()` + + Because of Ember's support for bindings and observers, you will always + access properties using the get method, and set properties using the + set method. This allows the observing objects to be notified and + computed properties to be handled properly. + + More documentation about `get` and `set` are below. + + ## Observing Property Changes + + You typically observe property changes simply by adding the `observes` + call to the end of your method declarations in classes that you write. + For example: + + ```javascript + Ember.Object.extend({ + valueObserver: function() { + // Executes whenever the "value" property changes + }.observes('value') + }); + ``` + + Although this is the most common way to add an observer, this capability + is actually built into the `Ember.Object` class on top of two methods + defined in this mixin: `addObserver` and `removeObserver`. You can use + these two methods to add and remove observers yourself if you need to + do so at runtime. + + To add an observer for a property, call: + + ```javascript + object.addObserver('propertyKey', targetObject, targetAction) + ``` + + This will call the `targetAction` method on the `targetObject` whenever + the value of the `propertyKey` changes. + + Note that if `propertyKey` is a computed property, the observer will be + called when any of the property dependencies are changed, even if the + resulting value of the computed property is unchanged. This is necessary + because computed properties are not computed until `get` is called. + + @class Observable + @namespace Ember +*/ +Ember.Observable = Ember.Mixin.create({ + + /** + Retrieves the value of a property from the object. + + This method is usually similar to using `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: function() { + return this.get('firstName') + ' ' + this.get('lastName'); + }.property('firstName', '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. + + @method get + @param {String} keyName The property to retrieve + @return {Object} The property value or undefined. + */ + get: function(keyName) { + return get(this, keyName); + }, + + /** + To get multiple properties at once, call `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' } + ``` + + @method getProperties + @param {String...|Array} list of keys to get + @return {Hash} + */ + getProperties: function() { + return getProperties.apply(null, [this].concat(slice.call(arguments))); + }, + + /** + Sets the provided key or path to the 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. +======= + this.forEach(function(x, idx) { + var method = x && x[methodName]; + if ('function' === typeof method) { + ret[idx] = args ? method.apply(x, args) : method.call(x); + } + }, this); + + return ret; + }, + + /** + Simply converts the enumerable into a genuine array. The order is not + guaranteed. Corresponds to the method implemented by Prototype. + + @method toArray + @return {Array} the enumerable as an array. + */ + toArray: function() { + var ret = Ember.A(); + this.forEach(function(o, idx) { ret[idx] = o; }); + return ret ; + }, + + /** + Returns a copy of the array with all null and undefined elements removed. + + ```javascript + var arr = ["a", null, "c", undefined]; + arr.compact(); // ["a", "c"] + ``` + + @method compact + @return {Array} the array without null and undefined elements. + */ + compact: function() { + return this.filter(function(value) { return value != null; }); + }, + + /** + Returns a new enumerable that excludes the passed value. The default + implementation returns an array regardless of the receiver type unless + the receiver does not contain the value. + + ```javascript + var arr = ["a", "b", "a", "c"]; + arr.without("a"); // ["b", "c"] + ``` + + @method without + @param {Object} value + @return {Ember.Enumerable} + */ + without: function(value) { + if (!this.contains(value)) return this; // nothing to do + var ret = Ember.A(); + this.forEach(function(k) { + if (k !== value) ret[ret.length] = k; + }) ; + return ret ; + }, + + /** + Returns a new enumerable that contains only unique values. The default + implementation returns an array regardless of the receiver type. + + ```javascript + var arr = ["a", "a", "b", "b"]; + arr.uniq(); // ["a", "b"] + ``` + + @method uniq + @return {Ember.Enumerable} + */ + uniq: function() { + var ret = Ember.A(); + this.forEach(function(k) { + if (a_indexOf(ret, k)<0) ret.push(k); + }); + return ret; + }, + + /** + This property will trigger anytime the enumerable's content changes. + You can observe this property to be notified of changes to the enumerables + content. + + For plain enumerables, this property is read only. `Ember.Array` overrides + this method. + + @property [] + @type Ember.Array + @return this + */ + '[]': Ember.computed(function(key, value) { + return this; + }), + + // .......................................................... + // ENUMERABLE OBSERVERS + // + + /** + Registers an enumerable observer. Must implement `Ember.EnumerableObserver` + mixin. + + @method addEnumerableObserver + @param {Object} target + @param {Hash} [opts] + @return this + */ + addEnumerableObserver: function(target, opts) { + var willChange = (opts && opts.willChange) || 'enumerableWillChange', + didChange = (opts && opts.didChange) || 'enumerableDidChange'; + + var hasObservers = get(this, 'hasEnumerableObservers'); + if (!hasObservers) Ember.propertyWillChange(this, 'hasEnumerableObservers'); + Ember.addListener(this, '@enumerable:before', target, willChange); + Ember.addListener(this, '@enumerable:change', target, didChange); + if (!hasObservers) Ember.propertyDidChange(this, 'hasEnumerableObservers'); + return this; + }, + + /** + Removes a registered enumerable observer. + + @method removeEnumerableObserver + @param {Object} target + @param {Hash} [opts] + @return this + */ + removeEnumerableObserver: function(target, opts) { + var willChange = (opts && opts.willChange) || 'enumerableWillChange', + didChange = (opts && opts.didChange) || 'enumerableDidChange'; + + var hasObservers = get(this, 'hasEnumerableObservers'); + if (hasObservers) Ember.propertyWillChange(this, 'hasEnumerableObservers'); + Ember.removeListener(this, '@enumerable:before', target, willChange); + Ember.removeListener(this, '@enumerable:change', target, didChange); + if (hasObservers) Ember.propertyDidChange(this, 'hasEnumerableObservers'); + return this; + }, + + /** + Becomes true whenever the array currently has observers watching changes + on the array. + + @property hasEnumerableObservers + @type Boolean + */ + hasEnumerableObservers: Ember.computed(function() { + return Ember.hasListeners(this, '@enumerable:change') || Ember.hasListeners(this, '@enumerable:before'); + }), + + + /** + Invoke this method just before the contents of your enumerable will + change. You can either omit the parameters completely or pass the objects + to be removed or added if available or just a count. + + @method enumerableContentWillChange + @param {Ember.Enumerable|Number} removing An enumerable of the objects to + be removed or the number of items to be removed. + @param {Ember.Enumerable|Number} adding An enumerable of the objects to be + added or the number of items to be added. + @chainable + */ + enumerableContentWillChange: function(removing, adding) { + + var removeCnt, addCnt, hasDelta; + + if ('number' === typeof removing) removeCnt = removing; + else if (removing) removeCnt = get(removing, 'length'); + else removeCnt = removing = -1; + + if ('number' === typeof adding) addCnt = adding; + else if (adding) addCnt = get(adding,'length'); + else addCnt = adding = -1; + + hasDelta = addCnt<0 || removeCnt<0 || addCnt-removeCnt!==0; + + if (removing === -1) removing = null; + if (adding === -1) adding = null; + + Ember.propertyWillChange(this, '[]'); + if (hasDelta) Ember.propertyWillChange(this, 'length'); + Ember.sendEvent(this, '@enumerable:before', [this, removing, adding]); + + return this; + }, + + /** + Invoke this method when the contents of your enumerable has changed. + This will notify any observers watching for content changes. If your are + implementing an ordered enumerable (such as an array), also pass the + start and end values where the content changed so that it can be used to + notify range observers. + + @method enumerableContentDidChange + @param {Number} [start] optional start offset for the content change. + For unordered enumerables, you should always pass -1. + @param {Ember.Enumerable|Number} removing An enumerable of the objects to + be removed or the number of items to be removed. + @param {Ember.Enumerable|Number} adding An enumerable of the objects to + be added or the number of items to be added. + @chainable + */ + enumerableContentDidChange: function(removing, adding) { + var removeCnt, addCnt, hasDelta; + + if ('number' === typeof removing) removeCnt = removing; + else if (removing) removeCnt = get(removing, 'length'); + else removeCnt = removing = -1; + + if ('number' === typeof adding) addCnt = adding; + else if (adding) addCnt = get(adding, 'length'); + else addCnt = adding = -1; + + hasDelta = addCnt<0 || removeCnt<0 || addCnt-removeCnt!==0; + + if (removing === -1) removing = null; + if (adding === -1) adding = null; + + Ember.sendEvent(this, '@enumerable:change', [this, removing, adding]); + if (hasDelta) Ember.propertyDidChange(this, 'length'); + Ember.propertyDidChange(this, '[]'); + + return this ; + }, + + /** + Converts the enumerable into an array and sorts by the keys + specified in the argument. + + You may provide multiple arguments to sort by multiple properties. + + @method sortBy + @param {String} property name(s) to sort on + @return {Array} The sorted array. + */ + sortBy: function() { + var sortKeys = arguments; + return this.toArray().sort(function(a, b){ + for(var i = 0; i < sortKeys.length; i++) { + var key = sortKeys[i], + propA = get(a, key), + propB = get(b, key); + // return 1 or -1 else continue to the next sortKey + var compareValue = Ember.compare(propA, propB); + if (compareValue) { return compareValue; } + } + return 0; + }); + } +}); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + + ### 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. + + ### Chaining + +<<<<<<< HEAD + In addition to property changes, `set()` returns the value of the object + itself so you can do chaining like this: + + ```javascript + record.set('firstName', 'Charles').set('lastName', 'Jolley'); + ``` + + @method set + @param {String} keyName The property to set + @param {Object} value The value to set or `null`. + @return {Ember.Observable} + */ + set: function(keyName, value) { + set(this, keyName, value); + return this; + }, + + /** + To set multiple properties at once, call `setProperties` + with a Hash: + + ```javascript + record.setProperties({ firstName: 'Charles', lastName: 'Jolley' }); + ``` + + @method setProperties + @param {Hash} hash the hash of keys and values to set + @return {Ember.Observable} + */ + setProperties: function(hash) { + return Ember.setProperties(this, hash); + }, + + /** + Begins a grouping of property changes. + + You can use this method to group property changes so that notifications + will not be sent until the changes are finished. If you plan to make a + large number of changes to an object at one time, you should call this + method at the beginning of the changes to begin deferring change + notifications. When you are done making changes, call + `endPropertyChanges()` to deliver the deferred change notifications and end + deferring. + + @method beginPropertyChanges + @return {Ember.Observable} + */ + beginPropertyChanges: function() { + Ember.beginPropertyChanges(); + return this; + }, + + /** + Ends a grouping of property changes. + + You can use this method to group property changes so that notifications + will not be sent until the changes are finished. If you plan to make a + large number of changes to an object at one time, you should call + `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. + + @method endPropertyChanges + @return {Ember.Observable} + */ + endPropertyChanges: function() { + Ember.endPropertyChanges(); + return this; + }, + + /** + Notify the observer system that a property is about to change. + + Sometimes you need to change a value directly or indirectly without + actually calling `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. + + @method propertyWillChange + @param {String} keyName The property key that is about to change. + @return {Ember.Observable} + */ + propertyWillChange: function(keyName) { + Ember.propertyWillChange(this, keyName); + return this; + }, + + /** + Notify the observer system that a property has just changed. + + Sometimes you need to change a value directly or indirectly without + actually calling `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. + + @method propertyDidChange + @param {String} keyName The property key that has just changed. + @return {Ember.Observable} + */ + propertyDidChange: function(keyName) { + Ember.propertyDidChange(this, keyName); + return this; + }, + + /** + Convenience method to call `propertyWillChange` and `propertyDidChange` in + succession. + + @method notifyPropertyChange + @param {String} keyName The property key to be notified about. + @return {Ember.Observable} + */ + notifyPropertyChange: function(keyName) { + this.propertyWillChange(keyName); + this.propertyDidChange(keyName); + return this; + }, + + addBeforeObserver: function(key, target, method) { + Ember.addBeforeObserver(this, key, target, method); +======= +var get = Ember.get, set = Ember.set, isNone = Ember.isNone, map = Ember.EnumerableUtils.map, cacheFor = Ember.cacheFor; + +// .......................................................... +// ARRAY +// +/** + This module implements Observer-friendly Array-like behavior. This mixin is + picked up by the Array class as well as other controllers, etc. that want to + appear to be arrays. + + Unlike `Ember.Enumerable,` this mixin defines methods specifically for + collections that provide index-ordered access to their contents. When you + are designing code that needs to accept any kind of Array-like object, you + should use these methods instead of Array primitives because these will + properly notify observers of changes to the array. + + Although these methods are efficient, they do add a layer of indirection to + your application so it is a good idea to use them only when you need the + flexibility of using both true JavaScript arrays and "virtual" arrays such + as controllers and collections. + + You can use the methods defined in this module to access and modify array + contents in a KVO-friendly way. You can also be notified whenever the + membership of an array changes by changing the syntax of the property to + `.observes('*myProperty.[]')`. + + To support `Ember.Array` in your own class, you must override two + primitives to use it: `replace()` and `objectAt()`. + + Note that the Ember.Array mixin also incorporates the `Ember.Enumerable` + mixin. All `Ember.Array`-like objects are also enumerable. + + @class Array + @namespace Ember + @uses Ember.Enumerable + @since Ember 0.9.0 +*/ +Ember.Array = Ember.Mixin.create(Ember.Enumerable, { + + /** + Your array must support the `length` property. Your replace methods should + set this property whenever it changes. + + @property {Number} length + */ + length: Ember.required(), + + /** + Returns the object at the given `index`. If the given `index` is negative + or is greater or equal than the array length, returns `undefined`. + + This is one of the primitives you must implement to support `Ember.Array`. + If your object supports retrieving the value of an array item using `get()` + (i.e. `myArray.get(0)`), then you do not need to implement this method + yourself. + + ```javascript + var arr = ['a', 'b', 'c', 'd']; + arr.objectAt(0); // "a" + arr.objectAt(3); // "d" + arr.objectAt(-1); // undefined + arr.objectAt(4); // undefined + arr.objectAt(5); // undefined + ``` + + @method objectAt + @param {Number} idx The index of the item to return. + @return {*} item at index or undefined + */ + objectAt: function(idx) { + if ((idx < 0) || (idx>=get(this, 'length'))) return undefined ; + return get(this, idx); + }, + + /** + This returns the objects at the specified indexes, using `objectAt`. + + ```javascript + var arr =Â ['a', 'b', 'c', 'd']; + arr.objectsAt([0, 1, 2]); // ["a", "b", "c"] + arr.objectsAt([2, 3, 4]); // ["c", "d", undefined] + ``` + + @method objectsAt + @param {Array} indexes An array of indexes of items to return. + @return {Array} + */ + objectsAt: function(indexes) { + var self = this; + return map(indexes, function(idx) { return self.objectAt(idx); }); + }, + + // overrides Ember.Enumerable version + nextObject: function(idx) { + return this.objectAt(idx); + }, + + /** + This is the handler for the special array content property. If you get + this property, it will return this. If you set this property it a new + array, it will replace the current content. + + This property overrides the default property defined in `Ember.Enumerable`. + + @property [] + @return this + */ + '[]': Ember.computed(function(key, value) { + if (value !== undefined) this.replace(0, get(this, 'length'), value) ; + return this ; + }), + + firstObject: Ember.computed(function() { + return this.objectAt(0); + }), + + lastObject: Ember.computed(function() { + return this.objectAt(get(this, 'length')-1); + }), + + // optimized version from Enumerable + contains: function(obj) { + return this.indexOf(obj) >= 0; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + }, + + // Add any extra methods to Ember.Array that are native to the built-in Array. + /** +<<<<<<< HEAD + Adds an observer on a property. + + This is the core method used to register an observer for a property. + + Once you call this method, any time the key's value is set, your observer + will be notified. Note that the observers are triggered any time the + value is set, regardless of whether it has actually changed. Your + observer should be prepared to handle that. + + You can also pass an optional context parameter to this method. The + context will be passed to your observer method whenever it is triggered. + Note that if you add the same target/method pair on a key multiple times + with different context parameters, your observer will only be called once + with the last context you passed. + + ### Observer Methods + + Observer methods you pass should generally have the following signature if + you do not pass a `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. + + @method addObserver + @param {String} key The key to observer + @param {Object} target The target object to invoke + @param {String|Function} method The method to invoke. + @return {Ember.Object} self + */ + addObserver: function(key, target, method) { + Ember.addObserver(this, key, target, method); + }, + + /** + Remove an observer you have previously registered on this object. Pass + the same key, target, and method you passed to `addObserver()` and your + target will no longer receive notifications. + + @method removeObserver + @param {String} key The key to observer + @param {Object} target The target object to invoke + @param {String|Function} method The method to invoke. + @return {Ember.Observable} receiver + */ + removeObserver: function(key, target, method) { + Ember.removeObserver(this, key, target, method); + }, + + /** + Returns `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. + + @method hasObserverFor + @param {String} key Key to check + @return {Boolean} + */ + hasObserverFor: function(key) { + return Ember.hasListeners(this, key+':change'); + }, + + /** + Retrieves the value of a property, or a default value in the case that the + property returns `undefined`. + + ```javascript + person.getWithDefault('lastName', 'Doe'); + ``` + + @method getWithDefault + @param {String} keyName The name of the property to retrieve + @param {Object} defaultValue The value to return if the property value is undefined + @return {Object} The property value or the defaultValue. + */ + getWithDefault: function(keyName, defaultValue) { + return Ember.getWithDefault(this, keyName, defaultValue); + }, + + /** + Set the value of a property to the current value plus some amount. + + ```javascript + person.incrementProperty('age'); + team.incrementProperty('score', 2); + ``` + + @method incrementProperty + @param {String} keyName The name of the property to increment + @param {Number} increment The amount to increment by. Defaults to 1 + @return {Number} The new property value + */ + incrementProperty: function(keyName, increment) { + if (Ember.isNone(increment)) { increment = 1; } + Ember.assert("Must pass a numeric value to incrementProperty", (!isNaN(parseFloat(increment)) && isFinite(increment))); + set(this, keyName, (get(this, keyName) || 0) + increment); + return get(this, keyName); + }, + + /** + Set the value of a property to the current value minus some amount. + + ```javascript + player.decrementProperty('lives'); + orc.decrementProperty('health', 5); + ``` + + @method decrementProperty + @param {String} keyName The name of the property to decrement + @param {Number} decrement The amount to decrement by. Defaults to 1 + @return {Number} The new property value + */ + decrementProperty: function(keyName, decrement) { + if (Ember.isNone(decrement)) { decrement = 1; } + Ember.assert("Must pass a numeric value to decrementProperty", (!isNaN(parseFloat(decrement)) && isFinite(decrement))); + set(this, keyName, (get(this, keyName) || 0) - decrement); + return get(this, keyName); + }, + + /** + Set the value of a boolean property to the opposite of it's + current value. + + ```javascript + starship.toggleProperty('warpDriveEngaged'); + ``` + + @method toggleProperty + @param {String} keyName The name of the property to toggle + @return {Object} The new property value + */ + toggleProperty: function(keyName) { + set(this, keyName, !get(this, keyName)); + return get(this, keyName); + }, + + /** + Returns the cached value of a computed property, if it exists. + This allows you to inspect the value of a computed property + without accidentally invoking it if it is intended to be + generated lazily. + + @method cacheFor + @param {String} keyName + @return {Object} The cached value of the computed property, if any + */ + cacheFor: function(keyName) { + return Ember.cacheFor(this, keyName); + }, + + // intended for debugging purposes + observersForKey: function(keyName) { + return Ember.observersFor(this, keyName); + } +}); + +})(); + + + (function() { /** @module ember @@ -10763,8 +15857,467 @@ CoreObject.PrototypeMixin = Mixin.create({ init: function() { alert('Name is ' + this.get('name')); } +======= + Returns a new array that is a slice of the receiver. This implementation + uses the observable array methods to retrieve the objects for the new + slice. + + ```javascript + var arr = ['red', 'green', 'blue']; + arr.slice(0); // ['red', 'green', 'blue'] + arr.slice(0, 2); // ['red', 'green'] + arr.slice(1, 100); // ['green', 'blue'] + ``` + + @method slice + @param {Integer} beginIndex (Optional) index to begin slicing from. + @param {Integer} endIndex (Optional) index to end the slice at. + @return {Array} New array with specified slice + */ + slice: function(beginIndex, endIndex) { + var ret = Ember.A(); + var length = get(this, 'length') ; + if (isNone(beginIndex)) beginIndex = 0 ; + if (isNone(endIndex) || (endIndex > length)) endIndex = length ; + + if (beginIndex < 0) beginIndex = length + beginIndex; + if (endIndex < 0) endIndex = length + endIndex; + + while(beginIndex < endIndex) { + ret[ret.length] = this.objectAt(beginIndex++) ; + } + return ret ; + }, + + /** + Returns the index of the given object's first occurrence. + If no `startAt` argument is given, the starting location to + search is 0. If it's negative, will count backward from + the end of the array. Returns -1 if no match is found. + + ```javascript + var arr = ["a", "b", "c", "d", "a"]; + arr.indexOf("a"); // 0 + arr.indexOf("z"); // -1 + arr.indexOf("a", 2); // 4 + arr.indexOf("a", -1); // 4 + arr.indexOf("b", 3); // -1 + arr.indexOf("a", 100); // -1 + ``` + + @method indexOf + @param {Object} object the item to search for + @param {Number} startAt optional starting location to search, default 0 + @return {Number} index or -1 if not found + */ + indexOf: function(object, startAt) { + var idx, len = get(this, 'length'); + + if (startAt === undefined) startAt = 0; + if (startAt < 0) startAt += len; + + for(idx=startAt;idx + }); + ``` + + @property promise + */ + promise: Ember.computed(function(key, promise) { + if (arguments.length === 2) { + promise = resolve(promise); + observePromise(this, promise); + return promise.then(); // fork the promise. + } else { + throw new Ember.Error("PromiseProxy's promise must be set"); + } + }), + + /** + An alias to the proxied promise's `then`. + + See RSVP.Promise.then. + + @method then + @param {Function} callback + @return {RSVP.Promise} + */ + then: promiseAlias('then'), + + /** + An alias to the proxied promise's `catch`. + + See RSVP.Promise.catch. + + @method catch + @param {Function} callback + @return {RSVP.Promise} + */ + 'catch': promiseAlias('catch'), + + /** + An alias to the proxied promise's `finally`. + + See RSVP.Promise.finally. + + @method finally + @param {Function} callback + @return {RSVP.Promise} + */ + 'finally': promiseAlias('finally') + +}); + +function promiseAlias(name) { + return function () { + var promise = get(this, 'promise'); + return promise[name].apply(promise, arguments); + }; +} + +})(); + + + +(function() { + +})(); + + + +(function() { +var get = Ember.get, + forEach = Ember.EnumerableUtils.forEach, + RETAIN = 'r', + INSERT = 'i', + DELETE = 'd'; + +/** + An `Ember.TrackedArray` tracks array operations. It's useful when you want to + lazily compute the indexes of items in an array after they've been shifted by + subsequent operations. + + @class TrackedArray + @namespace Ember + @param {array} [items=[]] The array to be tracked. This is used just to get + the initial items for the starting state of retain:n. +*/ +Ember.TrackedArray = function (items) { + if (arguments.length < 1) { items = []; } + + var length = get(items, 'length'); + + if (length) { + this._operations = [new ArrayOperation(RETAIN, length, items)]; + } else { + this._operations = []; + } +}; + +Ember.TrackedArray.RETAIN = RETAIN; +Ember.TrackedArray.INSERT = INSERT; +Ember.TrackedArray.DELETE = DELETE; + +Ember.TrackedArray.prototype = { + + /** + Track that `newItems` were added to the tracked array at `index`. + + @method addItems + @param index + @param newItems + */ + addItems: function (index, newItems) { + var count = get(newItems, 'length'); + if (count < 1) { return; } + + var match = this._findArrayOperation(index), + arrayOperation = match.operation, + arrayOperationIndex = match.index, + arrayOperationRangeStart = match.rangeStart, + composeIndex, + splitIndex, + splitItems, + splitArrayOperation, + newArrayOperation; + + newArrayOperation = new ArrayOperation(INSERT, count, newItems); + + if (arrayOperation) { + if (!match.split) { + // insert left of arrayOperation + this._operations.splice(arrayOperationIndex, 0, newArrayOperation); + composeIndex = arrayOperationIndex; + } else { + this._split(arrayOperationIndex, index - arrayOperationRangeStart, newArrayOperation); + composeIndex = arrayOperationIndex + 1; + } + } else { + // insert at end + this._operations.push(newArrayOperation); + composeIndex = arrayOperationIndex; + } + + this._composeInsert(composeIndex); + }, + + /** + Track that `count` items were removed at `index`. + + @method removeItems + @param index + @param count + */ + removeItems: function (index, count) { + if (count < 1) { return; } + + var match = this._findArrayOperation(index), + arrayOperation = match.operation, + arrayOperationIndex = match.index, + arrayOperationRangeStart = match.rangeStart, + newArrayOperation, + composeIndex; + + newArrayOperation = new ArrayOperation(DELETE, count); + if (!match.split) { + // insert left of arrayOperation + this._operations.splice(arrayOperationIndex, 0, newArrayOperation); + composeIndex = arrayOperationIndex; + } else { + this._split(arrayOperationIndex, index - arrayOperationRangeStart, newArrayOperation); + composeIndex = arrayOperationIndex + 1; + } + + return this._composeDelete(composeIndex); + }, + + /** + Apply all operations, reducing them to retain:n, for `n`, the number of + items in the array. + + `callback` will be called for each operation and will be passed the following arguments: + + * {array} items The items for the given operation + * {number} offset The computed offset of the items, ie the index in the + array of the first item for this operation. + * {string} operation The type of the operation. One of + `Ember.TrackedArray.{RETAIN, DELETE, INSERT}` + + @method apply + @param {function} callback + */ + apply: function (callback) { + var items = [], + offset = 0; + + forEach(this._operations, function (arrayOperation) { + callback(arrayOperation.items, offset, arrayOperation.type); + + if (arrayOperation.type !== DELETE) { + offset += arrayOperation.count; + items = items.concat(arrayOperation.items); + } + }); + + this._operations = [new ArrayOperation(RETAIN, items.length, items)]; + }, + + /** + Return an `ArrayOperationMatch` for the operation that contains the item at `index`. + + @method _findArrayOperation + + @param {number} index the index of the item whose operation information + should be returned. + @private + */ + _findArrayOperation: function (index) { + var arrayOperationIndex, + len, + split = false, + arrayOperation, + arrayOperationRangeStart, + arrayOperationRangeEnd; + + // OPTIMIZE: we could search these faster if we kept a balanced tree. + // find leftmost arrayOperation to the right of `index` + for (arrayOperationIndex = arrayOperationRangeStart = 0, len = this._operations.length; arrayOperationIndex < len; ++arrayOperationIndex) { + arrayOperation = this._operations[arrayOperationIndex]; + + if (arrayOperation.type === DELETE) { continue; } + + arrayOperationRangeEnd = arrayOperationRangeStart + arrayOperation.count - 1; + + if (index === arrayOperationRangeStart) { + break; + } else if (index > arrayOperationRangeStart && index <= arrayOperationRangeEnd) { + split = true; + break; + } else { + arrayOperationRangeStart = arrayOperationRangeEnd + 1; + } + } + + return new ArrayOperationMatch(arrayOperation, arrayOperationIndex, split, arrayOperationRangeStart); + }, + + _split: function (arrayOperationIndex, splitIndex, newArrayOperation) { + var arrayOperation = this._operations[arrayOperationIndex], + splitItems = arrayOperation.items.slice(splitIndex), + splitArrayOperation = new ArrayOperation(arrayOperation.type, splitItems.length, splitItems); + + // truncate LHS + arrayOperation.count = splitIndex; + arrayOperation.items = arrayOperation.items.slice(0, splitIndex); + + this._operations.splice(arrayOperationIndex + 1, 0, newArrayOperation, splitArrayOperation); + }, + + // see SubArray for a better implementation. + _composeInsert: function (index) { + var newArrayOperation = this._operations[index], + leftArrayOperation = this._operations[index-1], // may be undefined + rightArrayOperation = this._operations[index+1], // may be undefined + leftOp = leftArrayOperation && leftArrayOperation.type, + rightOp = rightArrayOperation && rightArrayOperation.type; + + if (leftOp === INSERT) { + // merge left + leftArrayOperation.count += newArrayOperation.count; + leftArrayOperation.items = leftArrayOperation.items.concat(newArrayOperation.items); + + if (rightOp === INSERT) { + // also merge right (we have split an insert with an insert) + leftArrayOperation.count += rightArrayOperation.count; + leftArrayOperation.items = leftArrayOperation.items.concat(rightArrayOperation.items); + this._operations.splice(index, 2); + } else { + // only merge left + this._operations.splice(index, 1); + } + } else if (rightOp === INSERT) { + // merge right + newArrayOperation.count += rightArrayOperation.count; + newArrayOperation.items = newArrayOperation.items.concat(rightArrayOperation.items); + this._operations.splice(index + 1, 1); + } + }, + + _composeDelete: function (index) { + var arrayOperation = this._operations[index], + deletesToGo = arrayOperation.count, + leftArrayOperation = this._operations[index-1], // may be undefined + leftOp = leftArrayOperation && leftArrayOperation.type, + nextArrayOperation, + nextOp, + nextCount, + removeNewAndNextOp = false, + removedItems = []; + + if (leftOp === DELETE) { + arrayOperation = leftArrayOperation; + index -= 1; + } + + for (var i = index + 1; deletesToGo > 0; ++i) { + nextArrayOperation = this._operations[i]; + nextOp = nextArrayOperation.type; + nextCount = nextArrayOperation.count; + + if (nextOp === DELETE) { + arrayOperation.count += nextCount; + continue; + } + + if (nextCount > deletesToGo) { + // d:2 {r,i}:5 we reduce the retain or insert, but it stays + removedItems = removedItems.concat(nextArrayOperation.items.splice(0, deletesToGo)); + nextArrayOperation.count -= deletesToGo; + + // In the case where we truncate the last arrayOperation, we don't need to + // remove it; also the deletesToGo reduction is not the entirety of + // nextCount + i -= 1; + nextCount = deletesToGo; + + deletesToGo = 0; + } else { + if (nextCount === deletesToGo) { + // Handle edge case of d:2 i:2 in which case both operations go away + // during composition. + removeNewAndNextOp = true; + } + removedItems = removedItems.concat(nextArrayOperation.items); + deletesToGo -= nextCount; + } + + if (nextOp === INSERT) { + // d:2 i:3 will result in delete going away + arrayOperation.count -= nextCount; + } + } + + if (arrayOperation.count > 0) { + // compose our new delete with possibly several operations to the right of + // disparate types + this._operations.splice(index+1, i-1-index); + } else { + // The delete operation can go away; it has merely reduced some other + // operation, as in d:3 i:4; it may also have eliminated that operation, + // as in d:3 i:3. + this._operations.splice(index, removeNewAndNextOp ? 2 : 1); + } + + return removedItems; + }, + + toString: function () { + var str = ""; + forEach(this._operations, function (operation) { + str += " " + operation.type + ":" + operation.count; + }); + return str.substring(1); + } +}; + +/** + Internal data structure to represent an array operation. + + @method ArrayOperation + @private + @param {string} type The type of the operation. One of + `Ember.TrackedArray.{RETAIN, INSERT, DELETE}` + @param {number} count The number of items in this operation. + @param {array} items The items of the operation, if included. RETAIN and + INSERT include their items, DELETE does not. +*/ +function ArrayOperation (operation, count, items) { + this.type = operation; // RETAIN | INSERT | DELETE + this.count = count; + this.items = items; +} + +/** + Internal data structure used to include information when looking up operations + by item index. + + @method ArrayOperationMatch + @private + @param {ArrayOperation} operation + @param {number} index The index of `operation` in the array of operations. + @param {boolean} split Whether or not the item index searched for would + require a split for a new operation type. + @param {number} rangeStart The index of the first item in the operation, + with respect to the tracked array. The index of the last item can be computed + from `rangeStart` and `operation.count`. +*/ +function ArrayOperationMatch(operation, index, split, rangeStart) { + this.operation = operation; + this.index = index; + this.split = split; + this.rangeStart = rangeStart; +} + +})(); + + + +(function() { +var get = Ember.get, + forEach = Ember.EnumerableUtils.forEach, + RETAIN = 'r', + FILTER = 'f'; + +function Operation (type, count) { + this.type = type; + this.count = count; +} + +/** + An `Ember.SubArray` tracks an array in a way similar to, but more specialized + than, `Ember.TrackedArray`. It is useful for keeping track of the indexes of + items within a filtered array. + + @class SubArray + @namespace Ember +*/ +Ember.SubArray = function (length) { + if (arguments.length < 1) { length = 0; } + + if (length > 0) { + this._operations = [new Operation(RETAIN, length)]; + } else { + this._operations = []; + } +}; + +Ember.SubArray.prototype = { + /** + Track that an item was added to the tracked array. + + @method addItem + + @param {number} index The index of the item in the tracked array. + @param {boolean} match `true` iff the item is included in the subarray. + + @return {number} The index of the item in the subarray. + */ + addItem: function(index, match) { + var returnValue = -1, + itemType = match ? RETAIN : FILTER, + self = this; + + this._findOperation(index, function(operation, operationIndex, rangeStart, rangeEnd, seenInSubArray) { + var newOperation, splitOperation; + + if (itemType === operation.type) { + ++operation.count; + } else if (index === rangeStart) { + // insert to the left of `operation` + self._operations.splice(operationIndex, 0, new Operation(itemType, 1)); + } else { + newOperation = new Operation(itemType, 1); + splitOperation = new Operation(operation.type, rangeEnd - index + 1); + operation.count = index - rangeStart; + + self._operations.splice(operationIndex + 1, 0, newOperation, splitOperation); + } + + if (match) { + if (operation.type === RETAIN) { + returnValue = seenInSubArray + (index - rangeStart); + } else { + returnValue = seenInSubArray; + } + } + + self._composeAt(operationIndex); + }, function(seenInSubArray) { + self._operations.push(new Operation(itemType, 1)); + + if (match) { + returnValue = seenInSubArray; + } + + self._composeAt(self._operations.length-1); + }); + + return returnValue; + }, + + /** + Track that an item was removed from the tracked array. + + @method removeItem + + @param {number} index The index of the item in the tracked array. + + @return {number} The index of the item in the subarray, or `-1` if the item + was not in the subarray. + */ + removeItem: function(index) { + var returnValue = -1, + self = this; + + this._findOperation(index, function (operation, operationIndex, rangeStart, rangeEnd, seenInSubArray) { + if (operation.type === RETAIN) { + returnValue = seenInSubArray + (index - rangeStart); + } + + if (operation.count > 1) { + --operation.count; + } else { + self._operations.splice(operationIndex, 1); + self._composeAt(operationIndex); + } + }, function() { + throw new Ember.Error("Can't remove an item that has never been added."); + }); + + return returnValue; + }, + + + _findOperation: function (index, foundCallback, notFoundCallback) { + var operationIndex, + len, + operation, + rangeStart, + rangeEnd, + seenInSubArray = 0; + + // OPTIMIZE: change to balanced tree + // find leftmost operation to the right of `index` + for (operationIndex = rangeStart = 0, len = this._operations.length; operationIndex < len; rangeStart = rangeEnd + 1, ++operationIndex) { + operation = this._operations[operationIndex]; + rangeEnd = rangeStart + operation.count - 1; + + if (index >= rangeStart && index <= rangeEnd) { + foundCallback(operation, operationIndex, rangeStart, rangeEnd, seenInSubArray); + return; + } else if (operation.type === RETAIN) { + seenInSubArray += operation.count; + } + } + + notFoundCallback(seenInSubArray); + }, + + _composeAt: function(index) { + var op = this._operations[index], + otherOp; + + if (!op) { + // Composing out of bounds is a no-op, as when removing the last operation + // in the list. + return; + } + + if (index > 0) { + otherOp = this._operations[index-1]; + if (otherOp.type === op.type) { + op.count += otherOp.count; + this._operations.splice(index-1, 1); + --index; + } + } + + if (index < this._operations.length-1) { + otherOp = this._operations[index+1]; + if (otherOp.type === op.type) { + op.count += otherOp.count; + this._operations.splice(index+1, 1); + } + } + }, + + toString: function () { + var str = ""; + forEach(this._operations, function (operation) { + str += " " + operation.type + ":" + operation.count; + }); + return str.substring(1); + } +}; + +})(); + + + +(function() { +Ember.Container = requireModule('container'); +Ember.Container.set = Ember.set; + +})(); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 var cp = new ArrayComputedProperty(options); @@ -14184,9 +23130,17 @@ Ember.computed.max = function (dependentKey) { @param {String} dependentKey @return {Ember.ComputedProperty} computes the smallest value in the dependentKey's array */ +<<<<<<< HEAD Ember.computed.min = function (dependentKey) { return Ember.reduceComputed.call(null, dependentKey, { initialValue: Infinity, +======= +Ember.ArrayProxy = Ember.Object.extend(Ember.MutableArray, { + + /** + The content array. Must be an object that implements `Ember.Array` and/or + `Ember.MutableArray.` +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 addedItem: function (accumulatedValue, item, changeMeta, instanceMeta) { return Math.min(accumulatedValue, item); @@ -14224,6 +23178,7 @@ Ember.computed.min = function (dependentKey) { hamster.get('excitingChores'); // ['COOK!', 'CLEAN!', 'WRITE MORE UNIT TESTS!'] ``` +<<<<<<< HEAD @method computed.map @for Ember @param {String} dependentKey @@ -14248,6 +23203,18 @@ Ember.computed.map = function(dependentKey, callback) { /** Returns an array mapped to the specified key. +======= + /** + Invoked when the content property is about to change. Notifies observers that the + entire array content will change. + + @private + @method _contentWillChange + */ + _contentWillChange: Ember.beforeObserver('content', function() { + this._teardownContent(); + }), +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 Example @@ -14264,6 +23231,7 @@ Ember.computed.map = function(dependentKey, callback) { lordByron.get('childAges'); // [7, 5, 8] ``` +<<<<<<< HEAD @method computed.mapBy @for Ember @param {String} dependentKey @@ -14286,23 +23254,45 @@ Ember.computed.mapProperty = Ember.computed.mapBy; /** Filters the array by the callback. +======= + /** + Invoked when the content property changes. Notifies observers that the + entire array content has changed. + + @private + @method _contentDidChange + */ + _contentDidChange: Ember.observer('content', function() { + var content = get(this, 'content'); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 The callback method you provide should have the following signature: +<<<<<<< HEAD ```javascript function(item); ``` +======= + this._setupContent(); + }), +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 - `item` is the current item in the iteration. Example +<<<<<<< HEAD ```javascript App.Hamster = Ember.Object.extend({ remainingChores: Ember.computed.filter('chores', function(chore) { return !chore.done; }) }); +======= + _arrangedContentWillChange: Ember.beforeObserver('arrangedContent', function() { + var arrangedContent = get(this, 'arrangedContent'), + len = arrangedContent ? get(arrangedContent, 'length') : 0; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 var hamster = App.Hamster.create({chores: [ {name: 'cook', done: true}, @@ -14312,6 +23302,7 @@ Ember.computed.mapProperty = Ember.computed.mapBy; hamster.get('remainingChores'); // [{name: 'write more unit tests', done: false}] ``` +<<<<<<< HEAD @method computed.filter @for Ember @param {String} dependentKey @@ -14327,6 +23318,14 @@ Ember.computed.filter = function(dependentKey, callback) { addedItem: function(array, item, changeMeta, instanceMeta) { var match = !!callback.call(this, item), filterIndex = instanceMeta.filteredArrayIndexes.addItem(changeMeta.index, match); +======= + this._teardownArrangedContent(arrangedContent); + }), + + _arrangedContentDidChange: Ember.observer('arrangedContent', function() { + var arrangedContent = get(this, 'arrangedContent'), + len = arrangedContent ? get(arrangedContent, 'length') : 0; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 if (match) { array.insertAt(filterIndex, item); @@ -14335,8 +23334,14 @@ Ember.computed.filter = function(dependentKey, callback) { return array; }, +<<<<<<< HEAD removedItem: function(array, item, changeMeta, instanceMeta) { var filterIndex = instanceMeta.filteredArrayIndexes.removeItem(changeMeta.index); +======= + this.arrangedContentDidChange(this); + this.arrangedContentArrayDidChange(this, 0, undefined, len); + }), +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 if (filterIndex > -1) { array.removeAt(filterIndex); @@ -14387,8 +23392,16 @@ Ember.computed.filterBy = function(dependentKey, propertyKey, value) { }; } +<<<<<<< HEAD return Ember.computed.filter(dependentKey + '.@each.' + propertyKey, callback); }; +======= + _insertAt: function(idx, object) { + if (idx > get(this, 'content.length')) throw new Ember.Error(OUT_OF_RANGE_EXCEPTION); + this._replace(idx, 0, [object]); + return this; + }, +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 /** @method computed.filterProperty @@ -14404,7 +23417,13 @@ Ember.computed.filterProperty = Ember.computed.filterBy; A computed property which returns a new array with all the unique elements from one or more dependent arrays. +<<<<<<< HEAD Example +======= + if ((start < 0) || (start >= get(this, 'length'))) { + throw new Ember.Error(OUT_OF_RANGE_EXCEPTION); + } +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 ```javascript App.Hamster = Ember.Object.extend({ @@ -14627,6 +23646,7 @@ function binarySearch(array, item, low, high) { return mid; } +<<<<<<< HEAD res = this.order(midItem, item); if (res === 0) { res = guidMid < guidItem ? -1 : 1; @@ -14792,6 +23812,21 @@ Ember.computed.sort = function (itemsKey, sortDefinition) { if (changeMeta.previousValues) { proxyProperties = merge({ content: item }, changeMeta.previousValues); +======= + +var set = Ember.set, get = Ember.get, guidFor = Ember.guidFor; +var forEach = Ember.EnumerableUtils.forEach, + indexOf = Ember.ArrayPolyfills.indexOf; + +var EachArray = Ember.Object.extend(Ember.Array, { + + init: function(content, keyName, owner) { + this._super(); + this._keyName = keyName; + this._owner = owner; + this._content = content; + }, +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 searchItem = SearchProxy.create(proxyProperties); } else { @@ -14824,6 +23859,15 @@ Ember.RSVP = requireModule('rsvp'); })(); +<<<<<<< HEAD +======= + guid = guidFor(item); + indicies = objects[guid]; + indicies[indexOf.call(indicies, loc)] = null; + } + } +} +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 (function() { /** @@ -14964,10 +24008,21 @@ if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.Function) { return this.observes.apply(this, arguments); }; +<<<<<<< HEAD /** The `observesBefore` extension of Javascript's Function prototype is available when `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Function` is true, which is the default. +======= +(function() { +/** +@module ember +@submodule ember-runtime +*/ + + +var get = Ember.get, set = Ember.set, replace = Ember.EnumerableUtils._replace; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 You can get notified when a property change is about to happen by by adding the `observesBefore` call to the end of your method @@ -14991,14 +24046,19 @@ if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.Function) { return this; }; +<<<<<<< HEAD /** The `on` extension of Javascript's Function prototype is available when `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Function` is true, which is the default. +======= + if (this.isFrozen) throw Ember.FROZEN_ERROR; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 You can listen for events simply by adding the `on` call to the end of your method declarations in classes or mixins that you write. For example: +<<<<<<< HEAD ```javascript Ember.Mixin.create({ doSomethingWithElement: function() { @@ -15008,6 +24068,17 @@ if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.Function) { ``` See `Ember.on`. +======= + if (len === 0) { + this.splice(idx, amt); + } else { + replace(this, idx, amt, objects); + } + + this.arrayContentDidChange(idx, amt, len); + return this; + }, +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 @method on @for Function @@ -15047,15 +24118,58 @@ if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.Function) { @namespace Ember @since Ember 0.9 */ +<<<<<<< HEAD Ember.Comparable = Ember.Mixin.create( /** @scope Ember.Comparable.prototype */{ +======= +Ember.NativeArray = NativeArray; + +/** + Creates an `Ember.NativeArray` from an Array like object. + Does not modify the original object. Ember.A is not needed if + `Ember.EXTEND_PROTOTYPES` is `true` (the default value). However, + it is recommended that you use Ember.A when creating addons for + ember or when you can not guarantee that `Ember.EXTEND_PROTOTYPES` + will be `true`. + + Example + + ```js + var Pagination = Ember.CollectionView.extend({ + tagName: 'ul', + classNames: ['pagination'], + init: function() { + this._super(); + if (!this.get('content')) { + this.set('content', Ember.A([])); + } + } + }); + ``` +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 /** Override to return the result of the comparison of the two parameters. The compare method should return: +<<<<<<< HEAD - `-1` if `a < b` - `0` if `a == b` - `1` if `a > b` +======= +/** + Activates the mixin on the Array.prototype if not already applied. Calling + this method more than once is safe. This will be called when ember is loaded + unless you have `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Array` + set to `false`. + + Example + + ```js + if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.Array) { + Ember.NativeArray.activate(); + } + ``` +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 Default implementation raises an exception. @@ -15153,10 +24267,18 @@ var get = Ember.get, set = Ember.set; ## Enforcement +<<<<<<< HEAD To fully support freezing in your subclass, you must include this mixin and override any method that might alter any property on the object to instead raise an exception. You can check the state of an object by checking the `isFrozen` property. +======= + When using `Ember.Set`, you can observe the `"[]"` property to be + alerted whenever the content changes. You can also add an enumerable + observer to the set to be notified of specific objects that are added and + removed from the set. See [Ember.Enumerable](/api/classes/Ember.Enumerable.html) + for more information on enumerables. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 Although future versions of JavaScript may support language-level freezing object objects, that is not the case today. Even if an object is freezable, @@ -15202,7 +24324,16 @@ var get = Ember.get, set = Ember.set; @namespace Ember @since Ember 0.9 */ +<<<<<<< HEAD Ember.Freezable = Ember.Mixin.create(/** @scope Ember.Freezable.prototype */ { +======= +Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Ember.Freezable, + { + + // .......................................................... + // IMPLEMENT ENUMERABLE APIS + // +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 /** Set to `true` when the object is frozen. Use this property to detect @@ -15220,11 +24351,16 @@ Ember.Freezable = Ember.Mixin.create(/** @scope Ember.Freezable.prototype */ { @method freeze @return {Object} receiver */ +<<<<<<< HEAD freeze: function() { if (get(this, 'isFrozen')) return this; set(this, 'isFrozen', true); return this; } +======= + clear: function() { + if (this.isFrozen) { throw new Ember.Error(Ember.FROZEN_ERROR); } +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 }); @@ -15306,11 +24442,19 @@ Ember.MutableEnumerable = Ember.Mixin.create(Ember.Enumerable, { @param {Ember.Enumerable} objects the objects to add. @return {Object} receiver */ +<<<<<<< HEAD addObjects: function(objects) { Ember.beginPropertyChanges(this); forEach(objects, function(obj) { this.addObject(obj); }, this); Ember.endPropertyChanges(this); return this; +======= + pop: function() { + if (get(this, 'isFrozen')) throw new Ember.Error(Ember.FROZEN_ERROR); + var obj = this.length > 0 ? this[this.length-1] : null; + this.remove(obj); + return obj; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 }, /** @@ -15486,6 +24630,7 @@ Ember.MutableArray = Ember.Mixin.create(Ember.Array, Ember.MutableEnumerable,/** colors.pushObject(["yellow", "orange"]); // ["red", "green", "blue", "black", ["yellow", "orange"]] ``` +<<<<<<< HEAD @method pushObject @param {*} obj object to push @return {*} the same obj passed as param @@ -15494,6 +24639,12 @@ Ember.MutableArray = Ember.Mixin.create(Ember.Array, Ember.MutableEnumerable,/** this.insertAt(get(this, 'length'), obj) ; return obj ; }, +======= + // implements Ember.MutableEnumerable + addObject: function(obj) { + if (get(this, 'isFrozen')) throw new Ember.Error(Ember.FROZEN_ERROR); + if (isNone(obj)) return this; // nothing to do +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 /** Add the objects in the passed numerable to the end of the array. Defers @@ -15539,9 +24690,16 @@ Ember.MutableArray = Ember.Mixin.create(Ember.Array, Ember.MutableEnumerable,/** return ret ; }, +<<<<<<< HEAD /** Shift an object from start of array or nil if none are left. Works just like `shift()` but it is KVO-compliant. +======= + // implements Ember.MutableEnumerable + removeObject: function(obj) { + if (get(this, 'isFrozen')) throw new Ember.Error(Ember.FROZEN_ERROR); + if (isNone(obj)) return this; // nothing to do +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 ```javascript var colors = ["red", "green", "blue"]; @@ -15661,25 +24819,61 @@ Ember.MutableArray = Ember.Mixin.create(Ember.Array, Ember.MutableEnumerable,/** (function() { /** -@module ember -@submodule ember-runtime + @module ember + @submodule ember-runtime */ var get = Ember.get, set = Ember.set; /** +<<<<<<< HEAD `Ember.TargetActionSupport` is a mixin that can be included in a class to add a `triggerAction` method with semantics similar to the Handlebars `{{action}}` helper. In normal Ember usage, the `{{action}}` helper is usually the best choice. This mixin is most often useful when you are doing more complex event handling in View objects. +======= + Detects when a specific package of Ember (e.g. 'Ember.Handlebars') + has fully loaded and is available for extension. + + The provided `callback` will be called with the `name` passed + resolved from a string into the object: + + ``` javascript + Ember.onLoad('Ember.Handlebars' function(hbars){ + hbars.registerHelper(...); + }); + ``` + + @method onLoad + @for Ember + @param name {String} name of hook + @param callback {Function} callback to be called +*/ +Ember.onLoad = function(name, callback) { + var object; + + loadHooks[name] = loadHooks[name] || Ember.A(); + loadHooks[name].pushObject(callback); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 See also `Ember.ViewTargetActionSupport`, which has view-aware defaults for target and actionContext. +<<<<<<< HEAD @class TargetActionSupport @namespace Ember @extends Ember.Mixin +======= +/** + Called when an Ember.js package (e.g Ember.Handlebars) has finished + loading. Triggers any callbacks registered for this event. + + @method runLoadHooks + @for Ember + @param name {String} name of hook + @param object {Object} object to pass to callbacks +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 */ Ember.TargetActionSupport = Ember.Mixin.create({ target: null, @@ -15714,6 +24908,7 @@ Ember.TargetActionSupport = Ember.Mixin.create({ Send an "action" with an "actionContext" to a "target". The action, actionContext and target will be retrieved from properties of the object. For example: +<<<<<<< HEAD ```javascript App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, { target: Ember.computed.alias('controller'), @@ -15745,6 +24940,31 @@ Ember.TargetActionSupport = Ember.Mixin.create({ The `actionContext` defaults to the object you mixing `TargetActionSupport` into. But `target` and `action` must be specified either as properties or with the argument to `triggerAction`, or a combination: +======= +/** +@module ember +@submodule ember-runtime +*/ + +/** + `Ember.ControllerMixin` provides a standard interface for all classes that + compose Ember's controller layer: `Ember.Controller`, + `Ember.ArrayController`, and `Ember.ObjectController`. + + @class ControllerMixin + @namespace Ember + @uses Ember.ActionHandler +*/ +Ember.ControllerMixin = Ember.Mixin.create(Ember.ActionHandler, { + /* ducktype as a controller */ + isController: true, + + /** + The object to which actions from the view should be sent. + + For example, when a Handlebars template uses the `{{action}}` helper, + it will attempt to send the action to the view's controller's `target`. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 ```javascript App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, { @@ -15782,6 +25002,7 @@ Ember.TargetActionSupport = Ember.Mixin.create({ if (target && action) { var ret; +<<<<<<< HEAD if (target.send) { ret = target.send.apply(target, args(actionContext, action)); } else { @@ -15795,6 +25016,18 @@ Ember.TargetActionSupport = Ember.Mixin.create({ } else { return false; } +======= + deprecatedSendHandles: function(actionName) { + return !!this[actionName]; + }, + + deprecatedSend: function(actionName) { + var args = [].slice.call(arguments, 1); + Ember.assert('' + this + " has the action " + actionName + " but it is not a function", typeof this[actionName] === 'function'); + Ember.deprecate('Action handlers implemented directly on controllers are deprecated in favor of action handlers on an `actions` object (' + actionName + ' on ' + this + ')', false); + this[actionName].apply(this, args); + return; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 } }); @@ -15830,6 +25063,7 @@ Ember.TargetActionSupport = Ember.Mixin.create({ // outputs: 'Our person has greeted' ``` +<<<<<<< HEAD You can also chain multiple event subscriptions: ```javascript @@ -15841,6 +25075,32 @@ Ember.TargetActionSupport = Ember.Mixin.create({ ``` @class Evented +======= + If you add or remove the properties to sort by or change the sort direction the content + sort order will be automatically updated. + + ```javascript + songsController.set('sortProperties', ['title']); + songsController.get('firstObject'); // {trackNumber: 2, title: 'Back in the U.S.S.R.'} + + songsController.toggleProperty('sortAscending'); + songsController.get('firstObject'); // {trackNumber: 4, title: 'Ob-La-Di, Ob-La-Da'} + ``` + + SortableMixin works by sorting the arrangedContent array, which is the array that + arrayProxy displays. Due to the fact that the underlying 'content' array is not changed, that + array will not display the sorted list: + + ```javascript + songsController.get('content').get('firstObject'); // Returns the unsorted original content + songsController.get('firstObject'); // Returns the sorted content. + ``` + + Although the sorted content can also be accessed through the arrangedContent property, + it is preferable to use the proxied class and not the arrangedContent array directly. + + @class SortableMixin +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 @namespace Ember */ Ember.Evented = Ember.Mixin.create({ @@ -15848,11 +25108,20 @@ Ember.Evented = Ember.Mixin.create({ /** Subscribes to a named event with given function. +<<<<<<< HEAD ```javascript person.on('didLoad', function() { // fired once the person has loaded }); ``` +======= + When specifying multiple properties the sorting will use properties + from the `sortProperties` array prioritized from first to last. + + @property {Array} sortProperties + */ + sortProperties: null, +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 An optional target can be passed in as the 2nd argument that will be set as the "this" for the callback. This is a good way to give your @@ -15871,9 +25140,18 @@ Ember.Evented = Ember.Mixin.create({ }, /** +<<<<<<< HEAD Subscribes a function to a named event and then cancels the subscription after the first time the event is triggered. It is good to use ``one`` when you only care about the first time an event has taken place. +======= + The function used to compare two values. You can override this if you + want to do custom comparisons. Functions must be of the type expected by + Array#sort, i.e. + return 0 if the two parameters are equal, + return a negative value if the first parameter is smaller than the second or + return a positive value otherwise: +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 This function takes an optional 2nd argument that will become the "this" value for the callback. If this argument is passed then the 3rd argument @@ -15924,6 +25202,7 @@ Ember.Evented = Ember.Mixin.create({ /** Cancels subscription for given name, target, and method. +<<<<<<< HEAD @method off @param {String} name The name of the event @param {Object} target The target of the subscription @@ -15934,6 +25213,20 @@ Ember.Evented = Ember.Mixin.create({ Ember.removeListener(this, name, target, method); return this; }, +======= + /** + Overrides the default arrangedContent from arrayProxy in order to sort by sortFunction. + Also sets up observers for each sortProperty on each item in the content Array. + + @property arrangedContent + */ + + arrangedContent: Ember.computed('content', 'sortProperties.@each', function(key, value) { + var content = get(this, 'content'), + isSorted = get(this, 'isSorted'), + sortProperties = get(this, 'sortProperties'), + self = this; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 /** Checks to see if object has any subscriptions for named event. @@ -15947,9 +25240,16 @@ Ember.Evented = Ember.Mixin.create({ } }); +<<<<<<< HEAD })(); +======= + _contentWillChange: Ember.beforeObserver('content', function() { + var content = get(this, 'content'), + sortProperties = get(this, 'sortProperties'); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 +<<<<<<< HEAD (function() { var RSVP = requireModule("rsvp"); @@ -15957,6 +25257,21 @@ var RSVP = requireModule("rsvp"); RSVP.configure('async', function(callback, promise) { Ember.run.schedule('actions', promise, callback, promise); }); +======= + this._super(); + }), + + sortAscendingWillChange: Ember.beforeObserver('sortAscending', function() { + this._lastSortAscending = get(this, 'sortAscending'); + }), + + sortAscendingDidChange: Ember.observer('sortAscending', function() { + if (get(this, 'sortAscending') !== this._lastSortAscending) { + var arrangedContent = get(this, 'arrangedContent'); + arrangedContent.reverseObjects(); + } + }), +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 /** @module ember @@ -16336,12 +25651,30 @@ Ember.TrackedArray.prototype = { composeIndex = arrayOperationIndex + 1; } +<<<<<<< HEAD return this._composeDelete(composeIndex); }, /** Apply all operations, reducing them to retain:n, for `n`, the number of items in the array. +======= + init: function() { + this._super(); + + this.set('_subControllers', Ember.A()); + }, + + content: Ember.computed(function () { + return Ember.A(); + }), + + controllerAt: function(idx, object, controllerClass) { + var container = get(this, 'container'), + subControllers = get(this, '_subControllers'), + subController = subControllers[idx], + factory, fullName; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 `callback` will be called for each operation and will be passed the following arguments: * {array} items The items for the given operation @@ -16357,8 +25690,14 @@ Ember.TrackedArray.prototype = { var items = [], offset = 0; +<<<<<<< HEAD forEach(this._operations, function (arrayOperation) { callback(arrayOperation.items, offset, arrayOperation.type); +======= + if (!container.has(fullName)) { + throw new Ember.Error('Could not resolve itemController: "' + controllerClass + '"'); + } +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 if (arrayOperation.type !== DELETE) { offset += arrayOperation.count; @@ -16405,6 +25744,7 @@ Ember.TrackedArray.prototype = { } } +<<<<<<< HEAD return new ArrayOperationMatch(arrayOperation, arrayOperationIndex, split, arrayOperationRangeStart); }, @@ -16412,6 +25752,15 @@ Ember.TrackedArray.prototype = { var arrayOperation = this._operations[arrayOperationIndex], splitItems = arrayOperation.items.slice(splitIndex), splitArrayOperation = new ArrayOperation(arrayOperation.type, splitItems.length, splitItems); +======= +/** + `Ember.ObjectController` is part of Ember's Controller layer. It is intended + to wrap a single object, proxying unhandled attempts to `get` and `set` to the underlying + content object, and to forward unhandled action attempts to its `target`. + + `Ember.ObjectController` derives this functionality from its superclass + `Ember.ObjectProxy` and the `Ember.ControllerMixin` mixin. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 // truncate LHS arrayOperation.count = splitIndex; @@ -16530,6 +25879,7 @@ Ember.TrackedArray.prototype = { /** Internal data structure to represent an array operation. +<<<<<<< HEAD @method ArrayOperation @private @property {string} type The type of the operation. One of @@ -16543,6 +25893,14 @@ function ArrayOperation (operation, count, items) { this.count = count; this.items = items; } +======= +var jQuery = this.jQuery || (Ember.imports && Ember.imports.jQuery); +if (!jQuery && typeof require === 'function') { + jQuery = require('jquery'); +} + +Ember.assert("Ember Views require jQuery 1.7, 1.8, 1.9, 1.10, or 2.0", jQuery && (jQuery().jquery.match(/^((1\.(7|8|9|10))|2.0)(\.\d+)?(pre|rc\d?)?/) || Ember.ENV.FORCE_JQUERY)); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 /** Internal data structure used to include information when looking up operations @@ -16798,6 +26156,7 @@ var get = Ember.get, set = Ember.set; an array, as they are accessed. This can be done by overriding `objectAtContent`: +<<<<<<< HEAD ```javascript var pets = ['dog', 'cat', 'fish']; var ap = Ember.ArrayProxy.create({ @@ -16823,6 +26182,60 @@ Ember.ArrayProxy = Ember.Object.extend(Ember.MutableArray,/** @scope Ember.Array @property content @type Ember.Array +======= +// IE 6/7 have bugs arond setting names on inputs during creation. +// From http://msdn.microsoft.com/en-us/library/ie/ms536389(v=vs.85).aspx: +// "To include the NAME attribute at run time on objects created with the createElement method, use the eTag." +var canSetNameOnInputs = (function() { + var div = document.createElement('div'), + el = document.createElement('input'); + + el.setAttribute('name', 'foo'); + div.appendChild(el); + + return !!div.innerHTML.match('foo'); +})(); + +/** + `Ember.RenderBuffer` gathers information regarding the a view and generates the + final representation. `Ember.RenderBuffer` will generate HTML which can be pushed + to the DOM. + + ```javascript + var buffer = Ember.RenderBuffer('div'); + ``` + + @class RenderBuffer + @namespace Ember + @constructor + @param {String} tagName tag name (such as 'div' or 'p') used for the buffer +*/ +Ember.RenderBuffer = function(tagName) { + return new Ember._RenderBuffer(tagName); +}; + +Ember._RenderBuffer = function(tagName) { + this.tagNames = [tagName || null]; + this.buffer = ""; +}; + +Ember._RenderBuffer.prototype = { + + // The root view's element + _element: null, + + _hasElement: true, + + /** + An internal set used to de-dupe class names when `addClass()` is + used. After each call to `addClass()`, the `classes` property + will be updated. + + @private + @property elementClasses + @type Array + @default [] +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 */ content: null, @@ -17043,9 +26456,60 @@ Ember.ArrayProxy = Ember.Object.extend(Ember.MutableArray,/** @scope Ember.Array return obj ; }, +<<<<<<< HEAD pushObjects: function(objects) { if (!(Ember.Enumerable.detect(objects) || Ember.isArray(objects))) { throw new TypeError("Must pass Ember.Enumerable to Ember.MutableArray#pushObjects"); +======= + generateElement: function() { + var tagName = this.tagNames.pop(), // pop since we don't need to close + id = this.elementId, + classes = this.classes, + attrs = this.elementAttributes, + props = this.elementProperties, + style = this.elementStyle, + styleBuffer = '', attr, prop, tagString; + + if (attrs && attrs.name && !canSetNameOnInputs) { + // IE allows passing a tag to createElement. See note on `canSetNameOnInputs` above as well. + tagString = '<'+stripTagName(tagName)+' name="'+escapeAttribute(attrs.name)+'">'; + } else { + tagString = tagName; + } + + var element = document.createElement(tagString), + $element = Ember.$(element); + + if (id) { + $element.attr('id', id); + this.elementId = null; + } + if (classes) { + $element.attr('class', classes.join(' ')); + this.classes = null; + } + + if (style) { + for (prop in style) { + if (style.hasOwnProperty(prop)) { + styleBuffer += (prop + ':' + style[prop] + ';'); + } + } + + $element.attr('style', styleBuffer); + + this.elementStyle = null; + } + + if (attrs) { + for (attr in attrs) { + if (attrs.hasOwnProperty(attr)) { + $element.attr(attr, attrs[attr]); + } + } + + this.elementAttributes = null; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 } this._replace(get(this, 'length'), 0, objects); return this; @@ -17105,9 +26569,30 @@ Ember.ArrayProxy = Ember.Object.extend(Ember.MutableArray,/** @scope Ember.Array */ +<<<<<<< HEAD var set = Ember.set, get = Ember.get, guidFor = Ember.guidFor; var forEach = Ember.EnumerableUtils.forEach, indexOf = Ember.ArrayPolyfills.indexOf; +======= +/** + `Ember.EventDispatcher` handles delegating browser events to their + corresponding `Ember.Views.` For example, when you click on a view, + `Ember.EventDispatcher` ensures that that view's `mouseDown` method gets + called. + + @class EventDispatcher + @namespace Ember + @private + @extends Ember.Object +*/ +Ember.EventDispatcher = Ember.Object.extend({ + + /** + The set of events names (and associated handler function names) to be setup + and dispatched by the `EventDispatcher`. Custom events can added to this list at setup + time, generally via the `Ember.Application.customEvents` hash. Only override this + default set to prevent the EventDispatcher from listening on some events all together. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 var EachArray = Ember.Object.extend(Ember.Array, { @@ -17118,16 +26603,25 @@ var EachArray = Ember.Object.extend(Ember.Array, { this._content = content; }, +<<<<<<< HEAD objectAt: function(idx) { var item = this._content.objectAt(idx); return item && get(item, this._keyName); }, +======= + /** + The root DOM element to which event listeners should be attached. Event + listeners will be attached to the document unless this is overridden. + + Can be specified as a DOMElement or a selector string. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 length: Ember.computed(function() { var content = this._content; return content ? get(content, 'length') : 0; }) +<<<<<<< HEAD }); var IS_OBSERVER = /^.+:(before|change)$/; @@ -17135,6 +26629,17 @@ var IS_OBSERVER = /^.+:(before|change)$/; function addObserverForContentKey(content, keyName, proxy, idx, loc) { var objects = proxy._objects, guid; if (!objects) objects = proxy._objects = {}; +======= + @private + @property rootElement + @type DOMElement + @default 'body' + */ + rootElement: 'body', + + /** + Sets up event listeners for standard browser events. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 while(--loc>=idx) { var item = content.objectAt(loc); @@ -17143,6 +26648,7 @@ function addObserverForContentKey(content, keyName, proxy, idx, loc) { Ember.addBeforeObserver(item, keyName, proxy, 'contentKeyWillChange'); Ember.addObserver(item, keyName, proxy, 'contentKeyDidChange'); +<<<<<<< HEAD // keep track of the index each item was found at so we can map // it back when the obj changes. guid = guidFor(item); @@ -17151,6 +26657,14 @@ function addObserverForContentKey(content, keyName, proxy, idx, loc) { } } } +======= + @private + @method setup + @param addedEvents {Hash} + */ + setup: function(addedEvents, rootElement) { + var event, events = get(this, 'events'); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 function removeObserverForContentKey(content, keyName, proxy, idx, loc) { var objects = proxy._objects; @@ -17195,12 +26709,34 @@ Ember.EachProxy = Ember.Object.extend({ }, /** +<<<<<<< HEAD You can directly access mapped properties by simply requesting them. The `unknownProperty` handler will generate an EachArray of each item. @method unknownProperty @param keyName {String} @param value {*} +======= + Registers an event listener on the document. If the given event is + triggered, the provided event handler will be triggered on the target view. + + If the target view does not implement the event handler, or if the handler + returns `false`, the parent view will be called. The event will continue to + bubble to each successive parent view until it reaches the top. + + For example, to have the `mouseDown` method called on the target view when + a `mousedown` event is received from the browser, do the following: + + ```javascript + setupHandler('mousedown', 'mouseDown'); + ``` + + @private + @method setupHandler + @param {Element} rootElement + @param {String} event the browser-originated event to listen to + @param {String} eventName the name of the method to call on the view +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 */ unknownProperty: function(keyName, value) { var ret; @@ -17210,9 +26746,16 @@ Ember.EachProxy = Ember.Object.extend({ return ret; }, +<<<<<<< HEAD // .......................................................... // ARRAY CHANGES // Invokes whenever the content array itself changes. +======= + rootElement.on(event + '.ember', '.ember-view', function(evt, triggeringManager) { + return Ember.handleErrors(function handleViewEvent() { + var view = Ember.View.views[this.id], + result = true, manager = null; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 arrayWillChange: function(content, idx, removedCnt, addedCnt) { var keys = this._keys, key, lim; @@ -17223,7 +26766,14 @@ Ember.EachProxy = Ember.Object.extend({ for(key in keys) { if (!keys.hasOwnProperty(key)) { continue; } +<<<<<<< HEAD if (lim>0) { removeObserverForContentKey(content, key, this, idx, lim); } +======= + rootElement.on(event + '.ember', '[data-ember-action]', function(evt) { + return Ember.handleErrors(function handleActionEvent() { + var actionId = Ember.$(evt.currentTarget).attr('data-ember-action'), + action = Ember.Handlebars.ActionHelper.registeredActions[actionId]; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 Ember.propertyWillChange(this, key); } @@ -17282,6 +26832,7 @@ Ember.EachProxy = Ember.Object.extend({ } }, +<<<<<<< HEAD stopObservingContentKey: function(keyName) { var keys = this._keys; if (keys && (keys[keyName]>0) && (--keys[keyName]<=0)) { @@ -17289,6 +26840,12 @@ Ember.EachProxy = Ember.Object.extend({ len = get(content, 'length'); removeObserverForContentKey(content, keyName, this, 0, len); } +======= + _bubbleEvent: function(view, evt, eventName) { + return Ember.run(function bubbleEvent() { + return view.handleEvent(eventName, evt); + }); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 }, contentKeyWillChange: function(obj, keyName) { @@ -17354,20 +26911,35 @@ var NativeArray = Ember.Mixin.create(Ember.MutableArray, Ember.Observable, Ember return this; }, +<<<<<<< HEAD // If you ask for an unknown property, then try to collect the value // from member items. unknownProperty: function(key, value) { var ret;// = this.reducedProperty(key, value) ; if ((value !== undefined) && ret === undefined) { ret = this[key] = value; +======= + _modelDidChange: Ember.observer('model', function() { + var containers = get(this, '_childContainers'); + + for (var prop in containers) { + if (!containers.hasOwnProperty(prop)) { continue; } + containers[prop].destroy(); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 } return ret ; }, +<<<<<<< HEAD // If browser did not implement indexOf natively, then override with // specialized version indexOf: function(object, startAt) { var idx, len = this.length; +======= + set(this, '_childContainers', {}); + }) +}); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 if (startAt === undefined) startAt = 0; else startAt = (startAt < 0) ? Math.ceil(startAt) : Math.floor(startAt); @@ -17426,6 +26998,7 @@ if (ignore.length>0) { */ Ember.NativeArray = NativeArray; +<<<<<<< HEAD /** Creates an `Ember.NativeArray` from an Array like object. Does not modify the original object. Ember.A is not needed if @@ -17433,6 +27006,13 @@ Ember.NativeArray = NativeArray; it is recommended that you use Ember.A when creating addons for ember or when you can not guarantee that `Ember.EXTEND_PROTOTYPES` will be `true`. +======= +var get = Ember.get, set = Ember.set; +var guidFor = Ember.guidFor; +var a_forEach = Ember.EnumerableUtils.forEach; +var a_addObject = Ember.EnumerableUtils.addObject; +var meta = Ember.meta; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 Example @@ -17449,7 +27029,29 @@ Ember.NativeArray = NativeArray; }); ``` +<<<<<<< HEAD @method A +======= + ret.replace = function (idx, removedCount, addedViews) { + if (view instanceof Ember.ContainerView) { + Ember.deprecate("Manipulating an Ember.ContainerView through its childViews property is deprecated. Please use the ContainerView instance itself as an Ember.MutableArray."); + return view.replace(idx, removedCount, addedViews); + } + throw new Ember.Error("childViews is immutable"); + }; + + return ret; +}); + +Ember.warn("The VIEW_PRESERVES_CONTEXT flag has been removed and the functionality can no longer be disabled.", Ember.ENV.VIEW_PRESERVES_CONTEXT !== false); + +/** + Global hash of shared templates. This will automatically be populated + by the build tools so that you can store your Handlebars templates in + separate files that get loaded into JavaScript at buildtime. + + @property TEMPLATES +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 @for Ember @return {Ember.NativeArray} */ @@ -17459,6 +27061,7 @@ Ember.A = function(arr) { }; /** +<<<<<<< HEAD Activates the mixin on the Array.prototype if not already applied. Calling this method more than once is safe. This will be called when ember is loaded unless you have `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Array` @@ -17471,6 +27074,25 @@ Ember.A = function(arr) { Ember.NativeArray.activate(); } ``` +======= + `Ember.CoreView` is an abstract class that exists to give view-like behavior + to both Ember's main view class `Ember.View` and other classes like + `Ember._SimpleMetamorphView` that don't need the fully functionaltiy of + `Ember.View`. + + Unless you have specific needs for `CoreView`, you will use `Ember.View` + in your applications. + + @class CoreView + @namespace Ember + @extends Ember.Object + @uses Ember.Evented + @uses Ember.ActionHandler +*/ + +Ember.CoreView = Ember.Object.extend(Ember.Evented, Ember.ActionHandler, { + isView: true, +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 @method activate @for Ember.NativeArray @@ -17503,6 +27125,7 @@ var get = Ember.get, set = Ember.set, guidFor = Ember.guidFor, isNone = Ember.is /** An unordered collection of objects. +<<<<<<< HEAD A Set works a bit like an array except that its items are not ordered. You can create a set to efficiently test for membership for an object. You can also iterate through a set just like an array, even accessing objects by @@ -17510,20 +27133,47 @@ var get = Ember.get, set = Ember.set, guidFor = Ember.guidFor, isNone = Ember.is All Sets are observable via the Enumerable Observer API - which works on any enumerable object including both Sets and Arrays. +======= + /** + Invoked by the view system when this view needs to produce an HTML + representation. This method will create a new render buffer, if needed, + then apply any default attributes, such as class names and visibility. + Finally, the `render()` method is invoked, which is responsible for + doing the bulk of the rendering. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 ## Creating a Set +<<<<<<< HEAD You can create a set like you would most objects using `new Ember.Set()`. Most new sets you create will be empty, but you can also initialize the set with some content by passing an array or other enumerable of objects to the constructor. +======= + @method renderToBuffer + @param {Ember.RenderBuffer} buffer the render buffer. If no buffer is + passed, a default buffer, using the current view's `tagName`, will + be used. + @private + */ + renderToBuffer: function(parentBuffer, bufferOperation) { + var name = 'render.' + this.instrumentName, + details = {}; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 Finally, you can pass in an existing set and the set will be copied. You can also create a copy of a set by calling `Ember.Set#copy()`. +<<<<<<< HEAD ```javascript // creates a new empty set var foundNames = new Ember.Set(); +======= + return Ember.instrument(name, details, function instrumentRenderToBuffer() { + return this._renderToBuffer(parentBuffer, bufferOperation); + }, this); + }, +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 // creates a set with four names in it. var names = new Ember.Set(["Charles", "Tom", "Juan", "Alex"]); // :P @@ -17541,6 +27191,7 @@ var get = Ember.get, set = Ember.set, guidFor = Ember.guidFor, isNone = Ember.is `remove()`. You can add any type of object including primitives such as numbers, strings, and booleans. +<<<<<<< HEAD Unlike arrays, objects can only exist one time in a set. If you call `add()` on a set with the same object multiple times, the object will only be added once. Likewise, calling `remove()` with the same object multiple times will @@ -17556,6 +27207,43 @@ var get = Ember.get, set = Ember.set, guidFor = Ember.guidFor, isNone = Ember.is queue when you don't care which order the jobs are executed in. ## Testing for an Object +======= + /** + Override the default event firing from `Ember.Evented` to + also call methods with the given name. + + @method trigger + @param name {String} + @private + */ + trigger: function(name) { + this._super.apply(this, arguments); + var method = this[name]; + if (method) { + var args = [], i, l; + for (i = 1, l = arguments.length; i < l; i++) { + args.push(arguments[i]); + } + return method.apply(this, args); + } + }, + + deprecatedSendHandles: function(actionName) { + return !!this[actionName]; + }, + + deprecatedSend: function(actionName) { + var args = [].slice.call(arguments, 1); + Ember.assert('' + this + " has the action " + actionName + " but it is not a function", typeof this[actionName] === 'function'); + Ember.deprecate('Action handlers implemented directly on views are deprecated in favor of action handlers on an `actions` object (' + actionName + ' on ' + this + ')', false); + this[actionName].apply(this, args); + return; + }, + + has: function(name) { + return Ember.typeOf(this[name]) === 'function' || this._super(name); + }, +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 To test for an object's presence in a set you simply call `Ember.Set#contains()`. @@ -17654,9 +27342,15 @@ Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Emb return this; }, +<<<<<<< HEAD /** Returns true if the passed object is also an enumerable that contains the same objects as the receiver. +======= + The default HTML tag name used for a view's DOM representation is `div`. This + can be customized by setting the `tagName` property. The following view + class: +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 ```javascript var colors = ["red", "green", "blue"], @@ -17848,10 +27542,16 @@ Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Emb return this.length > 0 ? this[0] : undefined; }), +<<<<<<< HEAD // more optimized version lastObject: Ember.computed(function() { return this.length > 0 ? this[this.length-1] : undefined; }), +======= + Both `classNames` and `classNameBindings` are concatenated properties. See + [Ember.Object](/api/classes/Ember.Object.html) documentation for more + information about concatenated properties. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 // implements Ember.MutableEnumerable addObject: function(obj) { @@ -17897,9 +27597,14 @@ Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Emb if (idx>=0 && idx >>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 // swap items - basically move the item to the end so it can be removed if (idx < len-1) { @@ -17947,11 +27652,38 @@ Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Emb })(); +<<<<<<< HEAD (function() { var DeferredMixin = Ember.DeferredMixin, // mixins/deferred get = Ember.get; +======= + If you have nested resources, your Handlebars template will look like this: + + ```html + + ``` + + And `templateName` property: + + ```javascript + AView = Ember.View.extend({ + templateName: 'posts/new' + }); + ``` + + Using a value for `templateName` that does not have a Handlebars template + with a matching `data-template-name` attribute will throw an error. + + For views classes that may have a template later defined (e.g. as the block + portion of a `{{view}}` Handlebars helper call in another template or in + a subclass), you can provide a `defaultTemplate` property set to compiled + template function. If a template is not later provided for the view instance + the `defaultTemplate` value will be used: +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 var Deferred = Ember.Object.extend(DeferredMixin); @@ -18034,6 +27766,11 @@ Ember.runLoadHooks = function(name, object) { })(); +<<<<<<< HEAD +======= + See [Ember.Handlebars.helpers.yield](/api/classes/Ember.Handlebars.helpers.html#method_yield) + for more information. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 (function() { @@ -18079,7 +27816,11 @@ Ember.ControllerMixin = Ember.Mixin.create(Ember.ActionHandler, { parentController: null, +<<<<<<< HEAD store: null, +======= + See [Handlebars.helpers.action](/api/classes/Ember.Handlebars.helpers.html#method_action). +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 model: Ember.computed.alias('content'), @@ -18135,18 +27876,40 @@ var get = Ember.get, set = Ember.set, forEach = Ember.EnumerableUtils.forEach; sortAscending: true }); +<<<<<<< HEAD songsController.get('firstObject'); // {trackNumber: 2, title: 'Back in the U.S.S.R.'} songsController.addObject({trackNumber: 1, title: 'Dear Prudence'}); songsController.get('firstObject'); // {trackNumber: 1, title: 'Dear Prudence'} ``` +======= + Other `Ember.View` instances can be included as part of a view's template by + using the `{{view}}` Handlebars helper. See [Ember.Handlebars.helpers.view](/api/classes/Ember.Handlebars.helpers.html#method_view) + for additional information. + + @class View + @namespace Ember + @extends Ember.CoreView +*/ +Ember.View = Ember.CoreView.extend({ +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 If you add or remove the properties to sort by or change the sort direction the content sort order will be automatically updated. +<<<<<<< HEAD ```javascript songsController.set('sortProperties', ['title']); songsController.get('firstObject'); // {trackNumber: 2, title: 'Back in the U.S.S.R.'} +======= + /** + @property isView + @type Boolean + @default true + @static + */ + isView: true, +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 songsController.toggleProperty('sortAscending'); songsController.get('firstObject'); // {trackNumber: 4, title: 'Ob-La-Di, Ob-La-Da'} @@ -18156,6 +27919,7 @@ var get = Ember.get, set = Ember.set, forEach = Ember.EnumerableUtils.forEach; arrayProxy displays. Due to the fact that the underlying 'content' array is not changed, that array will not display the sorted list: +<<<<<<< HEAD ```javascript songsController.get('content').get('firstObject'); // Returns the unsorted original content songsController.get('firstObject'); // Returns the sorted content. @@ -18163,6 +27927,10 @@ var get = Ember.get, set = Ember.set, forEach = Ember.EnumerableUtils.forEach; Although the sorted content can also be accessed through the arrangedContent property, it is preferable to use the proxied class and not the arrangedContent array directly. +======= + By default `Ember.View` will lookup a template with this name in + `Ember.TEMPLATES` (a shared global object). +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 @class SortableMixin @namespace Ember @@ -18173,14 +27941,20 @@ Ember.SortableMixin = Ember.Mixin.create(Ember.MutableEnumerable, { /** Specifies which properties dictate the arrangedContent's sort order. +<<<<<<< HEAD When specifying multiple properties the sorting will use properties from the `sortProperties` array prioritized from first to last. +======= + By default `Ember.View` will lookup a template with this name in + `Ember.TEMPLATES` (a shared global object). +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 @property {Array} sortProperties */ sortProperties: null, /** +<<<<<<< HEAD Specifies the arrangedContent's sort direction @property {Boolean} sortAscending @@ -18194,6 +27968,11 @@ Ember.SortableMixin = Ember.Mixin.create(Ember.MutableEnumerable, { return 0 if the two parameters are equal, return a negative value if the first parameter is smaller than the second or return a positive value otherwise: +======= + The template used to render the view. This should be a function that + accepts an optional context parameter and returns a string of HTML that + will be inserted into the DOM relative to its parent view. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 ```javascript function(x,y) { // These are assumed to be integers @@ -18253,6 +28032,7 @@ Ember.SortableMixin = Ember.Mixin.create(Ember.MutableEnumerable, { @property arrangedContent */ +<<<<<<< HEAD arrangedContent: Ember.computed('content', 'sortProperties.@each', function(key, value) { var content = get(this, 'content'), isSorted = get(this, 'isSorted'), @@ -18271,6 +28051,12 @@ Ember.SortableMixin = Ember.Mixin.create(Ember.MutableEnumerable, { }, this); return Ember.A(content); } +======= + /** + Private copy of the view's template context. This can be set directly + by Handlebars without triggering the observer that causes the view + to be re-rendered. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 return content; }), @@ -18287,8 +28073,16 @@ Ember.SortableMixin = Ember.Mixin.create(Ember.MutableEnumerable, { }, this); } +<<<<<<< HEAD this._super(); }), +======= + @property _context + @private + */ + _context: Ember.computed(function(key) { + var parentView, controller; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 sortAscendingWillChange: Ember.beforeObserver('sortAscending', function() { this._lastSortAscending = get(this, 'sortAscending'); @@ -18301,6 +28095,7 @@ Ember.SortableMixin = Ember.Mixin.create(Ember.MutableEnumerable, { } }), +<<<<<<< HEAD contentArrayWillChange: function(array, idx, removedCount, addedCount) { var isSorted = get(this, 'isSorted'); @@ -18324,10 +28119,43 @@ Ember.SortableMixin = Ember.Mixin.create(Ember.MutableEnumerable, { contentArrayDidChange: function(array, idx, removedCount, addedCount) { var isSorted = get(this, 'isSorted'), sortProperties = get(this, 'sortProperties'); +======= + /** + If a value that affects template rendering changes, the view should be + re-rendered to reflect the new value. + + @method _contextDidChange + @private + */ + _contextDidChange: Ember.observer('context', function() { + this.rerender(); + }), + + /** + If `false`, the view will appear hidden in DOM. + + @property isVisible + @type Boolean + @default null + */ + isVisible: true, + + /** + Array of child views. You should never edit this array directly. + Instead, use `appendChild` and `removeFromParent`. + + @property childViews + @type Array + @default [] + @private + */ + childViews: childViewsProperty, +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 if (isSorted) { var addedObjects = array.slice(idx, idx+addedCount); +<<<<<<< HEAD forEach(addedObjects, function(item) { this.insertItemSorted(item); @@ -18336,6 +28164,25 @@ Ember.SortableMixin = Ember.Mixin.create(Ember.MutableEnumerable, { }, this); }, this); } +======= + // When it's a virtual view, we need to notify the parent that their + // childViews will change. + _childViewsWillChange: Ember.beforeObserver('childViews', function() { + if (this.isVirtual) { + var parentView = get(this, 'parentView'); + if (parentView) { Ember.propertyWillChange(parentView, 'childViews'); } + } + }), + + // When it's a virtual view, we need to notify the parent that their + // childViews did change. + _childViewsDidChange: Ember.observer('childViews', function() { + if (this.isVirtual) { + var parentView = get(this, 'parentView'); + if (parentView) { Ember.propertyDidChange(parentView, 'childViews'); } + } + }), +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 return this._super(array, idx, removedCount, addedCount); }, @@ -18362,8 +28209,20 @@ Ember.SortableMixin = Ember.Mixin.create(Ember.MutableEnumerable, { } }, +<<<<<<< HEAD _binarySearch: function(item, low, high) { var mid, midItem, res, arrangedContent; +======= + /** + Return the nearest ancestor that has a given property. + + @function nearestWithProperty + @param {String} property A property name + @return Ember.View + */ + nearestWithProperty: function(property) { + var view = get(this, 'parentView'); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 if (low === high) { return low; @@ -18371,8 +28230,17 @@ Ember.SortableMixin = Ember.Mixin.create(Ember.MutableEnumerable, { arrangedContent = get(this, 'arrangedContent'); +<<<<<<< HEAD mid = low + Math.floor((high - low) / 2); midItem = arrangedContent.objectAt(mid); +======= + @method nearestChildOf + @param {Class} klass Subclass of Ember.View (or Ember.View itself) + @return Ember.View + */ + nearestChildOf: function(klass) { + var view = get(this, 'parentView'); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 res = this.orderBy(midItem, item); @@ -18382,14 +28250,26 @@ Ember.SortableMixin = Ember.Mixin.create(Ember.MutableEnumerable, { return this._binarySearch(item, low, mid); } +<<<<<<< HEAD return mid; } }); })(); +======= + /** + When the parent view changes, recursively invalidate `controller` + + @method _parentViewDidChange + @private + */ + _parentViewDidChange: Ember.observer('_parentView', function() { + if (this.isDestroying) { return; } +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 +<<<<<<< HEAD (function() { /** @module ember @@ -18398,15 +28278,31 @@ Ember.SortableMixin = Ember.Mixin.create(Ember.MutableEnumerable, { var get = Ember.get, set = Ember.set, forEach = Ember.EnumerableUtils.forEach, replace = Ember.EnumerableUtils.replace; +======= + if (get(this, 'parentView.controller') && !get(this, 'controller')) { + this.notifyPropertyChange('controller'); + } + }), + + _controllerDidChange: Ember.observer('controller', function() { + if (this.isDestroying) { return; } +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 /** `Ember.ArrayController` provides a way for you to publish a collection of objects so that you can easily bind to the collection from a Handlebars `#each` helper, an `Ember.CollectionView`, or other controllers. +<<<<<<< HEAD The advantage of using an `ArrayController` is that you only have to set up your view bindings once; to change what's displayed, simply swap out the `content` property on the controller. +======= + this.forEachChildView(function(view) { + view.propertyDidChange('controller'); + }); + }), +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 For example, imagine you wanted to display a list of items fetched via an XHR request. Create an `Ember.ArrayController` and set its `content` property: @@ -18491,11 +28387,21 @@ Ember.ArrayController = Ember.ArrayProxy.extend(Ember.ControllerMixin, Ember.SortableMixin, { /** +<<<<<<< HEAD The controller used to wrap items, if any. @property itemController @type String @default null +======= + Iterates over the view's `classNameBindings` array, inserts the value + of the specified property into the `classNames` array, then creates an + observer to update the view's element if the bound property ever changes + in the future. + + @method _applyClassNameBindings + @private +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 */ itemController: null, @@ -18548,10 +28454,23 @@ Ember.ArrayController = Ember.ArrayProxy.extend(Ember.ControllerMixin, return object; }, +<<<<<<< HEAD arrangedContentDidChange: function() { this._super(); this._resetSubControllers(); }, +======= + /** + Iterates through the view's attribute bindings, sets up observers for each, + then applies the current value of the attributes to the passed render buffer. + + @method _applyAttributeBindings + @param {Ember.RenderBuffer} buffer + @private + */ + _applyAttributeBindings: function(buffer, attributeBindings) { + var attributeValue, elem; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 arrayContentDidChange: function(idx, removedCnt, addedCnt) { var subControllers = get(this, '_subControllers'), @@ -18575,6 +28494,7 @@ Ember.ArrayController = Ember.ArrayProxy.extend(Ember.ControllerMixin, this.set('_subControllers', Ember.A()); }, +<<<<<<< HEAD content: Ember.computed(function () { return Ember.A(); }), @@ -18584,10 +28504,25 @@ Ember.ArrayController = Ember.ArrayProxy.extend(Ember.ControllerMixin, subControllers = get(this, '_subControllers'), subController = subControllers[idx], factory, fullName; +======= + /** + Given a property name, returns a dasherized version of that + property name if the property evaluates to a non-falsy value. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 if (subController) { return subController; } +<<<<<<< HEAD fullName = "controller:" + controllerClass; +======= + @method _classStringForProperty + @param property + @private + */ + _classStringForProperty: function(property) { + var parsedPath = Ember.View._parsePropertyPath(property); + var path = parsedPath.path; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 if (!container.has(fullName)) { throw new Ember.Error('Could not resolve itemController: "' + controllerClass + '"'); @@ -18675,7 +28610,17 @@ if (!jQuery && typeof require === 'function') { jQuery = require('jquery'); } +<<<<<<< HEAD Ember.assert("Ember Views require jQuery 1.7, 1.8, 1.9, 1.10, or 2.0", jQuery && (jQuery().jquery.match(/^((1\.(7|8|9|10))|2.0)(\.\d+)?(pre|rc\d?)?/) || Ember.ENV.FORCE_JQUERY)); +======= + @method replaceIn + @param {String|DOMElement|jQuery} target A selector, element, HTML string, or jQuery object + @return {Ember.View} received + */ + replaceIn: function(target) { + Ember.assert("You tried to replace in (" + target + ") but that isn't in the DOM", Ember.$(target).length > 0); + Ember.assert("You cannot replace an existing Ember.View. Consider using Ember.ContainerView instead.", !Ember.$(target).is('.ember-view') && !Ember.$(target).parents().is('.ember-view')); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 /** Alias for jQuery @@ -18685,8 +28630,15 @@ Ember.assert("Ember Views require jQuery 1.7, 1.8, 1.9, 1.10, or 2.0", jQuery && */ Ember.$ = jQuery; +<<<<<<< HEAD })(); +======= + /** + Schedules a DOM operation to occur during the next render phase. This + ensures that all bindings have finished synchronizing before the view is + rendered. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 (function() { @@ -18705,7 +28657,17 @@ if (Ember.$) { }); } +<<<<<<< HEAD })(); +======= + @method _insertElementLater + @param {Function} fn the function that inserts the element into the DOM + @private + */ + _insertElementLater: function(fn) { + this._scheduledInsert = Ember.run.scheduleOnce('render', this, '_insertElement', fn); + }, +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 @@ -18808,6 +28770,7 @@ var canSetInnerHTML = function(tagName) { innerHTMLTags[tagName] = canSet; +<<<<<<< HEAD return canSet; }; @@ -18820,6 +28783,19 @@ var setInnerHTML = function(element, html) { // Firefox versions < 11 do not have support for element.outerHTML. var outerHTML = element.outerHTML || new XMLSerializer().serializeToString(element); Ember.assert("Can't set innerHTML on "+element.tagName+" in this browser", outerHTML); +======= + /** + Run this callback on the current view (unless includeSelf is false) and recursively on child views. + + @method invokeRecursively + @param fn {Function} + @param includeSelf {Boolean} Includes itself if true. + @private + */ + invokeRecursively: function(fn, includeSelf) { + var childViews = (includeSelf === false) ? this._childViews : [this]; + var currentViews, view, currentChildViews; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 var startTag = outerHTML.match(new RegExp("<"+tagName+"([^>]*)>", 'i'))[0], endTag = ''; @@ -18864,10 +28840,15 @@ var ClassSet = function() { this.list = []; }; +<<<<<<< HEAD ClassSet.prototype = { add: function(string) { if (string in this.seen) { return; } this.seen[string] = true; +======= + You should not call or override this method yourself, but you may + want to implement the above callbacks. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 this.list.push(string); }, @@ -18880,6 +28861,7 @@ ClassSet.prototype = { var BAD_TAG_NAME_TEST_REGEXP = /[^a-zA-Z0-9\-]/; var BAD_TAG_NAME_REPLACE_REGEXP = /[^a-zA-Z0-9\-]/g; +<<<<<<< HEAD function stripTagName(tagName) { if (!tagName) { return tagName; @@ -18888,10 +28870,17 @@ function stripTagName(tagName) { if (!BAD_TAG_NAME_TEST_REGEXP.test(tagName)) { return tagName; } +======= + /** + Triggers the `willDestroyElement` event (which invokes the + `willDestroyElement()` method if it exists) on this view and all child + views. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 return tagName.replace(BAD_TAG_NAME_REPLACE_REGEXP, ''); } +<<<<<<< HEAD var BAD_CHARS_REGEXP = /&(?!\w+;)|[<>"'`]/g; var POSSIBLE_CHARS_REGEXP = /[&<>"'`]/; @@ -18911,6 +28900,31 @@ function escapeAttribute(value) { }; var string = value.toString(); +======= + @method _notifyWillDestroyElement + @private + */ + _notifyWillDestroyElement: function() { + var viewCollection = this.viewHierarchyCollection(); + viewCollection.trigger('willClearRender'); + viewCollection.trigger('willDestroyElement'); + return viewCollection; + }, + + /** + If this view's element changes, we need to invalidate the caches of our + child views so that we do not retain references to DOM elements that are + no longer needed. + + @method _elementDidChange + @private + */ + _elementDidChange: Ember.observer('element', function() { + this.forEachChildView(function(view) { + delete meta(view).cache.element; + }); + }), +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 if(!POSSIBLE_CHARS_REGEXP.test(string)) { return string; } return string.replace(BAD_CHARS_REGEXP, escapeChar); @@ -18988,8 +29002,13 @@ Ember._RenderBuffer.prototype = /** The id in of the element, to be applied in the id attribute. +<<<<<<< HEAD You should not set this property yourself, rather, you should use the `id()` method of `Ember.RenderBuffer`. +======= + The full list of valid WAI-ARIA roles is available at: + [http://www.w3.org/TR/wai-aria/roles#roles_categorization](http://www.w3.org/TR/wai-aria/roles#roles_categorization) +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 @property elementId @type String @@ -19044,6 +29063,7 @@ Ember._RenderBuffer.prototype = elementTag: null, /** +<<<<<<< HEAD A hash keyed on the name of the style attribute and whose value will be applied to that attribute. For example, if you wanted to apply a `background-color:black;` style to an element, you would set the @@ -19055,6 +29075,16 @@ Ember._RenderBuffer.prototype = @property elementStyle @type Hash @default {} +======= + Setup a view, but do not finish waking it up. + + * configure `childViews` + * register the view with the global views hash, which is used for event + dispatch + + @method init + @private +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 */ elementStyle: null, @@ -19177,9 +29207,26 @@ Ember._RenderBuffer.prototype = @param {String} name The name of the property @chainable */ +<<<<<<< HEAD removeProp: function(name) { var properties = this.elementProperties; if (properties) { delete properties[name]; } +======= + createChildView: function(view, attrs) { + if (!view) { + throw new TypeError("createChildViews first argument must exist"); + } + + if (view.isView && view._parentView === this && view.container === this.container) { + return view; + } + + attrs = attrs || {}; + attrs._parentView = this; + + if (Ember.CoreView.detect(view)) { + attrs.templateData = attrs.templateData || get(this, 'templateData'); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 return this; }, @@ -19213,6 +29260,7 @@ Ember._RenderBuffer.prototype = return; } +<<<<<<< HEAD var buffer = this.buffer, id = this.elementId, classes = this.classes, @@ -19231,6 +29279,24 @@ Ember._RenderBuffer.prototype = buffer += ' class="' + escapeAttribute(classes.join(' ')) + '"'; this.classes = null; } +======= + return view; + }, + + becameVisible: Ember.K, + becameHidden: Ember.K, + + /** + When the view's `isVisible` property changes, toggle the visibility + element of the actual DOM element. + + @method _isVisibleDidChange + @private + */ + _isVisibleDidChange: Ember.observer('isVisible', function() { + var $el = this.$(); + if (!$el) { return; } +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 if (style) { buffer += ' style="'; @@ -19245,6 +29311,16 @@ Ember._RenderBuffer.prototype = this.elementStyle = null; } +<<<<<<< HEAD +======= + }), + + _notifyBecameVisible: function() { + this.trigger('becameVisible'); + + this.forEachChildView(function(view) { + var isVisible = get(view, 'isVisible'); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 if (attrs) { for (attr in attrs) { @@ -19282,6 +29358,7 @@ Ember._RenderBuffer.prototype = if (tagName) { this.buffer += ''; } }, +<<<<<<< HEAD currentTagName: function() { return this.tagNames[this.tagNames.length-1]; }, @@ -19294,6 +29371,39 @@ Ember._RenderBuffer.prototype = props = this.elementProperties, style = this.elementStyle, styleBuffer = '', attr, prop, tagString; +======= + transitionTo: function(state, children) { + var priorState = this.currentState, + currentState = this.currentState = this.states[state]; + this.state = state; + + if (priorState && priorState.exit) { priorState.exit(this); } + if (currentState.enter) { currentState.enter(this); } + if (state === 'inDOM') { delete Ember.meta(this).cache.element; } + + if (children !== false) { + this.forEachChildView(function(view) { + view.transitionTo(state); + }); + } + }, + + // ....................................................... + // EVENT HANDLING + // + + /** + Handle events from `Ember.EventDispatcher` + + @method handleEvent + @param eventName {String} + @param evt {Event} + @private + */ + handleEvent: function(eventName, evt) { + return this.currentState.handleEvent(this, eventName, evt); + }, +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 if (attrs && attrs.name && !canSetNameOnInputs) { // IE allows passing a tag to createElement. See note on `canSetNameOnInputs` above as well. @@ -19302,8 +29412,35 @@ Ember._RenderBuffer.prototype = tagString = tagName; } +<<<<<<< HEAD var element = document.createElement(tagString), $element = Ember.$(element); +======= + if (!root || typeof root !== 'object') { + return; + } + + var view = this, + stateCheckedObserver = function() { + view.currentState.invokeObserver(this, observer); + }, + scheduledObserver = function() { + Ember.run.scheduleOnce('render', this, stateCheckedObserver); + }; + + Ember.addObserver(root, path, target, scheduledObserver); + + this.one('willClearRender', function() { + Ember.removeObserver(root, path, target, scheduledObserver); + }); + } + +}); + +/* + Describe how the specified actions should behave in the various + states that a view can exist in. Possible states: +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 if (id) { $element.attr('id', id); @@ -19391,6 +29528,7 @@ Ember._RenderBuffer.prototype = })(); +<<<<<<< HEAD (function() { /** @@ -19399,6 +29537,13 @@ Ember._RenderBuffer.prototype = */ var get = Ember.get, set = Ember.set, fmt = Ember.String.fmt; +======= + /** + Parse a path and return an object which holds the parsed properties. + + For example a path like "content.isEnabled:enabled:disabled" will return the + following object: +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 /** `Ember.EventDispatcher` handles delegating browser events to their @@ -19406,12 +29551,25 @@ var get = Ember.get, set = Ember.set, fmt = Ember.String.fmt; `Ember.EventDispatcher` ensures that that view's `mouseDown` method gets called. +<<<<<<< HEAD @class EventDispatcher @namespace Ember @private @extends Ember.Object */ Ember.EventDispatcher = Ember.Object.extend(/** @scope Ember.EventDispatcher.prototype */{ +======= + @method _parsePropertyPath + @static + @private + */ + _parsePropertyPath: function(path) { + var split = path.split(':'), + propertyPath = split[0], + classNames = "", + className, + falsyClassName; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 /** The set of events names (and associated handler function names) to be setup @@ -19455,19 +29613,34 @@ Ember.EventDispatcher = Ember.Object.extend(/** @scope Ember.EventDispatcher.pro }, /** +<<<<<<< HEAD @private The root DOM element to which event listeners should be attached. Event listeners will be attached to the document unless this is overridden. +======= + Get the class name for a given value, based on the path, optional + `className` and optional `falsyClassName`. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 Can be specified as a DOMElement or a selector string. +<<<<<<< HEAD The default body is a string since this may be evaluated before document.body exists in the DOM. @property rootElement @type DOMElement @default 'body' +======= + @method _classStringForValue + @param path + @param val + @param className + @param falsyClassName + @static + @private +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 */ rootElement: 'body', @@ -19517,9 +29690,24 @@ Ember.EventDispatcher = Ember.Object.extend(/** @scope Ember.EventDispatcher.pro Registers an event listener on the document. If the given event is triggered, the provided event handler will be triggered on the target view. +<<<<<<< HEAD If the target view does not implement the event handler, or if the handler returns `false`, the parent view will be called. The event will continue to bubble to each successive parent view until it reaches the top. +======= + if (!value) { + elem.removeAttr(name); + } + + if (value !== elem.prop(name)) { + // value and booleans should always be properties + elem.prop(name, value); + } + } else if (!value) { + elem.removeAttr(name); + } +}; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 For example, to have the `mouseDown` method called on the target view when a `mousedown` event is received from the browser, do the following: @@ -19624,12 +29812,53 @@ Ember.EventDispatcher = Ember.Object.extend(/** @scope Ember.EventDispatcher.pro @submodule ember-views */ +<<<<<<< HEAD // Add a new named queue for rendering views that happens // after bindings have synced, and a queue for scheduling actions // that that should occur after view rendering. var queues = Ember.run.queues, indexOf = Ember.ArrayPolyfills.indexOf; queues.splice(indexOf.call(queues, 'actions')+1, 0, 'render', 'afterRender'); +======= +var preRender = Ember.View.states.preRender = Ember.create(Ember.View.states._default); + +Ember.merge(preRender, { + // a view leaves the preRender state once its element has been + // created (createElement). + insertElement: function(view, fn) { + view.createElement(); + var viewCollection = view.viewHierarchyCollection(); + + viewCollection.trigger('willInsertElement'); + + fn.call(view); + + // We transition to `inDOM` if the element exists in the DOM + var element = view.get('element'); + while (element = element.parentNode) { + if (element === document) { + viewCollection.transitionTo('inDOM', false); + viewCollection.trigger('didInsertElement'); + } + } + + }, + + renderToBufferIfNeeded: function(view, buffer) { + view.renderToBuffer(buffer); + return true; + }, + + empty: Ember.K, + + setElement: function(view, value) { + if (value !== null) { + view.transitionTo('hasElement'); + } + return value; + } +}); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 })(); @@ -19682,7 +29911,16 @@ Ember.ControllerMixin.reopen({ (function() { +<<<<<<< HEAD })(); +======= + empty: function() { + Ember.assert("Emptying a view in the inBuffer state is not allowed and " + + "should not happen under normal circumstances. Most likely " + + "there is a bug in your application. This may be due to " + + "excessive property change notifications."); + }, +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 @@ -19866,6 +30104,13 @@ Ember.CoreView = Ember.Object.extend(Ember.Evented, Ember.ActionHandler, { } return method.apply(this, args); } +<<<<<<< HEAD +======= + + view.addBeforeObserver('elementId', function() { + throw new Ember.Error("Changing a view's elementId after creation is not allowed"); + }); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 }, deprecatedSendHandles: function(actionName) { @@ -19973,9 +30218,14 @@ ViewCollection.prototype = { var EMPTY_ARRAY = []; /** +<<<<<<< HEAD `Ember.View` is the class in Ember responsible for encapsulating templates of HTML content, combining templates with data to render as sections of a page's DOM, and registering and responding to user-initiated events. +======= + A `ContainerView` is an `Ember.View` subclass that implements `Ember.MutableArray` + allowing programmatic management of its child views. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 ## HTML Tag @@ -20006,7 +30256,16 @@ var EMPTY_ARRAY = []; }); ``` +<<<<<<< HEAD Will result in view instances with an HTML representation of: +======= + Each child view's rendering will be inserted into the container's rendered + HTML in the same order as its position in the `childViews` property. + + ## Adding and Removing Child Views + + The container view implements `Ember.MutableArray` allowing programmatic management of its child views. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 ```html @@ -20083,6 +30342,7 @@ var EMPTY_ARRAY = []; ``` +<<<<<<< HEAD Class name bindings can also refer to object values that are found by traversing a path relative to the view itself: @@ -20104,6 +30364,21 @@ var EMPTY_ARRAY = []; If you want to add a class name for a property which evaluates to true and and a different class name if it evaluates to false, you can pass a binding like this: +======= + ## Templates and Layout + + A `template`, `templateName`, `defaultTemplate`, `layout`, `layoutName` or + `defaultLayout` property on a container view will not result in the template + or layout being rendered. The HTML contents of a `Ember.ContainerView`'s DOM + representation will only be the rendered HTML of its child views. + + @class ContainerView + @namespace Ember + @extends Ember.View +*/ +Ember.ContainerView = Ember.View.extend(Ember.MutableArray, { + states: states, +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 ```javascript // Applies 'enabled' class when isEnabled is true and 'disabled' when isEnabled is false @@ -20160,6 +30435,7 @@ var EMPTY_ARRAY = []; ## HTML Attributes +<<<<<<< HEAD The HTML attribute section of a view's tag can be set by providing an `attributeBindings` property set to an array of property names on the view. The return value of these properties will be used as the value of the view's @@ -20178,11 +30454,30 @@ var EMPTY_ARRAY = []; ```html ``` +======= + length: Ember.computed(function () { + return this._childViews.length; + }).volatile(), + + /** + Instructs each child view to render to the passed render buffer. + + @private + @method render + @param {Ember.RenderBuffer} buffer the buffer to render to + */ + render: function(buffer) { + this.forEachChildView(function(view) { + view.renderToBuffer(buffer); + }); + }, +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 If the return value of an `attributeBindings` monitored property is a boolean the property will follow HTML's pattern of repeating the attribute's name as its value: +<<<<<<< HEAD ```javascript MyTextInput = Ember.View.extend({ tagName: 'input', @@ -20192,12 +30487,28 @@ var EMPTY_ARRAY = []; ``` Will result in view instances with an HTML representation of: +======= + /** + When a child view is removed, destroy its element so that + it is removed from the DOM. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 ```html ``` +<<<<<<< HEAD `attributeBindings` can refer to computed properties: +======= + @private + @method childViewsWillChange + @param {Ember.Array} views the child views array before mutation + @param {Number} start the start position of the mutation + @param {Number} removed the number of child views removed + **/ + childViewsWillChange: function(views, start, removed) { + this.propertyWillChange('childViews'); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 ```javascript MyTextInput = Ember.View.extend({ @@ -20216,10 +30527,15 @@ var EMPTY_ARRAY = []; Updates to the the property of an attribute binding will result in automatic update of the HTML attribute in the view's rendered HTML representation. +<<<<<<< HEAD `attributeBindings` is a concatenated property. See [Ember.Object](/api/classes/Ember.Object.html) documentation for more information about concatenated properties. ## Templates +======= + /** + When a child view is added, make sure the DOM gets updated appropriately. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 The HTML contents of a view's rendered representation are determined by its template. Templates can be any function that accepts an optional context @@ -20227,11 +30543,29 @@ var EMPTY_ARRAY = []; view's tag. Most typically in Ember this function will be a compiled `Ember.Handlebars` template. +<<<<<<< HEAD ```javascript AView = Ember.View.extend({ template: Ember.Handlebars.compile('I am the template') }); ``` +======= + @private + @method childViewsDidChange + @param {Ember.Array} views the array of child views afte the mutation has occurred + @param {Number} start the start position of the mutation + @param {Number} removed the number of child views removed + @param {Number} the number of child views added + */ + childViewsDidChange: function(views, start, removed, added) { + if (added > 0) { + var changedViews = views.slice(start, start+added); + this.initializeViews(changedViews, this, get(this, 'templateData')); + this.currentState.childViewsDidChange(this, views, start, added); + } + this.propertyDidChange('childViews'); + }, +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 Will result in view instances with an HTML representation of: @@ -20248,6 +30582,7 @@ var EMPTY_ARRAY = []; ``` +<<<<<<< HEAD And associate it by name using a view's `templateName` property: ```javascript @@ -20255,6 +30590,22 @@ var EMPTY_ARRAY = []; templateName: 'some-template' }); ``` +======= + _currentViewWillChange: Ember.beforeObserver('currentView', function() { + var currentView = get(this, 'currentView'); + if (currentView) { + currentView.destroy(); + } + }), + + _currentViewDidChange: Ember.observer('currentView', function() { + var currentView = get(this, 'currentView'); + if (currentView) { + Ember.assert("You tried to set a current view that already has a parent. Make sure you don't have multiple outlets in the same view.", !get(currentView, '_parentView')); + this.pushObject(currentView); + } + }), +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 Using a value for `templateName` that does not have a Handlebars template with a matching `data-template-name` attribute will throw an error. @@ -20265,6 +30616,7 @@ var EMPTY_ARRAY = []; template function. If a template is not later provided for the view instance the `defaultTemplate` value will be used: +<<<<<<< HEAD ```javascript AView = Ember.View.extend({ defaultTemplate: Ember.Handlebars.compile('I was the default'), @@ -20272,6 +30624,13 @@ var EMPTY_ARRAY = []; templateName: null }); ``` +======= +Ember.merge(states.inBuffer, { + childViewsDidChange: function(parentView, views, start, added) { + throw new Ember.Error('You cannot modify child views while in the inBuffer state'); + } +}); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 Will result in instances with an HTML representation of: @@ -20412,8 +30771,16 @@ var EMPTY_ARRAY = []; }); ``` +<<<<<<< HEAD An event defined for an event manager takes precedence over events of the same name handled through methods on the view. +======= + ## Programmatic creation of child views + + For cases where additional customization beyond the use of a single + `itemViewClass` or `tagName` matching is required CollectionView's + `createChildView` method can be overidden: +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 ```javascript AView = Ember.View.extend({ @@ -20471,6 +30838,7 @@ var EMPTY_ARRAY = []; built-in events exists in `Ember.EventDispatcher`.) Additional, custom events can be registered by using `Ember.Application.customEvents`. +<<<<<<< HEAD Touch events: * `touchStart` @@ -20479,6 +30847,15 @@ var EMPTY_ARRAY = []; * `touchCancel` Keyboard events +======= + + @class CollectionView + @namespace Ember + @extends Ember.ContainerView + @since Ember 0.9 +*/ +Ember.CollectionView = Ember.ContainerView.extend({ +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 * `keyDown` * `keyUp` @@ -20486,6 +30863,7 @@ var EMPTY_ARRAY = []; Mouse events +<<<<<<< HEAD * `mouseDown` * `mouseUp` * `contextMenu` @@ -20504,6 +30882,17 @@ var EMPTY_ARRAY = []; * `focusIn` * `focusOut` * `input` +======= + /** + This provides metadata about what kind of empty view class this + collection would like if it is being instantiated from another + system (like Handlebars) + + @private + @property emptyViewClass + */ + emptyViewClass: Ember.View, +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 HTML5 drag and drop events: @@ -20516,6 +30905,7 @@ var EMPTY_ARRAY = []; ## Handlebars `{{view}}` Helper +<<<<<<< HEAD Other `Ember.View` instances can be included as part of a view's template by using the `{{view}}` Handlebars helper. See [Ember.Handlebars.helpers.view](/api/classes/Ember.Handlebars.helpers.html#method_view) for additional information. @@ -20536,11 +30926,51 @@ Ember.View = Ember.CoreView.extend( @final */ isView: true, +======= + /** + Setup a CollectionView + + @method init + */ + init: function() { + var ret = this._super(); + this._contentDidChange(); + return ret; + }, + + /** + Invoked when the content property is about to change. Notifies observers that the + entire array content will change. + + @private + @method _contentWillChange + */ + _contentWillChange: Ember.beforeObserver('content', function() { + var content = this.get('content'); + + if (content) { content.removeArrayObserver(this); } + var len = content ? get(content, 'length') : 0; + this.arrayWillChange(content, 0, len); + }), + + /** + Check to make sure that the content has changed, and if so, + update the children directly. This is always scheduled + asynchronously, to allow the element to be created before + bindings have synchronized and vice versa. + + @private + @method _contentDidChange + */ + _contentDidChange: Ember.observer('content', function() { + var content = get(this, 'content'); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 // .......................................................... // TEMPLATE SUPPORT // +<<<<<<< HEAD /** The name of the template to lookup if no template is provided. @@ -20552,6 +30982,29 @@ Ember.View = Ember.CoreView.extend( @default null */ templateName: null, +======= + var len = content ? get(content, 'length') : 0; + this.arrayDidChange(content, 0, null, len); + }), + + /** + Ensure that the content implements Ember.Array + + @private + @method _assertArrayLike + */ + _assertArrayLike: function(content) { + Ember.assert(fmt("an Ember.CollectionView's content must implement Ember.Array. You passed %@", [content]), Ember.Array.detect(content)); + }, + + /** + Removes the content and content observers. + + @method destroy + */ + destroy: function() { + if (!this._super()) { return; } +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 /** The name of the layout to lookup if no layout is provided. @@ -20566,9 +31019,31 @@ Ember.View = Ember.CoreView.extend( layoutName: null, /** +<<<<<<< HEAD The template used to render the view. This should be a function that accepts an optional context parameter and returns a string of HTML that will be inserted into the DOM relative to its parent view. +======= + Called when a mutation to the underlying content array will occur. + + This method will remove any views that are no longer in the underlying + content array. + + Invokes whenever the content array itself will change. + + @method arrayWillChange + @param {Array} content the managed collection of objects + @param {Number} start the index at which the changes will occurr + @param {Number} removed number of object to be removed from content + */ + arrayWillChange: function(content, start, removedCount) { + // If the contents were empty before and this template collection has an + // empty view remove it now. + var emptyView = get(this, 'emptyView'); + if (emptyView && emptyView instanceof Ember.View) { + emptyView.removeFromParent(); + } +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 In general, you should set the `templateName` property instead of setting the template yourself. @@ -20674,10 +31149,30 @@ Ember.View = Ember.CoreView.extend( checks to see whether the view has a specified controller. This is something of a hack and should be revisited. +<<<<<<< HEAD @property _context */ _context: Ember.computed(function(key) { var parentView, controller; +======= + /** + Instantiates a view to be added to the childViews array during view + initialization. You generally will not call this method directly unless + you are overriding `createChildViews()`. Note that this method will + automatically configure the correct settings on the new view instance to + act as a child of the parent. + + The tag name for the view will be set to the tagName of the viewClass + passed in. + + @method createChildView + @param {Class} viewClass + @param {Hash} [attrs] Attributes to add + @return {Ember.View} new instance + */ + createChildView: function(view, attrs) { + view = this._super(view, attrs); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 if (controller = get(this, 'controller')) { return controller; @@ -20697,20 +31192,37 @@ Ember.View = Ember.CoreView.extend( If a value that affects template rendering changes, the view should be re-rendered to reflect the new value. +<<<<<<< HEAD @method _contextDidChange */ _contextDidChange: Ember.observer('context', function() { this.rerender(); }), +======= +(function() { +var get = Ember.get, set = Ember.set, isNone = Ember.isNone, + a_slice = Array.prototype.slice; + +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 /** If `false`, the view will appear hidden in DOM. +<<<<<<< HEAD @property isVisible @type Boolean @default null */ isVisible: true, +======= +/** + An `Ember.Component` is a view that is completely + isolated. Property access in its templates go + to the view object and actions are targeted at + the view object. There is no access to the + surrounding context or outer controller; all + contextual information must be passed in. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 /** @private @@ -20718,6 +31230,7 @@ Ember.View = Ember.CoreView.extend( Array of child views. You should never edit this array directly. Instead, use `appendChild` and `removeFromParent`. +<<<<<<< HEAD @property childViews @type Array @default [] @@ -20747,6 +31260,39 @@ Ember.View = Ember.CoreView.extend( /** Return the nearest ancestor that is an instance of the provided class. +======= + ```html + + {{person.title}}
++
{{person.signature}}
+ ``` + + You can use `yield` inside a template to + include the **contents** of any block attached to + the component. The block will be executed in the + context of the surrounding context or outer controller: + + ```handlebars + {{#app-profile person=currentUser}} +Admin mode
+ {{! Executed in the controllers context. }} + {{/app-profile}} + ``` + + ```handlebars + +{{person.title}}
+ {{! Executed in the components context. }} + {{yield}} {{! block contents }} + ``` + + If you want to customize the component, in order to + handle events or actions, you implement a subclass + of `Ember.Component` named after the name of the + component. Note that `Component` needs to be appended to the name of + your subclass like `AppProfileComponent`. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 @property nearestInstanceOf @param {Class} klass Subclass of Ember.View (or Ember.View itself) @@ -20757,9 +31303,18 @@ Ember.View = Ember.CoreView.extend( Ember.deprecate("nearestInstanceOf is deprecated and will be removed from future releases. Use nearestOfType."); var view = get(this, 'parentView'); +<<<<<<< HEAD while (view) { if (view instanceof klass) { return view; } view = get(view, 'parentView'); +======= + ```javascript + App.AppProfileComponent = Ember.Component.extend({ + actions: { + hello: function(name) { + console.log("Hello", name); + } +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 } }, @@ -20794,10 +31349,24 @@ Ember.View = Ember.CoreView.extend( nearestWithProperty: function(property) { var view = get(this, 'parentView'); +<<<<<<< HEAD while (view) { if (property in view) { return view; } view = get(view, 'parentView'); } +======= + defaultLayout: function(options){ + options.data = {view: options._context}; + Ember.Handlebars.helpers['yield'].apply(this, [options]); + }, + + // during render, isolate keywords + cloneKeywords: function() { + return { + view: this, + controller: this + }; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 }, /** @@ -20811,6 +31380,7 @@ Ember.View = Ember.CoreView.extend( nearestChildOf: function(klass) { var view = get(this, 'parentView'); +<<<<<<< HEAD while (view) { if (get(view, 'parentView') instanceof klass) { return view; } view = get(view, 'parentView'); @@ -20859,11 +31429,136 @@ Ember.View = Ember.CoreView.extend( Called on your view when it should push strings of HTML into a `Ember.RenderBuffer`. Most users will want to override the `template` or `templateName` properties instead of this method. +======= + view.appendChild(Ember.View, { + isVirtual: true, + tagName: '', + _contextView: parentView, + template: template, + context: get(parentView, 'context'), + controller: get(parentView, 'controller'), + templateData: { keywords: parentView.cloneKeywords() } + }); + } + }, + + /** + If the component is currently inserted into the DOM of a parent view, this + property will point to the controller of the parent view. + + @property targetObject + @type Ember.Controller + @default null + */ + targetObject: Ember.computed(function(key) { + var parentView = get(this, '_parentView'); + return parentView ? get(parentView, 'controller') : null; + }).property('_parentView'), + + /** + Triggers a named action on the controller context where the component is used if + this controller has registered for notifications of the action. + + For example a component for playing or pausing music may translate click events + into action notifications of "play" or "stop" depending on some internal state + of the component: + + + ```javascript + App.PlayButtonComponent = Ember.Component.extend({ + click: function(){ + if (this.get('isPlaying')) { + this.triggerAction('play'); + } else { + this.triggerAction('stop'); + } + } + }); + ``` + + When used inside a template these component actions are configured to + trigger actions in the outer application context: + + ```handlebars + {{! application.hbs }} + {{play-button play="musicStarted" stop="musicStopped"}} + ``` + + When the component receives a browser `click` event it translate this + interaction into application-specific semantics ("play" or "stop") and + triggers the specified action name on the controller for the template + where the component is used: + + + ```javascript + App.ApplicationController = Ember.Controller.extend({ + actions: { + musicStarted: function(){ + // called when the play button is clicked + // and the music started playing + }, + musicStopped: function(){ + // called when the play button is clicked + // and the music stopped playing + } + } + }); + ``` + + If no action name is passed to `sendAction` a default name of "action" + is assumed. + + ```javascript + App.NextButtonComponent = Ember.Component.extend({ + click: function(){ + this.sendAction(); + } + }); + ``` + + ```handlebars + {{! application.hbs }} + {{next-button action="playNextSongInAlbum"}} + ``` + + ```javascript + App.ApplicationController = Ember.Controller.extend({ + actions: { + playNextSongInAlbum: function(){ + ... + } + } + }); + ``` + + @method sendAction + @param [action] {String} the action to trigger + @param [context] {*} a context to send with the action + */ + sendAction: function(action) { + var actionName, + contexts = a_slice.call(arguments, 1); + + // Send the default action + if (action === undefined) { + actionName = get(this, 'action'); + Ember.assert("The default action was triggered on the component " + this.toString() + + ", but the action name (" + actionName + ") was not a string.", + isNone(actionName) || typeof actionName === 'string'); + } else { + actionName = get(this, action); + Ember.assert("The " + action + " action was triggered on the component " + + this.toString() + ", but the action name (" + actionName + + ") was not a string.", + isNone(actionName) || typeof actionName === 'string'); + } +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 By default, `Ember.View` will look for a function in the `template` property and invoke it with the value of `context`. The value of `context` will be the view's controller unless you override it. +<<<<<<< HEAD @method render @param {Ember.RenderBuffer} buffer The render buffer */ @@ -20872,6 +31567,16 @@ Ember.View = Ember.CoreView.extend( // the layout to render the view's template. Otherwise, render the template // directly. var template = get(this, 'layout') || get(this, 'template'); +======= + this.triggerAction({ + action: actionName, + actionContext: contexts + }); + } +}); + +})(); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 if (template) { var context = get(this, 'context'); @@ -21001,6 +31706,7 @@ Ember.View = Ember.CoreView.extend( oldClass = dasherizedClass; } +<<<<<<< HEAD this.registerObserver(this, parsedPath.path, observer); // Remove className so when the view is rerendered, // the className is added based on binding reevaluation @@ -21013,6 +31719,29 @@ Ember.View = Ember.CoreView.extend( }, this); }, +======= +(function() { +define("metamorph", + [], + function() { + "use strict"; + // ========================================================================== + // Project: metamorph + // Copyright: ©2014 Tilde, Inc. All rights reserved. + // ========================================================================== + + var K = function() {}, + guid = 0, + disableRange = (function(){ + if ('undefined' !== typeof MetamorphENV) { + return MetamorphENV.DISABLE_RANGE_API; + } else if ('undefined' !== ENV) { + return ENV.DISABLE_RANGE_API; + } else { + return false; + } + })(), +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 /** @private @@ -21113,10 +31842,25 @@ Ember.View = Ember.CoreView.extend( idx = childViews.length, view; +<<<<<<< HEAD while(--idx >= 0) { view = childViews[idx]; callback(this, view, idx); } +======= + /** + * @public + * + * Remove this object (including starting and ending + * placeholders). + * + * @method remove + */ + removeFunc = function() { + // get a range for the current metamorph object including + // the starting and ending placeholders. + var range = rangeFor(this, true); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 return this; }, @@ -21143,9 +31887,31 @@ Ember.View = Ember.CoreView.extend( If the view does not have an HTML representation yet, `createElement()` will be called automatically. +<<<<<<< HEAD Note that this method just schedules the view to be appended; the DOM element will not be appended to the given element until all bindings have finished synchronizing. +======= + } else { + /* + * This code is mostly taken from jQuery, with one exception. In jQuery's case, we + * have some HTML and we need to figure out how to convert it into some nodes. + * + * In this case, jQuery needs to scan the HTML looking for an opening tag and use + * that as the key for the wrap map. In our case, we know the parent node, and + * can use its type as the key for the wrap map. + **/ + var wrapMap = { + select: [ 1, "" ], + fieldset: [ 1, "" ], + table: [ 1, "", "
" ], + tbody: [ 2, "", "
" ], + tr: [ 3, "
" ], + colgroup: [ 2, "", "
" ], + map: [ 1, "" ], + _default: [ 0, "", "" ] + }; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 This is not typically a function that you will need to call directly when building your application. You might consider using `Ember.ContainerView` @@ -21178,6 +31944,7 @@ Ember.View = Ember.CoreView.extend( element will not be appended to the given element until all bindings have finished synchronizing +<<<<<<< HEAD @method replaceIn @param {String|DOMElement|jQuery} A selector, element, HTML string, or jQuery object @return {Ember.View} received @@ -21185,6 +31952,17 @@ Ember.View = Ember.CoreView.extend( replaceIn: function(target) { Ember.assert("You tried to replace in (" + target + ") but that isn't in the DOM", Ember.$(target).length > 0); Ember.assert("You cannot replace an existing Ember.View. Consider using Ember.ContainerView instead.", !Ember.$(target).is('.ember-view') && !Ember.$(target).parents().is('.ember-view')); +======= + /* + * Given a parent node and some HTML, generate a set of nodes. Return the first + * node, which will allow us to traverse the rest using nextSibling. + * + * We need to do this because innerHTML in IE does not really parse the nodes. + */ + var firstNodeFor = function(parentNode, html) { + var arr = wrapMap[parentNode.tagName.toLowerCase()] || wrapMap._default; + var depth = arr[0], start = arr[1], end = arr[2]; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 this._insertElementLater(function() { Ember.$(target).empty(); @@ -24070,6 +34848,10 @@ define("metamorph", // swallow some of the content. node = firstNodeFor(start.parentNode, html); + if (outerToo) { + start.parentNode.removeChild(start); + } + // copy the nodes for the HTML between the starting and ending // placeholder. while (node) { @@ -24194,13 +34976,24 @@ var objectCreate = Object.create || function(parent) { return new F(); }; -var Handlebars = this.Handlebars || (Ember.imports && Ember.imports.Handlebars); +var Handlebars = (Ember.imports && Ember.imports.Handlebars) || (this && this.Handlebars); if (!Handlebars && typeof require === 'function') { Handlebars = require('handlebars'); } +<<<<<<< HEAD Ember.assert("Ember Handlebars requires Handlebars version 1.0 or 1.1. Include a SCRIPT tag in the HTML HEAD linking to the Handlebars file before you link to Ember.", Handlebars); Ember.assert("Ember Handlebars requires Handlebars version 1.0 or 1.1, COMPILER_REVISION expected: 4, got: " + Handlebars.COMPILER_REVISION + " - Please note: Builds of master may have other COMPILER_REVISION values.", Handlebars.COMPILER_REVISION === 4); +======= +Ember.assert("Ember Handlebars requires Handlebars version 1.0 or 1.1. Include " + + "a SCRIPT tag in the HTML HEAD linking to the Handlebars file " + + "before you link to Ember.", Handlebars); + +Ember.assert("Ember Handlebars requires Handlebars version 1.0 or 1.1, " + + "COMPILER_REVISION expected: 4, got: " + Handlebars.COMPILER_REVISION + + " - Please note: Builds of master may have other COMPILER_REVISION values.", + Handlebars.COMPILER_REVISION === 4); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 /** Prepares the Handlebars templating library for use inside Ember's view @@ -24282,20 +35075,31 @@ Ember.Handlebars.helper = function(name, value) { }; /** +<<<<<<< HEAD @private +======= +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 Returns a helper function that renders the provided ViewClass. Used internally by Ember.Handlebars.helper and other methods involving helper/component registration. +<<<<<<< HEAD +======= + @private +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 @method helper @for Ember.Handlebars @param {Function} ViewClass view class constructor */ Ember.Handlebars.makeViewHelper = function(ViewClass) { return function(options) { +<<<<<<< HEAD Ember.assert("You can only pass attributes (such as name=value) not bare values to a helper for a View", arguments.length < 2); +======= + Ember.assert("You can only pass attributes (such as name=value) not bare values to a helper for a View found in '" + ViewClass.toString() + "'", arguments.length < 2); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 return Ember.Handlebars.helpers.view.call(this, ViewClass, options); }; }; @@ -24345,12 +35149,11 @@ Ember.Handlebars.JavaScriptCompiler.prototype.initializeBuffer = function() { }; /** - @private - Override the default buffer for Ember Handlebars. By default, Handlebars creates an empty String at the beginning of each invocation and appends to it. Ember's Handlebars overrides this to append to a single shared buffer. + @private @method appendToBuffer @param string {String} */ @@ -24368,7 +35171,11 @@ Ember.Handlebars.JavaScriptCompiler.prototype.appendToBuffer = function(string) // instead, as expected. // // This can go away once the following is closed: +<<<<<<< HEAD // https://github.com/wycats/handlebars.js/issues/617 +======= +// https://github.com/wycats/handlebars.js/issues/634 +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 var DOT_LOOKUP_REGEX = /helpers\.(.*?)\)/, BRACKET_STRING_LOOKUP_REGEX = /helpers\['(.*?)'/, @@ -24398,12 +35205,11 @@ Ember.Handlebars.JavaScriptCompiler.prototype.ambiguousBlockValue = function() { var prefix = "ember" + (+new Date()), incr = 1; /** - @private - Rewrite simple mustaches from `{{foo}}` to `{{bind "foo"}}`. This means that all simple mustaches in Ember's Handlebars will also set up an observer to keep the DOM up to date when the underlying property changes. + @private @method mustache @for Ember.Handlebars.Compiler @param mustache @@ -24446,7 +35252,7 @@ Ember.Handlebars.precompile = function(string) { knownHelpers: { action: true, unbound: true, - bindAttr: true, + 'bind-attr': true, template: true, view: true, _triageMustache: true @@ -24493,11 +35299,10 @@ var slice = Array.prototype.slice, originalTemplate = Ember.Handlebars.template; /** - @private - If a path starts with a reserved keyword, returns the root that should be used. + @private @method normalizePath @for Ember @param root {Object} @@ -24551,19 +35356,17 @@ var handlebarsGet = Ember.Handlebars.get = function(root, path, options) { normalizedPath = normalizePath(root, path, data), value; - // In cases where the path begins with a keyword, change the - // root to the value represented by that keyword, and ensure - // the path is relative to it. - root = normalizedPath.root; - path = normalizedPath.path; + + root = normalizedPath.root; + path = normalizedPath.path; - value = Ember.get(root, path); + value = Ember.get(root, path); + + if (value === undefined && root !== Ember.lookup && Ember.isGlobalPath(path)) { + value = Ember.get(Ember.lookup, path); + } + - // If the path starts with a capital letter, look it up on Ember.lookup, - // which defaults to the `window` object in browsers. - if (value === undefined && root !== Ember.lookup && Ember.isGlobalPath(path)) { - value = Ember.get(Ember.lookup, path); - } return value; }; @@ -24603,8 +35406,6 @@ Ember.Handlebars.resolveHash = function(context, hash, options) { }; /** - @private - Registers a helper in Handlebars that will be called if no property with the given name can be found on the current context object, and no helper with that name is registered. @@ -24612,6 +35413,7 @@ Ember.Handlebars.resolveHash = function(context, hash, options) { This throws an exception with a more helpful error message so the user can track down where the problem is happening. + @private @method helperMissing @for Ember.Handlebars.helpers @param {String} path @@ -24622,6 +35424,7 @@ Ember.Handlebars.registerHelper('helperMissing', function(path) { var options = arguments[arguments.length - 1]; +<<<<<<< HEAD var helper = Ember.Handlebars.resolveHelper(options.data.view.container, path); @@ -24630,6 +35433,13 @@ Ember.Handlebars.registerHelper('helperMissing', function(path) { return helper.apply(this, slice.call(arguments, 1)); } +======= + var helper = Ember.Handlebars.resolveHelper(options.data.view.container, path); + + if (helper) { + return helper.apply(this, slice.call(arguments, 1)); + } +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 error = "%@ Handlebars error: Could not find property '%@' on object %@."; if (options.data) { @@ -24639,8 +35449,11 @@ Ember.Handlebars.registerHelper('helperMissing', function(path) { }); /** +<<<<<<< HEAD @private +======= +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 Registers a helper in Handlebars that will be called if no property with the given name can be found on the current context object, and no helper with that name is registered. @@ -24648,6 +35461,10 @@ Ember.Handlebars.registerHelper('helperMissing', function(path) { This throws an exception with a more helpful error message so the user can track down where the problem is happening. +<<<<<<< HEAD +======= + @private +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 @method helperMissing @for Ember.Handlebars.helpers @param {String} path @@ -24657,6 +35474,7 @@ Ember.Handlebars.registerHelper('blockHelperMissing', function(path) { var options = arguments[arguments.length - 1]; +<<<<<<< HEAD Ember.assert("`blockHelperMissing` was invoked without a helper name, which is most likely due to a mismatch between the version of Ember.js you're running now and the one used to precompile your templates. Please make sure the version of `ember-handlebars-compiler` you're using is up to date.", path); @@ -24667,6 +35485,21 @@ Ember.Handlebars.registerHelper('blockHelperMissing', function(path) { return helper.apply(this, slice.call(arguments, 1)); } +======= + Ember.assert("`blockHelperMissing` was invoked without a helper name, which " + + "is most likely due to a mismatch between the version of " + + "Ember.js you're running now and the one used to precompile your " + + "templates. Please make sure the version of " + + "`ember-handlebars-compiler` you're using is up to date.", path); + + var helper = Ember.Handlebars.resolveHelper(options.data.view.container, path); + + if (helper) { + return helper.apply(this, slice.call(arguments, 1)); + } else { + return Handlebars.helpers.helperMissing.call(this, path); + } +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 return Handlebars.helpers.blockHelperMissing.apply(this, arguments); }); @@ -24787,8 +35620,11 @@ Ember.Handlebars.registerBoundHelper = function(name, fn) { }; /** +<<<<<<< HEAD @private +======= +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 A (mostly) private helper function to `registerBoundHelper`. Takes the provided Handlebars helper function fn and returns it in wrapped bound helper form. @@ -24807,6 +35643,10 @@ Ember.Handlebars.registerBoundHelper = function(name, fn) { In the above example, if the helper function hadn't been wrapped in `makeBoundHelper`, the registered helper would be unbound. +<<<<<<< HEAD +======= + @private +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 @method makeBoundHelper @for Ember.Handlebars @param {Function} function @@ -24822,6 +35662,7 @@ Ember.Handlebars.makeBoundHelper = function(fn) { normalizedProperties = [], types = options.types, data = options.data, + types = data.isUnbound ? slice.call(options.types, 1) : options.types, hash = options.hash, view = data.view, contexts = options.contexts, @@ -24852,7 +35693,15 @@ Ember.Handlebars.makeBoundHelper = function(fn) { normalizedProperties.push(normalizedProp); watchedProperties.push(normalizedProp); } else { +<<<<<<< HEAD normalizedProperties.push(null); +======= + if(data.isUnbound) { + normalizedProperties.push({path: properties[loc]}); + }else { + normalizedProperties.push(null); + } +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 } } @@ -24930,10 +35779,12 @@ Ember.Handlebars.makeBoundHelper = function(fn) { }; /** - @private - Renders the unbound form of an otherwise bound helper function. +<<<<<<< HEAD +======= + @private +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 @method evaluateUnboundHelper @param {Function} fn @param {Object} context @@ -24941,7 +35792,15 @@ Ember.Handlebars.makeBoundHelper = function(fn) { @param {String} options */ function evaluateUnboundHelper(context, fn, normalizedProperties, options) { - var args = [], hash = options.hash, boundOptions = hash.boundOptions, loc, len, property, boundOption; + var args = [], + hash = options.hash, + boundOptions = hash.boundOptions, + types = slice.call(options.types, 1), + loc, + len, + property, + propertyType, + boundOption; for (boundOption in boundOptions) { if (!boundOptions.hasOwnProperty(boundOption)) { continue; } @@ -24950,18 +35809,26 @@ function evaluateUnboundHelper(context, fn, normalizedProperties, options) { for(loc = 0, len = normalizedProperties.length; loc < len; ++loc) { property = normalizedProperties[loc]; +<<<<<<< HEAD args.push(Ember.Handlebars.get(property.root, property.path, options)); +======= + propertyType = types[loc]; + if(propertyType === "ID") { + args.push(Ember.Handlebars.get(property.root, property.path, options)); + } else { + args.push(property.path); + } +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 } args.push(options); return fn.apply(context, args); } /** - @private - Overrides Handlebars.template so that we can distinguish user-created, top-level templates from inner contexts. + @private @method template @for Ember.Handlebars @param {String} spec @@ -25081,7 +35948,7 @@ var DOMManager = { view.transitionTo('preRender'); - Ember.run.schedule('render', this, function() { + Ember.run.schedule('render', this, function renderMetamorphView() { if (view.isDestroying) { return; } view.clearRenderedChildren(); @@ -25513,6 +36380,7 @@ Ember._HandlebarsBoundView = Ember._MetamorphView.extend({ var get = Ember.get, set = Ember.set, fmt = Ember.String.fmt; var handlebarsGet = Ember.Handlebars.get, normalizePath = Ember.Handlebars.normalizePath; var forEach = Ember.ArrayPolyfills.forEach; +var o_create = Ember.create; var EmberHandlebars = Ember.Handlebars, helpers = EmberHandlebars.helpers; @@ -25643,8 +36511,11 @@ function simpleBind(currentContext, property, options) { } /** +<<<<<<< HEAD @private +======= +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 '_triageMustache' is used internally select between a binding, helper, or component for the given context. Until this point, it would be hard to determine if the mustache is a property reference or a regular helper reference. This triage @@ -25652,6 +36523,7 @@ function simpleBind(currentContext, property, options) { This would not be typically invoked by directly. + @private @method _triageMustache @for Ember.Handlebars.helpers @param {String} property Property/helperID to triage @@ -25663,6 +36535,7 @@ EmberHandlebars.registerHelper('_triageMustache', function(property, options) { if (helpers[property]) { return helpers[property].call(this, options); +<<<<<<< HEAD } @@ -25676,6 +36549,37 @@ EmberHandlebars.registerHelper('_triageMustache', function(property, options) { return helpers.bind.call(this, property, options); }); +Ember.Handlebars.resolveHelper = function(container, name) { + + if (!container || name.indexOf('-') === -1) { + return; + } + + var helper = container.lookup('helper:' + name); + if (!helper) { + var componentLookup = container.lookup('component-lookup:main'); + Ember.assert("Could not find 'component-lookup:main' on the provided container, which is necessary for performing component lookups", componentLookup); + + var Component = componentLookup.lookupFactory(name, container); + if (Component) { + helper = EmberHandlebars.makeViewHelper(Component); + container.register('helper:' + name, helper); + } + } + return helper; +}; +======= + } + + var helper = Ember.Handlebars.resolveHelper(options.data.view.container, property); + if (helper) { + return helper.call(this, options); + } + + return helpers.bind.call(this, property, options); +}); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + Ember.Handlebars.resolveHelper = function(container, name) { if (!container || name.indexOf('-') === -1) { @@ -25697,8 +36601,6 @@ Ember.Handlebars.resolveHelper = function(container, name) { }; /** - @private - `bind` can be used to display a value, then update that value if it changes. For example, if you wanted to print the `title` property of `content`: @@ -25714,13 +36616,14 @@ Ember.Handlebars.resolveHelper = function(container, name) { relies on Ember's KVO system. For all other browsers this will be handled for you automatically. + @private @method bind @for Ember.Handlebars.helpers @param {String} property Property to bind @param {Function} fn Context to provide for rendering @return {String} HTML string */ -EmberHandlebars.registerHelper('bind', function(property, options) { +EmberHandlebars.registerHelper('bind', function bindHelper(property, options) { Ember.assert("You cannot pass more than one argument to the bind helper", arguments.length <= 2); var context = (options.contexts && options.contexts.length) ? options.contexts[0] : this; @@ -25733,8 +36636,6 @@ EmberHandlebars.registerHelper('bind', function(property, options) { }); /** - @private - Use the `boundIf` helper to create a conditional that re-evaluates whenever the truthiness of the bound value changes. @@ -25744,13 +36645,18 @@ EmberHandlebars.registerHelper('bind', function(property, options) { {{/boundIf}} ``` + @private @method boundIf @for Ember.Handlebars.helpers @param {String} property Property to bind @param {Function} fn Context to provide for rendering @return {String} HTML string */ +<<<<<<< HEAD EmberHandlebars.registerHelper('boundIf', function(property, fn) { +======= +EmberHandlebars.registerHelper('boundIf', function boundIfHelper(property, fn) { +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 var context = (fn.contexts && fn.contexts.length) ? fn.contexts[0] : this; var func = function(result) { var truthy = result && get(result, 'isTruthy'); @@ -25767,15 +36673,65 @@ EmberHandlebars.registerHelper('boundIf', function(property, fn) { }); /** + Use the `{{with}}` helper when you want to scope context. Take the following code as an example: + + ```handlebars +", " {{user.name}}
+ +++ ``` + + `{{with}}` can be our best friend in these cases, + instead of writing `user.role.*` over and over, we use `{{#with user.role}}`. + Now the context within the `{{#with}} .. {{/with}}` block is `user.role` so you can do the following: + + ```handlebars +{{user.role.label}}
+ {{user.role.id}} + +{{user.role.description}}
+{{user.name}}
+ ++ {{#with user.role}} ++ ``` + + ### `as` operator + + This operator aliases the scope to a new name. It's helpful for semantic clarity and to retain + default scope or to reference from another `{{with}}` block. + + ```handlebars + // posts might not be + {{#with user.posts as blogPosts}} +{{label}}
+ {{id}} + +{{description}}
+ {{/with}} ++ There are {{blogPosts.length}} blog posts written by {{user.name}}. ++ + {{#each post in blogPosts}} +" + ``` + @method debugger @for Ember.Handlebars.helpers @param {String} property */ -Ember.Handlebars.registerHelper('debugger', function(options) { +Ember.Handlebars.registerHelper('debugger', function debuggerHelper(options) { + + // These are helpful values you can inspect while debugging. + var templateContext = this; + var typeOfTemplateContext = Ember.inspect(templateContext); + debugger; }); + + })(); @@ -27262,7 +38280,7 @@ GroupedEach.prototype = { @param [options.itemController] {String} name of a controller to be created for each item @param [options.groupedRows] {boolean} enable normal item-by-item rendering when inside a `#group` helper */ -Ember.Handlebars.registerHelper('each', function(path, options) { +Ember.Handlebars.registerHelper('each', function eachHelper(path, options) { if (arguments.length === 4) { Ember.assert("If you pass more than one argument to the each helper, it must be in the form #each foo in bar", arguments[1] === "in"); @@ -27410,7 +38428,11 @@ Ember.Handlebars.registerHelper('template', function(name, options) { @param {String} partialName the name of the template to render minus the leading underscore */ +<<<<<<< HEAD Ember.Handlebars.registerHelper('partial', function(name, options) { +======= +Ember.Handlebars.registerHelper('partial', function partialHelper(name, options) { +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 var context = (options.contexts && options.contexts.length) ? options.contexts[0] : this; @@ -27546,7 +38568,7 @@ var get = Ember.get, set = Ember.set; @param {Hash} options @return {String} HTML string */ -Ember.Handlebars.registerHelper('yield', function(options) { +Ember.Handlebars.registerHelper('yield', function yieldHelper(options) { var view = options.data.view; while (view && !get(view, 'layout')) { @@ -27590,7 +38612,7 @@ Ember.Handlebars.registerHelper('yield', function(options) { @param {String} str The string to format */ -Ember.Handlebars.registerHelper('loc', function(str) { +Ember.Handlebars.registerHelper('loc', function locHelper(str) { return Ember.String.loc(str); }); @@ -27622,7 +38644,11 @@ var set = Ember.set, get = Ember.get; The internal class used to create text inputs when the `{{input}}` helper is used with `type` of `checkbox`. +<<<<<<< HEAD See Handlebars.helpers.input for usage details. +======= + See [handlebars.helpers.input](/api/classes/Ember.Handlebars.helpers.html#method_input) for usage details. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 ## Direct manipulation of `checked` @@ -27870,7 +38896,11 @@ var get = Ember.get, set = Ember.set; The internal class used to create text inputs when the `{{input}}` helper is used with `type` of `text`. +<<<<<<< HEAD See [handlebars.helpers.input](Ember.Handlebars.helpers.html#method_input) for usage details. +======= + See [Handlebars.helpers.input](/api/classes/Ember.Handlebars.helpers.html#method_input) for usage details. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 ## Layout and LayoutName properties @@ -27883,8 +38913,12 @@ var get = Ember.get, set = Ember.set; @extends Ember.Component @uses Ember.TextSupport */ +<<<<<<< HEAD Ember.TextField = Ember.Component.extend(Ember.TextSupport, /** @scope Ember.TextField.prototype */ { +======= +Ember.TextField = Ember.Component.extend(Ember.TextSupport, { +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 classNames: ['ember-text-field'], tagName: "input", @@ -27906,6 +38940,7 @@ Ember.TextField = Ember.Component.extend(Ember.TextSupport, @property type @type String @default "text" +<<<<<<< HEAD */ type: "text", @@ -27925,6 +38960,27 @@ Ember.TextField = Ember.Component.extend(Ember.TextSupport, @type String @default null */ +======= + */ + type: "text", + + /** + The `size` of the text field in characters. + + @property size + @type String + @default null + */ + size: null, + + /** + The `pattern` the pattern attribute of input element. + + @property pattern + @type String + @default null + */ +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 pattern: null }); @@ -28439,9 +39495,7 @@ Ember.SelectOptgroup = Ember.CollectionView.extend({ @namespace Ember @extends Ember.View */ -Ember.Select = Ember.View.extend( - /** @scope Ember.Select.prototype */ { - +Ember.Select = Ember.View.extend({ tagName: 'select', classNames: ['ember-select'], defaultTemplate: Ember.Handlebars.template(function anonymous(Handlebars,depth0,helpers,partials,data) { @@ -28451,11 +39505,16 @@ helpers = this.merge(helpers, Ember.Handlebars.helpers); data = data || {}; function program1(depth0,data) { +<<<<<<< HEAD var buffer = '', hashTypes, hashContexts; +======= + var buffer = '', stack1, hashTypes, hashContexts; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 data.buffer.push(""); return buffer; } @@ -29058,10 +40117,288 @@ Ember.Handlebars.registerHelper('input', function(options) { {{textarea value=twoWayWrittenWords}} ``` +<<<<<<< HEAD +======= +(function() { +/** +@module ember +@submodule ember-handlebars-compiler +*/ + +/** + + The `{{input}}` helper inserts an HTML `` tag into the template, + with a `type` value of either `text` or `checkbox`. If no `type` is provided, + `text` will be the default value applied. The attributes of `{{input}}` + match those of the native HTML tag as closely as possible for these two types. + + ## Use as text field + An `{{input}}` with no `type` or a `type` of `text` will render an HTML text input. + The following HTML attributes can be set via the helper: + +* `value` +* `size` +* `name` +* `pattern` +* `placeholder` +* `disabled` +* `maxlength` +* `tabindex` + + + When set to a quoted string, these values will be directly applied to the HTML + element. When left unquoted, these values will be bound to a property on the + template's current rendering context (most typically a controller instance). + + ## Unbound: + + ```handlebars + {{input value="http://www.facebook.com"}} + ``` + + + ```html + + ``` + + ## Bound: + + ```javascript + App.ApplicationController = Ember.Controller.extend({ + firstName: "Stanley", + entryNotAllowed: true + }); + ``` + + + ```handlebars + {{input type="text" value=firstName disabled=entryNotAllowed size="50"}} + ``` + + + ```html + + ``` + + ## Extension + + Internally, `{{input type="text"}}` creates an instance of `Ember.TextField`, passing + arguments from the helper to `Ember.TextField`'s `create` method. You can extend the + capablilties of text inputs in your applications by reopening this class. For example, + if you are deploying to browsers where the `required` attribute is used, you + can add this to the `TextField`'s `attributeBindings` property: + + + ```javascript + Ember.TextField.reopen({ + attributeBindings: ['required'] + }); + ``` + + Keep in mind when writing `Ember.TextField` subclasses that `Ember.TextField` + itself extends `Ember.Component`, meaning that it does NOT inherit + the `controller` of the parent view. + + See more about [Ember components](api/classes/Ember.Component.html) + + + ## Use as checkbox + + An `{{input}}` with a `type` of `checkbox` will render an HTML checkbox input. + The following HTML attributes can be set via the helper: + +* `checked` +* `disabled` +* `tabindex` +* `indeterminate` +* `name` + + + When set to a quoted string, these values will be directly applied to the HTML + element. When left unquoted, these values will be bound to a property on the + template's current rendering context (most typically a controller instance). + + ## Unbound: + + ```handlebars + {{input type="checkbox" name="isAdmin"}} + ``` + + ```html + + ``` + + ## Bound: + + ```javascript + App.ApplicationController = Ember.Controller.extend({ + isAdmin: true + }); + ``` + + + ```handlebars + {{input type="checkbox" checked=isAdmin }} + ``` + + + ```html + + ``` + + ## Extension + + Internally, `{{input type="checkbox"}}` creates an instance of `Ember.Checkbox`, passing + arguments from the helper to `Ember.Checkbox`'s `create` method. You can extend the + capablilties of checkbox inputs in your applications by reopening this class. For example, + if you wanted to add a css class to all checkboxes in your application: + + + ```javascript + Ember.Checkbox.reopen({ + classNames: ['my-app-checkbox'] + }); + ``` + + + @method input + @for Ember.Handlebars.helpers + @param {Hash} options +*/ +Ember.Handlebars.registerHelper('input', function(options) { + Ember.assert('You can only pass attributes to the `input` helper, not arguments', arguments.length < 2); + + var hash = options.hash, + types = options.hashTypes, + inputType = hash.type, + onEvent = hash.on; + + delete hash.type; + delete hash.on; + + if (inputType === 'checkbox') { + return Ember.Handlebars.helpers.view.call(this, Ember.Checkbox, options); + } else { + if (inputType) { hash.type = inputType; } + hash.onEvent = onEvent || 'enter'; + return Ember.Handlebars.helpers.view.call(this, Ember.TextField, options); + } +}); + +/** + `{{textarea}}` inserts a new instance of ` + ``` + + Bound: + + In the following example, the `writtenWords` property on `App.ApplicationController` + will be updated live as the user types 'Lots of text that IS bound' into + the text area of their browser's window. + + ```javascript + App.ApplicationController = Ember.Controller.extend({ + writtenWords: "Lots of text that IS bound" + }); + ``` + + ```handlebars + {{textarea value=writtenWords}} + ``` + + Would result in the following HTML: + + ```html + + ``` + + If you wanted a one way binding between the text area and a div tag + somewhere else on your screen, you could use `Ember.computed.oneWay`: + + ```javascript + App.ApplicationController = Ember.Controller.extend({ + writtenWords: "Lots of text that IS bound", + outputWrittenWords: Ember.computed.oneWay("writtenWords") + }); + ``` + + ```handlebars + {{textarea value=writtenWords}} + + + {{outputWrittenWords}} ++ ``` + + Would result in the following HTML: + + ```html + + + <-- the following div will be updated in real time as you type --> + ++ Lots of text that IS bound ++ ``` + + Finally, this example really shows the power and ease of Ember when two + properties are bound to eachother via `Ember.computed.alias`. Type into + either text area box and they'll both stay in sync. Note that + `Ember.computed.alias` costs more in terms of performance, so only use it when + your really binding in both directions: + + ```javascript + App.ApplicationController = Ember.Controller.extend({ + writtenWords: "Lots of text that IS bound", + twoWayWrittenWords: Ember.computed.alias("writtenWords") + }); + ``` + + ```handlebars + {{textarea value=writtenWords}} + {{textarea value=twoWayWrittenWords}} + ``` + +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 ```html +<<<<<<< HEAD <-- both updated in real time --> @@ -29106,6 +40443,84 @@ Ember.Handlebars.registerHelper('textarea', function(options) { return Ember.Handlebars.helpers.view.call(this, Ember.TextArea, options); }); +======= + + <-- both updated in real time --> + + + ``` + + ## Extension + + Internally, `{{textarea}}` creates an instance of `Ember.TextArea`, passing + arguments from the helper to `Ember.TextArea`'s `create` method. You can + extend the capabilities of text areas in your application by reopening this + class. For example, if you are deploying to browsers where the `required` + attribute is used, you can globally add support for the `required` attribute + on all `{{textarea}}`s' in your app by reopening `Ember.TextArea` or + `Ember.TextSupport` and adding it to the `attributeBindings` concatenated + property: + + ```javascript + Ember.TextArea.reopen({ + attributeBindings: ['required'] + }); + ``` + + Keep in mind when writing `Ember.TextArea` subclasses that `Ember.TextArea` + itself extends `Ember.Component`, meaning that it does NOT inherit + the `controller` of the parent view. + + See more about [Ember components](api/classes/Ember.Component.html) + + @method textarea + @for Ember.Handlebars.helpers + @param {Hash} options +*/ +Ember.Handlebars.registerHelper('textarea', function(options) { + Ember.assert('You can only pass attributes to the `textarea` helper, not arguments', arguments.length < 2); + + var hash = options.hash, + types = options.hashTypes; + + return Ember.Handlebars.helpers.view.call(this, Ember.TextArea, options); +}); + +})(); + + + +(function() { +Ember.ComponentLookup = Ember.Object.extend({ + lookupFactory: function(name, container) { + + container = container || this.container; + + var fullName = 'component:' + name, + templateFullName = 'template:components/' + name, + templateRegistered = container && container.has(templateFullName); + + if (templateRegistered) { + container.injection(fullName, 'layout', templateFullName); + } + + var Component = container.lookupFactory(fullName); + + // Only treat as a component if either the component + // or a template has been registered. + if (templateRegistered || Component) { + if (!Component) { + container.register(fullName, Ember.Component); + Component = container.lookupFactory(fullName); + } + return Component; + } + } +}); + +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 })(); @@ -29150,8 +40565,6 @@ Ember.ComponentLookup = Ember.Object.extend({ */ /** - @private - Find templates stored in the head tag as script tags and make them available to `Ember.CoreView` in the global `Ember.TEMPLATES` object. This will be run as as jQuery DOM-ready callback. @@ -29161,6 +40574,7 @@ Ember.ComponentLookup = Ember.Object.extend({ Those with type `text/x-raw-handlebars` will be compiled with regular Handlebars and are suitable for use in views' computed properties. + @private @method bootstrap @for Ember.Handlebars @static @@ -29200,6 +40614,7 @@ function bootstrap() { Ember.Handlebars.bootstrap( Ember.$(document) ); } +<<<<<<< HEAD function registerComponents(container) { var templates = Ember.TEMPLATES, match; if (!templates) { return; } @@ -29229,6 +40644,8 @@ function registerComponent(container, name) { Ember.Handlebars.helper(name, Component); } +======= +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 function registerComponentLookup(container) { container.register('component-lookup:main', Ember.ComponentLookup); } @@ -29250,12 +40667,19 @@ Ember.onLoad('Ember.Application', function(Application) { initialize: bootstrap }); +<<<<<<< HEAD Application.initializer({ name: 'registerComponentLookup', after: 'domTemplates', initialize: registerComponentLookup }); +======= + Application.initializer({ + name: 'registerComponentLookup', + after: 'domTemplates', + initialize: registerComponentLookup +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 }); })(); @@ -30053,7 +41477,11 @@ define("router", // TODO: separate into module? Router.Transition = Transition; +<<<<<<< HEAD __exports__['default'] = Router; +======= + __exports__["default"] = Router; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 /** @@ -30283,7 +41711,11 @@ define("router", if (isParam(object)) { var name = recogHandler.names[0]; +<<<<<<< HEAD if ("" + object !== this.currentParams[name]) { return false; } +======= + if (!this.currentParams || "" + object !== this.currentParams[name]) { return false; } +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 } else if (handlerInfo.context !== object) { return false; } @@ -31061,10 +42493,17 @@ define("router", merge(newQueryParams, handlerInfos[i].queryParams); } router.currentQueryParams = newQueryParams; +<<<<<<< HEAD var params = paramsForHandler(router, handlerName, objects, transition.queryParams); +======= + + + var params = paramsForHandler(router, handlerName, objects, transition.queryParams); + +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 router.currentParams = params; if (urlMethod) { @@ -31366,9 +42805,16 @@ DSL.prototype = { } else { this.push(options.path, name, null, options.queryParams); } +<<<<<<< HEAD }, +======= + + + }, + +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 push: function(url, name, callback, queryParams) { var parts = name.split('.'); if (url === "" || url === "/" || parts[parts.length-1] === "index") { this.explicitIndex = true; } @@ -31378,7 +42824,11 @@ DSL.prototype = { route: function(name, options) { route(this, name, options); +<<<<<<< HEAD }, +======= + }, +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 generate: function() { var dslMatches = this.matches; @@ -31433,7 +42883,11 @@ var get = Ember.get; */ /** +<<<<<<< HEAD +======= + +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 Finds a controller instance. @for Ember @@ -31445,6 +42899,7 @@ Ember.controllerFor = function(container, controllerName, lookupOptions) { }; /** +<<<<<<< HEAD Generates a controller automatically if none was provided. The type of generated controller depends on the context. You can customize your generated controllers by defining @@ -31452,10 +42907,24 @@ Ember.controllerFor = function(container, controllerName, lookupOptions) { @for Ember @method generateController +======= + Generates a controller factory + + The type of the generated controller factory is derived + from the context. If the context is an array an array controller + is generated, if an object, an object controller otherwise, a basic + controller is generated. + + You can customize your generated controllers by defining + `App.ObjectController` or `App.ArrayController`. + + @for Ember + @method generateControllerFactory +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 @private */ -Ember.generateController = function(container, controllerName, context) { - var ControllerFactory, fullName, instance, name, factoryName, controllerType; +Ember.generateControllerFactory = function(container, controllerName, context) { + var Factory, fullName, instance, name, factoryName, controllerType; if (context && Ember.isArray(context)) { controllerType = 'array'; @@ -31467,7 +42936,7 @@ Ember.generateController = function(container, controllerName, context) { factoryName = 'controller:' + controllerType; - ControllerFactory = container.lookupFactory(factoryName).extend({ + Factory = container.lookupFactory(factoryName).extend({ isGenerated: true, toString: function() { return "(generated " + controllerName + " controller)"; @@ -31476,9 +42945,27 @@ Ember.generateController = function(container, controllerName, context) { fullName = 'controller:' + controllerName; - container.register(fullName, ControllerFactory); + container.register(fullName, Factory); - instance = container.lookup(fullName); + return Factory; +}; + +/** + Generates and instantiates a controller. + + The type of the generated controller factory is derived + from the context. If the context is an array an array controller + is generated, if an object, an object controller otherwise, a basic + controller is generated. + + @for Ember + @method generateController + @private +*/ +Ember.generateController = function(container, controllerName, context) { + Ember.generateControllerFactory(container, controllerName, context); + var fullName = 'controller:' + controllerName; + var instance = container.lookup(fullName); if (get(instance, 'namespace.LOG_ACTIVE_GENERATION')) { Ember.Logger.info("generated -> " + fullName, { fullName: fullName }); @@ -31500,6 +42987,7 @@ Ember.generateController = function(container, controllerName, context) { var Router = requireModule("router")['default']; var get = Ember.get, set = Ember.set; var defineProperty = Ember.defineProperty; +var slice = Array.prototype.slice; var DefaultView = Ember._MetamorphView; /** @@ -31511,18 +42999,52 @@ var DefaultView = Ember._MetamorphView; @extends Ember.Object */ Ember.Router = Ember.Object.extend(Ember.Evented, { +<<<<<<< HEAD +======= + /** + The `location` property determines the type of URL's that your + application will use. + + The following location types are currently available: + + * `hash` + * `history` + * `none` + + @property location + @default 'hash' + @see {Ember.Location} + */ +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 location: 'hash', init: function() { this.router = this.constructor.router || this.constructor.map(Ember.K); this._activeViews = {}; this._setupLocation(); + + if (get(this, 'namespace.LOG_TRANSITIONS_INTERNAL')) { + this.router.log = Ember.Logger.debug; + } }, + /** + Represents the current URL. + + @method url + @returns {String} The current URL. + */ url: Ember.computed(function() { return get(this, 'location').getURL(); }), + /** + Initializes the current router instance and sets up the change handling + event listeners used by the instances `location` implementation. + + @method startRouting + @private + */ startRouting: function() { this.router = this.router || this.constructor.map(Ember.K); @@ -31543,19 +43065,41 @@ Ember.Router = Ember.Object.extend(Ember.Evented, { this.handleURL(location.getURL()); }, +<<<<<<< HEAD didTransition: function(infos) { updatePaths(this); +======= + /** + Handles updating the paths and notifying any listeners of the URL + change. + + Triggers the router level `didTransition` hook. + + @method didTransition + @private + */ + didTransition: function(infos) { + updatePaths(this); + + this._cancelLoadingEvent(); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 this._cancelLoadingEvent(); this.notifyPropertyChange('url'); +<<<<<<< HEAD // Put this in the runloop so url will be accurate. Seems // less surprising than didTransition being out of sync. Ember.run.once(this, this.trigger, 'didTransition'); +======= + // Put this in the runloop so url will be accurate. Seems + // less surprising than didTransition being out of sync. + Ember.run.once(this, this.trigger, 'didTransition'); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 if (get(this, 'namespace').LOG_TRANSITIONS) { Ember.Logger.log("Transitioned into '" + Ember.Router._routePath(infos) + "'"); @@ -31590,6 +43134,14 @@ Ember.Router = Ember.Object.extend(Ember.Evented, { return this.location.formatURL(url); }, + /** + Determines if the supplied route is currently active. + + @method isActive + @param routeName + @returns {Boolean} + @private + */ isActive: function(routeName) { var router = this.router; return router.isActive.apply(router, arguments); @@ -31599,16 +43151,22 @@ Ember.Router = Ember.Object.extend(Ember.Evented, { this.router.trigger.apply(this.router, arguments); }, + /** + Does this router instance have the given route. + + @method hasRoute + @returns {Boolean} + @private + */ hasRoute: function(route) { return this.router.hasRoute(route); }, /** - @private - Resets the state of the router by clearing the current route handlers and deactivating them. + @private @method reset */ reset: function() { @@ -31655,6 +43213,10 @@ Ember.Router = Ember.Object.extend(Ember.Evented, { options.implementation = location; location = set(this, 'location', Ember.Location.create(options)); } + + // ensure that initState is called AFTER the rootURL is set on + // the location instance + if (typeof location.initState === 'function') { location.initState(); } }, _getHandlerFunction: function() { @@ -31671,8 +43233,11 @@ Ember.Router = Ember.Object.extend(Ember.Evented, { seen[name] = true; if (!handler) { +<<<<<<< HEAD +======= +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 container.register(routeName, DefaultRoute.extend()); handler = container.lookup(routeName); @@ -31718,7 +43283,7 @@ Ember.Router = Ember.Object.extend(Ember.Evented, { _doTransition: function(method, args) { // Normalize blank route to root URL. - args = [].slice.call(args); + args = slice.call(args); args[0] = args[0] || '/'; var passedName = args[0], name, self = this, @@ -31739,14 +43304,21 @@ Ember.Router = Ember.Object.extend(Ember.Evented, { var transitionPromise = this.router[method].apply(this.router, args); +<<<<<<< HEAD // Don't schedule loading state entry if user has already aborted the transition. +======= +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 transitionPromise.then(null, function(error) { if (error.name === "UnrecognizedURLError") { Ember.assert("The URL '" + error.message + "' did not match any routes in your application"); } +<<<<<<< HEAD }); +======= + }, 'Ember: Check for Router unrecognized URL error'); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 // We want to return the configurable promise object // so that callers of this function can use `.method()` on it, @@ -31756,6 +43328,7 @@ Ember.Router = Ember.Object.extend(Ember.Evented, { _scheduleLoadingEvent: function(transition, originRoute) { this._cancelLoadingEvent(); +<<<<<<< HEAD this._loadingStateTimer = Ember.run.scheduleOnce('routerTransitions', this, '_fireLoadingEvent', transition, originRoute); @@ -32066,10 +43639,410 @@ var get = Ember.get, set = Ember.set, @extends Ember.Object */ Ember.Route = Ember.Object.extend(Ember.ActionHandler, { +======= + this._loadingStateTimer = Ember.run.scheduleOnce('routerTransitions', this, '_fireLoadingEvent', transition, originRoute); + }, + + _fireLoadingEvent: function(transition, originRoute) { + if (!this.router.activeTransition) { + // Don't fire an event if we've since moved on from + // the transition that put us in a loading state. + return; + } + + transition.trigger(true, 'loading', transition, originRoute); + }, + + _cancelLoadingEvent: function () { + if (this._loadingStateTimer) { + Ember.run.cancel(this._loadingStateTimer); + } + this._loadingStateTimer = null; + } +}); + +/** + Helper function for iterating root-ward, starting + from (but not including) the provided `originRoute`. + + Returns true if the last callback fired requested + to bubble upward. + + @private + */ +function forEachRouteAbove(originRoute, transition, callback) { + var handlerInfos = transition.handlerInfos, + originRouteFound = false; + + for (var i = handlerInfos.length - 1; i >= 0; --i) { + var handlerInfo = handlerInfos[i], + route = handlerInfo.handler; + + if (!originRouteFound) { + if (originRoute === route) { + originRouteFound = true; + } + continue; + } + + if (callback(route, handlerInfos[i + 1].handler) !== true) { + return false; + } + } + return true; +} + +// These get invoked when an action bubbles above ApplicationRoute +// and are not meant to be overridable. +var defaultActionHandlers = { + + willResolveModel: function(transition, originRoute) { + originRoute.router._scheduleLoadingEvent(transition, originRoute); + }, + + error: function(error, transition, originRoute) { + // Attempt to find an appropriate error substate to enter. + var router = originRoute.router; + + var tryTopLevel = forEachRouteAbove(originRoute, transition, function(route, childRoute) { + var childErrorRouteName = findChildRouteName(route, childRoute, 'error'); + if (childErrorRouteName) { + router.intermediateTransitionTo(childErrorRouteName, error); + return; + } + return true; + }); + + if (tryTopLevel) { + // Check for top-level error state to enter. + if (routeHasBeenDefined(originRoute.router, 'application_error')) { + router.intermediateTransitionTo('application_error', error); + return; + } + } else { + // Don't fire an assertion if we found an error substate. + return; + } + + Ember.Logger.error('Error while loading route: ' + error.stack); + }, + + loading: function(transition, originRoute) { + // Attempt to find an appropriate loading substate to enter. + var router = originRoute.router; + + var tryTopLevel = forEachRouteAbove(originRoute, transition, function(route, childRoute) { + var childLoadingRouteName = findChildRouteName(route, childRoute, 'loading'); + + if (childLoadingRouteName) { + router.intermediateTransitionTo(childLoadingRouteName); + return; + } + + // Don't bubble above pivot route. + if (transition.pivotHandler !== route) { + return true; + } + }); + + if (tryTopLevel) { + // Check for top-level loading state to enter. + if (routeHasBeenDefined(originRoute.router, 'application_loading')) { + router.intermediateTransitionTo('application_loading'); + return; + } + } + } +}; + +function findChildRouteName(parentRoute, originatingChildRoute, name) { + var router = parentRoute.router, + childName, + targetChildRouteName = originatingChildRoute.routeName.split('.').pop(), + namespace = parentRoute.routeName === 'application' ? '' : parentRoute.routeName + '.'; + + + // Second, try general loading state, e.g. 'loading' + childName = namespace + name; + if (routeHasBeenDefined(router, childName)) { + return childName; + } +} + +function routeHasBeenDefined(router, name) { + var container = router.container; + return router.hasRoute(name) && + (container.has('template:' + name) || container.has('route:' + name)); +} +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + +function triggerEvent(handlerInfos, ignoreFailure, args) { + var name = args.shift(); + +<<<<<<< HEAD + @method exit + */ + exit: function() { + this.deactivate(); + this.teardownViews(); + }, /** @private + @method enter + */ + enter: function() { + this.activate(); + }, + + /** + The collection of functions, keyed by name, available on this route as + action targets. + + These functions will be invoked when a matching `{{action}}` is triggered + from within a template and the application's current route is this route. + + Actions can also be invoked from other parts of your application via `Route#send` + or `Controller#send`. + + The `actions` hash will inherit action handlers from + the `actions` hash defined on extended Route parent classes + or mixins rather than just replace the entire hash, e.g.: + + ```js + App.CanDisplayBanner = Ember.Mixin.create({ + actions: { + displayBanner: function(msg) { + // ... +======= + if (!handlerInfos) { + if (ignoreFailure) { return; } + throw new Ember.Error("Can't trigger action '" + name + "' because your app hasn't finished transitioning into its first route. To trigger an action on destination routes during a transition, you can call `.send()` on the `Transition` object passed to the `model/beforeModel/afterModel` hooks."); + } + + var eventWasHandled = false; + + for (var i = handlerInfos.length - 1; i >= 0; i--) { + var handlerInfo = handlerInfos[i], + handler = handlerInfo.handler; + + if (handler._actions && handler._actions[name]) { + if (handler._actions[name].apply(handler, args) === true) { + eventWasHandled = true; + } else { + return; + } + } + } + + if (defaultActionHandlers[name]) { + defaultActionHandlers[name].apply(null, args); + return; + } + + if (!eventWasHandled && !ignoreFailure) { + throw new Ember.Error("Nothing handled the action '" + name + "'. If you did handle the action, this error can be caused by returning true from an action handler in a controller, causing the action to bubble."); + } +} + +function updatePaths(router) { + var appController = router.container.lookup('controller:application'); + + if (!appController) { + // appController might not exist when top-level loading/error + // substates have been entered since ApplicationRoute hasn't + // actually been entered at that point. + return; + } + + var infos = router.router.currentHandlerInfos, + path = Ember.Router._routePath(infos); + + if (!('currentPath' in appController)) { + defineProperty(appController, 'currentPath'); + } + + set(appController, 'currentPath', path); + + if (!('currentRouteName' in appController)) { + defineProperty(appController, 'currentRouteName'); + } + + set(appController, 'currentRouteName', infos[infos.length - 1].name); +} + +Ember.Router.reopenClass({ + router: null, + map: function(callback) { + var router = this.router; + if (!router) { + router = new Router(); + router.callbacks = []; + router.triggerEvent = triggerEvent; + this.reopenClass({ router: router }); + } + + var dsl = Ember.RouterDSL.map(function() { + this.resource('application', { path: "/" }, function() { + for (var i=0; i < router.callbacks.length; i++) { + router.callbacks[i].call(this); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + } + callback.call(this); + }); + }); +<<<<<<< HEAD + + App.WelcomeRoute = Ember.Route.extend(App.CanDisplayBanner, { + actions: { + playMusic: function() { + // ... + } + } + }); + + // `WelcomeRoute`, when active, will be able to respond + // to both actions, since the actions hash is merged rather + // then replaced when extending mixins / parent classes. + this.send('displayBanner'); + this.send('playMusic'); + ``` + + Within a route's action handler, the value of the `this` context + is the Route object: + + ```js + App.SongRoute = Ember.Route.extend({ + actions: { + myAction: function() { + this.controllerFor("song"); + this.transitionTo("other.route"); + ... +======= + + router.callbacks.push(callback); + router.map(dsl.generate()); + return router; + }, + + _routePath: function(handlerInfos) { + var path = []; + + // We have to handle coalescing resource names that + // are prefixed with their parent's names, e.g. + // ['foo', 'foo.bar.baz'] => 'foo.bar.baz', not 'foo.foo.bar.baz' + + function intersectionMatches(a1, a2) { + for (var i = 0, len = a1.length; i < len; ++i) { + if (a1[i] !== a2[i]) { + return false; + } + } + return true; + } + + for (var i=1, l=handlerInfos.length; i@@ -34508,6 +48519,7 @@ Ember.onLoad('Ember.Handlebars', function(Handlebars) { ``` +<<<<<<< HEAD Those parameters will be passed along as arguments to the JavaScript function implementing the action. @@ -34655,6 +48667,162 @@ Ember.onLoad('Ember.Handlebars', function(Handlebars) { return new SafeString('data-ember-action="' + actionId + '"'); }); +======= +var get = Ember.get, set = Ember.set; +Ember.onLoad('Ember.Handlebars', function(Handlebars) { + + /** + Calling ``{{render}}`` from within a template will insert another + template that matches the provided name. The inserted template will + access its properties on its own controller (rather than the controller + of the parent template). + + If a view class with the same name exists, the view class also will be used. + + Note: A given controller may only be used *once* in your app in this manner. + A singleton instance of the controller will be created for you. + + Example: + + ```javascript + App.NavigationController = Ember.Controller.extend({ + who: "world" + }); + ``` + + ```handlebars + + Hello, {{who}}. + ``` + + ```handelbars + +My great app
+ {{render navigation}} + ``` + + ```html +My great app
++ Hello, world. ++ ``` + + Optionally you may provide a second argument: a property path + that will be bound to the `model` property of the controller. + + If a `model` property path is specified, then a new instance of the + controller will be created and `{{render}}` can be used multiple times + with the same name. + + For example if you had this `author` template. + + ```handlebars + + ``` + + You could render it inside the `post` template using the `render` helper. + + ```handlebars +++ ``` + + @method render + @for Ember.Handlebars.helpers + @param {String} name + @param {Object?} contextString + @param {Hash} options + @return {String} HTML string + */ + Ember.Handlebars.registerHelper('render', function renderHelper(name, contextString, options) { + var length = arguments.length; + Ember.assert("You must pass a template to render", length >= 2); + var contextProvided = length === 3, + container, router, controller, view, context, lookupOptions; + + container = (options || contextString).data.keywords.controller.container; + router = container.lookup('router:main'); + + if (length === 2) { + // use the singleton controller + options = contextString; + contextString = undefined; + Ember.assert("You can only use the {{render}} helper once without a model object as its second argument, as in {{render \"post\" post}}.", !router || !router._lookupActiveView(name)); + } else if (length === 3) { + // create a new controller + context = Ember.Handlebars.get(options.contexts[1], contextString, options); + } else { + throw Ember.Error("You must pass a templateName to render"); + } + + // # legacy namespace + name = name.replace(/\//g, '.'); + // \ legacy slash as namespace support + + + view = container.lookup('view:' + name) || container.lookup('view:default'); + + // provide controller override + var controllerName = options.hash.controller || name; + var controllerFullName = 'controller:' + controllerName; + + if (options.hash.controller) { + Ember.assert("The controller name you supplied '" + controllerName + "' did not resolve to a controller.", container.has(controllerFullName)); + } + + var parentController = options.data.keywords.controller; + + // choose name + if (length > 2) { + var factory = container.lookupFactory(controllerFullName) || + Ember.generateControllerFactory(container, controllerName, context); + + controller = factory.create({ + model: context, + parentController: parentController, + target: parentController + }); + + } else { + controller = container.lookup(controllerFullName) || + Ember.generateController(container, controllerName); + + controller.setProperties({ + target: parentController, + parentController: parentController + }); + } + + var root = options.contexts[1]; + + if (root) { + view.registerObserver(root, contextString, function() { + controller.set('model', Ember.Handlebars.get(root, contextString, options)); + }); + } + + options.hash.viewName = Ember.String.camelize(name); + + var templateName = 'template:' + name; + Ember.assert("You used `{{render '" + name + "'}}`, but '" + name + "' can not be found as either a template or a view.", container.has("view:" + name) || container.has(templateName)); + options.hash.template = container.lookup(templateName); + + options.hash.controller = controller; + + if (router && !context) { + router._connectActiveView(name, view); + } + + Ember.Handlebars.helpers.view.call(this, view, options); + }); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 }); })(); @@ -34666,6 +48834,7 @@ Ember.onLoad('Ember.Handlebars', function(Handlebars) { @module ember @submodule ember-routing */ +<<<<<<< HEAD if (Ember.ENV.EXPERIMENTAL_CONTROL_HELPER) { var get = Ember.get, set = Ember.set; @@ -34888,9 +49057,224 @@ Ember.ControllerMixin.reopen({ }); })(); +======= +Ember.onLoad('Ember.Handlebars', function(Handlebars) { + var resolveParams = Ember.Router.resolveParams, + isSimpleClick = Ember.ViewUtils.isSimpleClick; + var EmberHandlebars = Ember.Handlebars, + handlebarsGet = EmberHandlebars.get, + SafeString = EmberHandlebars.SafeString, + forEach = Ember.ArrayPolyfills.forEach, + get = Ember.get, + a_slice = Array.prototype.slice; + function args(options, actionName) { + var ret = []; + if (actionName) { ret.push(actionName); } + + var types = options.options.types.slice(1), + data = options.options.data; + + return ret.concat(resolveParams(options.context, options.params, { types: types, data: data })); + } + + var ActionHelper = EmberHandlebars.ActionHelper = { + registeredActions: {} + }; + + var keys = ["alt", "shift", "meta", "ctrl"]; + + var POINTER_EVENT_TYPE_REGEX = /^click|mouse|touch/; + + var isAllowedEvent = function(event, allowedKeys) { + if (typeof allowedKeys === "undefined") { + if (POINTER_EVENT_TYPE_REGEX.test(event.type)) { + return isSimpleClick(event); + } else { + allowedKeys = ''; + } + } + + if (allowedKeys.indexOf("any") >= 0) { + return true; + } + + var allowed = true; + + forEach.call(keys, function(key) { + if (event[key + "Key"] && allowedKeys.indexOf(key) === -1) { + allowed = false; + } + }); + + return allowed; + }; + + ActionHelper.registerAction = function(actionName, options, allowedKeys) { + var actionId = (++Ember.uuid).toString(); + + ActionHelper.registeredActions[actionId] = { + eventName: options.eventName, + handler: function handleRegisteredAction(event) { + if (!isAllowedEvent(event, allowedKeys)) { return true; } + + if (options.preventDefault !== false) { + event.preventDefault(); + } + + if (options.bubbles === false) { + event.stopPropagation(); + } + + var target = options.target; + + if (target.target) { + target = handlebarsGet(target.root, target.target, target.options); + } else { + target = target.root; + } + + Ember.run(function runRegisteredAction() { + if (target.send) { + target.send.apply(target, args(options.parameters, actionName)); + } else { + Ember.assert("The action '" + actionName + "' did not exist on " + target, typeof target[actionName] === 'function'); + target[actionName].apply(target, args(options.parameters)); + } + }); + } + }; + + options.view.on('willClearRender', function() { + delete ActionHelper.registeredActions[actionId]; + }); + + return actionId; + }; + + /** + The `{{action}}` helper registers an HTML element within a template for DOM + event handling and forwards that interaction to the templates's controller + or supplied `target` option (see 'Specifying a Target'). + + If the controller does not implement the event, the event is sent + to the current route, and it bubbles up the route hierarchy from there. + + User interaction with that element will invoke the supplied action name on + the appropriate target. + + Given the following application Handlebars template on the page + + ```handlebars ++ click me ++ ``` + + And application code + + ```javascript + App.ApplicationController = Ember.Controller.extend({ + actions: { + anActionName: function() { + } + } + }); + ``` + + Will result in the following rendered HTML + + ```html +++ ``` + + Clicking "click me" will trigger the `anActionName` action of the + `App.ApplicationController`. In this case, no additional parameters will be passed. + + If you provide additional parameters to the helper: + + ```handlebars + + ``` + + Those parameters will be passed along as arguments to the JavaScript + function implementing the action. + + ### Event Propagation + + Events triggered through the action helper will automatically have + `.preventDefault()` called on them. You do not need to do so in your event + handlers. If you need to allow event propagation (to handle file inputs for + example) you can supply the `preventDefault=false` option to the `{{action}}` helper: + + ```handlebars ++ click me +++ + ++ ``` + + To disable bubbling, pass `bubbles=false` to the helper: + + ```handlebars + + ``` + + If you need the default handler to trigger you should either register your + own event handler, or use event methods on your view class. See [Ember.View](/api/classes/Ember.View.html) + 'Responding to Browser Events' for more information. + + ### Specifying DOM event type + + By default the `{{action}}` helper registers for DOM `click` events. You can + supply an `on` option to the helper to specify a different DOM event name: + + ```handlebars ++ click me ++ ``` + + See `Ember.View` 'Responding to Browser Events' for a list of + acceptable DOM event names. + + NOTE: Because `{{action}}` depends on Ember's event dispatch system it will + only function if an `Ember.EventDispatcher` instance is available. An + `Ember.EventDispatcher` instance will be created when a new `Ember.Application` + is created. Having an instance of `Ember.Application` will satisfy this + requirement. + + ### Specifying whitelisted modifier keys + + By default the `{{action}}` helper will ignore click event with pressed modifier + keys. You can supply an `allowedKeys` option to specify which keys should not be ignored. + + ```handlebars ++ click me ++ ``` + + This way the `{{action}}` will fire when clicking with the alt key pressed down. + + Alternatively, supply "any" to the `allowedKeys` option to accept any combination of modifier keys. +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + + ```handlebars ++ click me with any key pressed ++ ``` + + ### Specifying a Target + +<<<<<<< HEAD (function() { /** @module ember @@ -35036,6 +49420,101 @@ Ember.View.reopen({ } } }); +======= + There are several possible target objects for `{{action}}` helpers: + + In a typical Ember application, where views are managed through use of the + `{{outlet}}` helper, actions will bubble to the current controller, then + to the current route, and then up the route hierarchy. + + Alternatively, a `target` option can be provided to the helper to change + which object will receive the method call. This option must be a path + to an object, accessible in the current context: + + ```handlebars + {{! the application template }} ++ click me ++ ``` + + ```javascript + App.ApplicationView = Ember.View.extend({ + actions: { + anActionName: function(){} + } + }); + + ``` + + ### Additional Parameters + + You may specify additional parameters to the `{{action}}` helper. These + parameters are passed along as the arguments to the JavaScript function + implementing the action. + + ```handlebars + {{#each person in people}} ++ click me ++ {{/each}} + ``` + + Clicking "click me" will trigger the `edit` method on the current controller + with the value of `person` as a parameter. + + @method action + @for Ember.Handlebars.helpers + @param {String} actionName + @param {Object} [context]* + @param {Hash} options + */ + EmberHandlebars.registerHelper('action', function actionHelper(actionName) { + var options = arguments[arguments.length - 1], + contexts = a_slice.call(arguments, 1, -1); + + var hash = options.hash, + controller; + + // create a hash to pass along to registerAction + var action = { + eventName: hash.on || "click" + }; + + action.parameters = { + context: this, + options: options, + params: contexts + }; + + action.view = options.data.view; + + var root, target; + + if (hash.target) { + root = this; + target = hash.target; + } else if (controller = options.data.keywords.controller) { + root = controller; + } + + action.target = { root: root, target: target, options: options }; + action.bubbles = hash.bubbles; + action.preventDefault = hash.preventDefault; + + var actionId = ActionHelper.registerAction(actionName, action, hash.allowedKeys); + return new SafeString('data-ember-action="' + actionId + '"'); + }); + +}); + +})(); + + + +(function() { +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 })(); @@ -35044,6 +49523,7 @@ Ember.View.reopen({ (function() { /** @module ember +<<<<<<< HEAD @submodule ember-views */ @@ -35090,6 +49570,66 @@ var get = Ember.get, set = Ember.set; You can pass it a `implementation` ('hash', 'history', 'none') to force a particular implementation. +======= +@submodule ember-routing +*/ + +var get = Ember.get, set = Ember.set; + +Ember.ControllerMixin.reopen({ + /** + Transition the application into another route. The route may + be either a single route or route path: + + ```javascript + aController.transitionToRoute('blogPosts'); + aController.transitionToRoute('blogPosts.recentEntries'); + ``` + + Optionally supply a model for the route in question. The model + will be serialized into the URL using the `serialize` hook of + the route: + + ```javascript + aController.transitionToRoute('blogPost', aPost); + ``` + + Multiple models will be applied last to first recursively up the + resource tree. + + ```javascript + this.resource('blogPost', {path:':blogPostId'}, function(){ + this.resource('blogComment', {path: ':blogCommentId'}); + }); + + aController.transitionToRoute('blogComment', aPost, aComment); + ``` + + See also 'replaceRoute'. + + @param {String} name the name of the route + @param {...Object} models the model(s) to be used while transitioning + to the route. + @for Ember.ControllerMixin + @method transitionToRoute + */ + transitionToRoute: function() { + // target may be either another controller or a router + var target = get(this, 'target'), + method = target.transitionToRoute || target.transitionTo; + return method.apply(target, arguments); + }, + + /** + @deprecated + @for Ember.ControllerMixin + @method transitionTo + */ + transitionTo: function() { + Ember.deprecate("transitionTo is deprecated. Please use transitionToRoute."); + return this.transitionToRoute.apply(this, arguments); + }, +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 @class Location @namespace Ember @@ -35097,6 +49637,7 @@ var get = Ember.get, set = Ember.set; */ Ember.Location = { /** +<<<<<<< HEAD Create an instance of a an implementation of the `location` API. Requires an options object with an `implementation` property. @@ -35243,11 +49784,59 @@ Ember.NoneLocation = Ember.Object.extend({ // errors when test code renders templates containing {{action href=true}} // helpers. return url; +======= + Transition into another route while replacing the current URL, if possible. + This will replace the current history entry instead of adding a new one. + Beside that, it is identical to `transitionToRoute` in all other respects. + + ```javascript + aController.replaceRoute('blogPosts'); + aController.replaceRoute('blogPosts.recentEntries'); + ``` + + Optionally supply a model for the route in question. The model + will be serialized into the URL using the `serialize` hook of + the route: + + ```javascript + aController.replaceRoute('blogPost', aPost); + ``` + + Multiple models will be applied last to first recursively up the + resource tree. + + ```javascript + this.resource('blogPost', {path:':blogPostId'}, function(){ + this.resource('blogComment', {path: ':blogCommentId'}); + }); + + aController.replaceRoute('blogComment', aPost, aComment); + ``` + + @param {String} name the name of the route + @param {...Object} models the model(s) to be used while transitioning + to the route. + @for Ember.ControllerMixin + @method replaceRoute + */ + replaceRoute: function() { + // target may be either another controller or a router + var target = get(this, 'target'), + method = target.replaceRoute || target.replaceWith; + return method.apply(target, arguments); + }, + + /** + @deprecated + @for Ember.ControllerMixin + @method replaceWith + */ + replaceWith: function() { + Ember.deprecate("replaceWith is deprecated. Please use replaceRoute."); + return this.replaceRoute.apply(this, arguments); } }); -Ember.Location.registerImplementation('none', Ember.NoneLocation); - })(); @@ -35260,6 +49849,169 @@ Ember.Location.registerImplementation('none', Ember.NoneLocation); var get = Ember.get, set = Ember.set; +Ember.View.reopen({ + + /** + Sets the private `_outlets` object on the view. + + @method init + */ + init: function() { + set(this, '_outlets', {}); + this._super(); + }, + + /** + Manually fill any of a view's `{{outlet}}` areas with the + supplied view. + + Example + + ```javascript + var MyView = Ember.View.extend({ + template: Ember.Handlebars.compile('Child view: {{outlet "main"}} ') + }); + var myView = MyView.create(); + myView.appendTo('body'); + // The html for myView now looks like: + //Child view:+ + var FooView = Ember.View.extend({ + template: Ember.Handlebars.compile('Foo
') + }); + var fooView = FooView.create(); + myView.connectOutlet('main', fooView); + // The html for myView now looks like: + //Child view: + //+ ``` + @method connectOutlet + @param {String} outletName A unique name for the outlet + @param {Object} view An Ember.View + */ + connectOutlet: function(outletName, view) { + if (this._pendingDisconnections) { + delete this._pendingDisconnections[outletName]; + } + + if (this._hasEquivalentView(outletName, view)) { + view.destroy(); + return; + } + + var outlets = get(this, '_outlets'), + container = get(this, 'container'), + router = container && container.lookup('router:main'), + renderedName = get(view, 'renderedName'); + + set(outlets, outletName, view); + + if (router && renderedName) { + router._connectActiveView(renderedName, view); + } + }, + + /** + Determines if the view has already been created by checking if + the view has the same constructor, template, and context as the + view in the `_outlets` object. + + @private + @method _hasEquivalentView + @param {String} outletName The name of the outlet we are checking + @param {Object} view An Ember.View + @return {Boolean} + */ + _hasEquivalentView: function(outletName, view) { + var existingView = get(this, '_outlets.'+outletName); + return existingView && + existingView.constructor === view.constructor && + existingView.get('template') === view.get('template') && + existingView.get('context') === view.get('context'); + }, + + /** + Removes an outlet from the view. + + Example + + ```javascript + var MyView = Ember.View.extend({ + template: Ember.Handlebars.compile('Child view: {{outlet "main"}} ') + }); + var myView = MyView.create(); + myView.appendTo('body'); + // myView's html: + //+ //Foo
Child view:+ + var FooView = Ember.View.extend({ + template: Ember.Handlebars.compile('Foo
') + }); + var fooView = FooView.create(); + myView.connectOutlet('main', fooView); + // myView's html: + //Child view: + //+ + myView.disconnectOutlet('main'); + // myView's html: + //+ //Foo
Child view:+ ``` + + @method disconnectOutlet + @param {String} outletName The name of the outlet to be removed + */ + disconnectOutlet: function(outletName) { + if (!this._pendingDisconnections) { + this._pendingDisconnections = {}; + } + this._pendingDisconnections[outletName] = true; + Ember.run.once(this, '_finishDisconnections'); + }, + + /** + Gets an outlet that is pending disconnection and then + nullifys the object on the `_outlet` object. + + @private + @method _finishDisconnections + */ + _finishDisconnections: function() { + var outlets = get(this, '_outlets'); + var pendingDisconnections = this._pendingDisconnections; + this._pendingDisconnections = null; + + for (var outletName in pendingDisconnections) { + set(outlets, outletName, null); + } +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + } +}); + +Ember.Location.registerImplementation('none', Ember.NoneLocation); + +})(); + + + +(function() { +/** +@module ember +<<<<<<< HEAD +@submodule ember-routing +======= +@submodule ember-views +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 +*/ + +// Add a new named queue after the 'actions' queue (where RSVP promises +// resolve), which is used in router transitions to prevent unnecessary +// loading state entry if all context promises resolve on the +// 'actions' queue first. + +<<<<<<< HEAD /** Ember.HashLocation implements the location API using the browser's hash. At present, it relies on a hashchange event existing in the @@ -35835,10 +50587,552 @@ Ember.DefaultResolver = Ember.Object.extend({ } else { return fullName; } +======= +var queues = Ember.run.queues, + indexOf = Ember.ArrayPolyfills.indexOf; +queues.splice(indexOf.call(queues, 'actions') + 1, 0, 'routerTransitions'); + +})(); + + + +(function() { +/** +@module ember +@submodule ember-routing +*/ + +var get = Ember.get, set = Ember.set; + +/** + Ember.Location returns an instance of the correct implementation of + the `location` API. + + ## Implementations + + You can pass an implementation name (`hash`, `history`, `none`) to force a + particular implementation to be used in your application. + + ### HashLocation + + Using `HashLocation` results in URLs with a `#` (hash sign) separating the + server side URL portion of the URL from the portion that is used by Ember. + This relies upon the `hashchange` event existing in the browser. + + Example: + + ```javascript + App.Router.map(function() { + this.resource('posts', function() { + this.route('new'); + }); + }); + + App.Router.reopen({ + location: 'hash' + }); + ``` + + This will result in a posts.new url of `/#/posts/new`. + + ### HistoryLocation + + Using `HistoryLocation` results in URLs that are indistinguishable from a + standard URL. This relies upon the browser's `history` API. + + Example: + + ```javascript + App.Router.map(function() { + this.resource('posts', function() { + this.route('new'); + }); + }); + + App.Router.reopen({ + location: 'history' + }); + ``` + + This will result in a posts.new url of `/posts/new`. + + ### NoneLocation + + Using `NoneLocation` causes Ember to not store the applications URL state + in the actual URL. This is generally used for testing purposes, and is one + of the changes made when calling `App.setupForTesting()`. + + ## Location API + + Each location implementation must provide the following methods: + + * implementation: returns the string name used to reference the implementation. + * getURL: returns the current URL. + * setURL(path): sets the current URL. + * replaceURL(path): replace the current URL (optional). + * onUpdateURL(callback): triggers the callback when the URL changes. + * formatURL(url): formats `url` to be placed into `href` attribute. + + Calling setURL or replaceURL will not trigger onUpdateURL callbacks. + + @class Location + @namespace Ember + @static +*/ +Ember.Location = { + /** + This is deprecated in favor of using the container to lookup the location + implementation as desired. + + For example: + + ```javascript + // Given a location registered as follows: + container.register('location:history-test', HistoryTestLocation); + + // You could create a new instance via: + container.lookup('location:history-test'); + ``` + + @method create + @param {Object} options + @return {Object} an instance of an implementation of the `location` API + @deprecated Use the container to lookup the location implementation that you + need. + */ + create: function(options) { + var implementation = options && options.implementation; + Ember.assert("Ember.Location.create: you must specify a 'implementation' option", !!implementation); + + var implementationClass = this.implementations[implementation]; + Ember.assert("Ember.Location.create: " + implementation + " is not a valid implementation", !!implementationClass); + + return implementationClass.create.apply(implementationClass, arguments); + }, + + /** + This is deprecated in favor of using the container to register the + location implementation as desired. + + Example: + + ```javascript + Application.initializer({ + name: "history-test-location", + + initialize: function(container, application) { + application.register('location:history-test', HistoryTestLocation); + } + }); + ``` + + @method registerImplementation + @param {String} name + @param {Object} implementation of the `location` API + @deprecated Register your custom location implementation with the + container directly. + */ + registerImplementation: function(name, implementation) { + this.implementations[name] = implementation; + }, + + implementations: {} +}; + +})(); + + + +(function() { +/** +@module ember +@submodule ember-routing +*/ + +var get = Ember.get, set = Ember.set; + +/** + Ember.NoneLocation does not interact with the browser. It is useful for + testing, or when you need to manage state with your Router, but temporarily + don't want it to muck with the URL (for example when you embed your + application in a larger page). + + @class NoneLocation + @namespace Ember + @extends Ember.Object +*/ +Ember.NoneLocation = Ember.Object.extend({ + path: '', + + /** + Returns the current path. + + @private + @method getURL + @return {String} path + */ + getURL: function() { + return get(this, 'path'); + }, + + /** + Set the path and remembers what was set. Using this method + to change the path will not invoke the `updateURL` callback. + + @private + @method setURL + @param path {String} + */ + setURL: function(path) { + set(this, 'path', path); + }, + + /** + Register a callback to be invoked when the path changes. These + callbacks will execute when the user presses the back or forward + button, but not after `setURL` is invoked. + + @private + @method onUpdateURL + @param callback {Function} + */ + onUpdateURL: function(callback) { + this.updateCallback = callback; + }, + + /** + Sets the path and calls the `updateURL` callback. + + @private + @method handleURL + @param callback {Function} + */ + handleURL: function(url) { + set(this, 'path', url); + this.updateCallback(url); + }, + + /** + Given a URL, formats it to be placed into the page as part + of an element's `href` attribute. + + This is used, for example, when using the {{action}} helper + to generate a URL based on an event. + + @private + @method formatURL + @param url {String} + @return {String} url + */ + formatURL: function(url) { + // The return value is not overly meaningful, but we do not want to throw + // errors when test code renders templates containing {{action href=true}} + // helpers. + return url; + } +}); + +Ember.Location.registerImplementation('none', Ember.NoneLocation); + +})(); + + + +(function() { +/** +@module ember +@submodule ember-routing +*/ + +var get = Ember.get, set = Ember.set; + +/** + `Ember.HashLocation` implements the location API using the browser's + hash. At present, it relies on a `hashchange` event existing in the + browser. + + @class HashLocation + @namespace Ember + @extends Ember.Object +*/ +Ember.HashLocation = Ember.Object.extend({ + + init: function() { + set(this, 'location', get(this, 'location') || window.location); + }, + + /** + Returns the current `location.hash`, minus the '#' at the front. + + @private + @method getURL + */ + getURL: function() { + // Default implementation without feature flag enabled + return get(this, 'location').hash.substr(1); + }, + + /** + Set the `location.hash` and remembers what was set. This prevents + `onUpdateURL` callbacks from triggering when the hash was set by + `HashLocation`. + + @private + @method setURL + @param path {String} + */ + setURL: function(path) { + get(this, 'location').hash = path; + set(this, 'lastSetURL', path); + }, + + /** + Uses location.replace to update the url without a page reload + or history modification. + + @private + @method replaceURL + @param path {String} + */ + replaceURL: function(path) { + get(this, 'location').replace('#' + path); + }, + + /** + Register a callback to be invoked when the hash changes. These + callbacks will execute when the user presses the back or forward + button, but not after `setURL` is invoked. + + @private + @method onUpdateURL + @param callback {Function} + */ + onUpdateURL: function(callback) { + var self = this; + var guid = Ember.guidFor(this); + + Ember.$(window).on('hashchange.ember-location-'+guid, function() { + Ember.run(function() { + var path = location.hash.substr(1); + if (get(self, 'lastSetURL') === path) { return; } + + set(self, 'lastSetURL', null); + + callback(path); + }); + }); + }, + + /** + Given a URL, formats it to be placed into the page as part + of an element's `href` attribute. + + This is used, for example, when using the {{action}} helper + to generate a URL based on an event. + + @private + @method formatURL + @param url {String} + */ + formatURL: function(url) { + return '#'+url; + }, + + /** + Cleans up the HashLocation event listener. + + @private + @method willDestroy + */ + willDestroy: function() { + var guid = Ember.guidFor(this); + + Ember.$(window).off('hashchange.ember-location-'+guid); + } +}); + +Ember.Location.registerImplementation('hash', Ember.HashLocation); + +})(); + + + +(function() { +/** +@module ember +@submodule ember-routing +*/ + +var get = Ember.get, set = Ember.set; +var popstateFired = false; +var supportsHistoryState = window.history && 'state' in window.history; + +/** + Ember.HistoryLocation implements the location API using the browser's + history.pushState API. + + @class HistoryLocation + @namespace Ember + @extends Ember.Object +*/ +Ember.HistoryLocation = Ember.Object.extend({ + + init: function() { + set(this, 'location', get(this, 'location') || window.location); + }, + + /** + Used to set state on first call to setURL + + @private + @method initState + */ + initState: function() { + set(this, 'history', get(this, 'history') || window.history); + this.replaceState(this.formatURL(this.getURL())); + }, + + /** + Will be pre-pended to path upon state change + + @property rootURL + @default '/' + */ + rootURL: '/', + + /** + Returns the current `location.pathname` without `rootURL`. + + @private + @method getURL + @return url {String} + */ + getURL: function() { + var rootURL = get(this, 'rootURL'), + location = get(this, 'location'), + path = location.pathname; + + rootURL = rootURL.replace(/\/$/, ''); + var url = path.replace(rootURL, ''); + + + return url; + }, + + /** + Uses `history.pushState` to update the url without a page reload. + + @private + @method setURL + @param path {String} + */ + setURL: function(path) { + var state = this.getState(); + path = this.formatURL(path); + + if (state && state.path !== path) { + this.pushState(path); + } + }, + + /** + Uses `history.replaceState` to update the url without a page reload + or history modification. + + @private + @method replaceURL + @param path {String} + */ + replaceURL: function(path) { + var state = this.getState(); + path = this.formatURL(path); + + if (state && state.path !== path) { + this.replaceState(path); + } + }, + + /** + Get the current `history.state` + Polyfill checks for native browser support and falls back to retrieving + from a private _historyState variable + + @private + @method getState + @return state {Object} + */ + getState: function() { + return supportsHistoryState ? get(this, 'history').state : this._historyState; + }, + + /** + Pushes a new state. + + @private + @method pushState + @param path {String} + */ + pushState: function(path) { + var state = { path: path }; + + get(this, 'history').pushState(state, null, path); + + // store state if browser doesn't support `history.state` + if (!supportsHistoryState) { + this._historyState = state; + } + + // used for webkit workaround + this._previousURL = this.getURL(); + }, + + /** + Replaces the current state. + + @private + @method replaceState + @param path {String} + */ + replaceState: function(path) { + var state = { path: path }; + + get(this, 'history').replaceState(state, null, path); + + // store state if browser doesn't support `history.state` + if (!supportsHistoryState) { + this._historyState = state; + } + + // used for webkit workaround + this._previousURL = this.getURL(); + }, + + /** + Register a callback to be invoked whenever the browser + history changes, including using forward and back buttons. + + @private + @method onUpdateURL + @param callback {Function} + */ + onUpdateURL: function(callback) { + var guid = Ember.guidFor(this), + self = this; + + Ember.$(window).on('popstate.ember-location-'+guid, function(e) { + // Ignore initial page load popstate event in Chrome + if (!popstateFired) { + popstateFired = true; + if (self.getURL() === self._previousURL) { return; } + } + callback(self.getURL()); + }); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 }, /** +<<<<<<< HEAD This method is called via the container's resolver method. It parses the provided `fullName` and then looks up and returns the appropriate template or class. @@ -35860,8 +51154,26 @@ Ember.DefaultResolver = Ember.Object.extend({ if (resolved) { return resolved; } } return this.resolveOther(parsedName); +======= + Used when using `{{action}}` helper. The url is always appended to the rootURL. + + @private + @method formatURL + @param url {String} + @return formatted url {String} + */ + formatURL: function(url) { + var rootURL = get(this, 'rootURL'); + + if (url !== '') { + rootURL = rootURL.replace(/\/$/, ''); + } + + return rootURL + url; +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 }, /** +<<<<<<< HEAD Convert the string name of the form "type:name" to a Javascript object with the parsed aspects of the name broken out. @@ -36027,6 +51339,146 @@ Ember.DefaultResolver = Ember.Object.extend({ return factory.toString(); } }); +======= + Cleans up the HistoryLocation event listener. + + @private + @method willDestroy + */ + willDestroy: function() { + var guid = Ember.guidFor(this); + + Ember.$(window).off('popstate.ember-location-'+guid); + } +}); + +Ember.Location.registerImplementation('history', Ember.HistoryLocation); + +})(); + + + +(function() { + +})(); + + + +(function() { +/** +Ember Routing + +@module ember +@submodule ember-routing +@requires ember-views +*/ + +})(); + +(function() { +function visit(vertex, fn, visited, path) { + var name = vertex.name, + vertices = vertex.incoming, + names = vertex.incomingNames, + len = names.length, + i; + if (!visited) { + visited = {}; + } + if (!path) { + path = []; + } + if (visited.hasOwnProperty(name)) { + return; + } + path.push(name); + visited[name] = true; + for (i = 0; i < len; i++) { + visit(vertices[names[i]], fn, visited, path); + } + fn(vertex, path); + path.pop(); +} + +function DAG() { + this.names = []; + this.vertices = {}; +} + +DAG.prototype.add = function(name) { + if (!name) { return; } + if (this.vertices.hasOwnProperty(name)) { + return this.vertices[name]; + } + var vertex = { + name: name, incoming: {}, incomingNames: [], hasOutgoing: false, value: null + }; + this.vertices[name] = vertex; + this.names.push(name); + return vertex; +}; + +DAG.prototype.map = function(name, value) { + this.add(name).value = value; +}; + +DAG.prototype.addEdge = function(fromName, toName) { + if (!fromName || !toName || fromName === toName) { + return; + } + var from = this.add(fromName), to = this.add(toName); + if (to.incoming.hasOwnProperty(fromName)) { + return; + } + function checkCycle(vertex, path) { + if (vertex.name === toName) { + throw new Ember.Error("cycle detected: " + toName + " <- " + path.join(" <- ")); + } + } + visit(from, checkCycle); + from.hasOutgoing = true; + to.incoming[fromName] = from; + to.incomingNames.push(fromName); +}; + +DAG.prototype.topsort = function(fn) { + var visited = {}, + vertices = this.vertices, + names = this.names, + len = names.length, + i, vertex; + for (i = 0; i < len; i++) { + vertex = vertices[names[i]]; + if (!vertex.hasOutgoing) { + visit(vertex, fn, visited); + } + } +}; + +DAG.prototype.addEdges = function(name, value, before, after) { + var i; + this.map(name, value); + if (before) { + if (typeof before === 'string') { + this.addEdge(name, before); + } else { + for (i = 0; i < before.length; i++) { + this.addEdge(name, before[i]); + } + } + } + if (after) { + if (typeof after === 'string') { + this.addEdge(after, name); + } else { + for (i = 0; i < after.length; i++) { + this.addEdge(after[i], name); + } + } + } +}; + +Ember.DAG = DAG; })(); @@ -36038,8 +51490,180 @@ Ember.DefaultResolver = Ember.Object.extend({ @submodule ember-application */ -var get = Ember.get, set = Ember.set; +var get = Ember.get, + classify = Ember.String.classify, + capitalize = Ember.String.capitalize, + decamelize = Ember.String.decamelize; +/** + The DefaultResolver defines the default lookup rules to resolve + container lookups before consulting the container for registered + items: + +* templates are looked up on `Ember.TEMPLATES` +* other names are looked up on the application after converting + the name. For example, `controller:post` looks up + `App.PostController` by default. +* there are some nuances (see examples below) + + ### How Resolving Works + + The container calls this object's `resolve` method with the + `fullName` argument. + + It first parses the fullName into an object using `parseName`. + + Then it checks for the presence of a type-specific instance + method of the form `resolve[Type]` and calls it if it exists. + For example if it was resolving 'template:post', it would call + the `resolveTemplate` method. + + Its last resort is to call the `resolveOther` method. + + The methods of this object are designed to be easy to override + in a subclass. For example, you could enhance how a template + is resolved like so: + + ```javascript + App = Ember.Application.create({ + Resolver: Ember.DefaultResolver.extend({ + resolveTemplate: function(parsedName) { + var resolvedTemplate = this._super(parsedName); + if (resolvedTemplate) { return resolvedTemplate; } + return Ember.TEMPLATES['not_found']; + } + }) + }); + ``` + + Some examples of how names are resolved: + + ``` + 'template:post' //=> Ember.TEMPLATES['post'] + 'template:posts/byline' //=> Ember.TEMPLATES['posts/byline'] + 'template:posts.byline' //=> Ember.TEMPLATES['posts/byline'] + 'template:blogPost' //=> Ember.TEMPLATES['blogPost'] + // OR + // Ember.TEMPLATES['blog_post'] + 'controller:post' //=> App.PostController + 'controller:posts.index' //=> App.PostsIndexController + 'controller:blog/post' //=> Blog.PostController + 'controller:basic' //=> Ember.Controller + 'route:post' //=> App.PostRoute + 'route:posts.index' //=> App.PostsIndexRoute + 'route:blog/post' //=> Blog.PostRoute + 'route:basic' //=> Ember.Route + 'view:post' //=> App.PostView + 'view:posts.index' //=> App.PostsIndexView + 'view:blog/post' //=> Blog.PostView + 'view:basic' //=> Ember.View + 'foo:post' //=> App.PostFoo + 'model:post' //=> App.Post + ``` + + @class DefaultResolver + @namespace Ember + @extends Ember.Object +*/ +Ember.DefaultResolver = Ember.Object.extend({ + /** + This will be set to the Application instance when it is + created. + + @property namespace + */ + namespace: null, + + normalize: function(fullName) { + var split = fullName.split(':', 2), + type = split[0], + name = split[1]; + + Ember.assert("Tried to normalize a container name without a colon (:) in " + + "it. You probably tried to lookup a name that did not contain " + + "a type, a colon, and a name. A proper lookup name would be " + + "`view:post`.", split.length === 2); + + if (type !== 'template') { + var result = name; + + if (result.indexOf('.') > -1) { + result = result.replace(/\.(.)/g, function(m) { return m.charAt(1).toUpperCase(); }); + } + + if (name.indexOf('_') > -1) { + result = result.replace(/_(.)/g, function(m) { return m.charAt(1).toUpperCase(); }); + } + + return type + ':' + result; + } else { + return fullName; + } + }, + + + /** + This method is called via the container's resolver method. + It parses the provided `fullName` and then looks up and + returns the appropriate template or class. + + @method resolve + @param {String} fullName the lookup string + @return {Object} the resolved factory + */ + resolve: function(fullName) { + var parsedName = this.parseName(fullName), + typeSpecificResolveMethod = this[parsedName.resolveMethodName]; + + if (!parsedName.name || !parsedName.type) { + throw new TypeError("Invalid fullName: `" + fullName + "`, must be of the form `type:name` "); + } +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + + if (typeSpecificResolveMethod) { + var resolved = typeSpecificResolveMethod.call(this, parsedName); + if (resolved) { return resolved; } + } + return this.resolveOther(parsedName); + }, + /** + Convert the string name of the form "type:name" to + a Javascript object with the parsed aspects of the name + broken out. + + @protected + @param {String} fullName the lookup string + @method parseName + */ + parseName: function(fullName) { + var nameParts = fullName.split(":"), + type = nameParts[0], fullNameWithoutType = nameParts[1], + name = fullNameWithoutType, + namespace = get(this, 'namespace'), + root = namespace; + + if (type !== 'template' && name.indexOf('/') !== -1) { + var parts = name.split('/'); + name = parts[parts.length - 1]; + var namespaceName = capitalize(parts.slice(0, -1).join('.')); + root = Ember.Namespace.byName(namespaceName); + + Ember.assert('You are looking for a ' + name + ' ' + type + ' in the ' + namespaceName + ' namespace, but the namespace could not be found', root); + } + + return { + fullName: fullName, + type: type, + fullNameWithoutType: fullNameWithoutType, + name: name, + root: root, + resolveMethodName: "resolve" + classify(type) + }; + }, + /** + Look up the template in Ember.TEMPLATES + +<<<<<<< HEAD function DeprecatedContainer(container) { this._container = container; } @@ -36128,6 +51752,137 @@ DeprecatedContainer.prototype = { } }); ``` +======= + @protected + @param {Object} parsedName a parseName object with the parsed + fullName lookup string + @method resolveTemplate + */ + resolveTemplate: function(parsedName) { + var templateName = parsedName.fullNameWithoutType.replace(/\./g, '/'); + + if (Ember.TEMPLATES[templateName]) { + return Ember.TEMPLATES[templateName]; + } + + templateName = decamelize(templateName); + if (Ember.TEMPLATES[templateName]) { + return Ember.TEMPLATES[templateName]; + } + }, + /** + Given a parseName object (output from `parseName`), apply + the conventions expected by `Ember.Router` + + @protected + @param {Object} parsedName a parseName object with the parsed + fullName lookup string + @method useRouterNaming + */ + useRouterNaming: function(parsedName) { + parsedName.name = parsedName.name.replace(/\./g, '_'); + if (parsedName.name === 'basic') { + parsedName.name = ''; + } + }, + /** + Lookup the controller using `resolveOther` + + @protected + @param {Object} parsedName a parseName object with the parsed + fullName lookup string + @method resolveController + */ + resolveController: function(parsedName) { + this.useRouterNaming(parsedName); + return this.resolveOther(parsedName); + }, + /** + Lookup the route using `resolveOther` + + @protected + @param {Object} parsedName a parseName object with the parsed + fullName lookup string + @method resolveRoute + */ + resolveRoute: function(parsedName) { + this.useRouterNaming(parsedName); + return this.resolveOther(parsedName); + }, + /** + Lookup the view using `resolveOther` + + @protected + @param {Object} parsedName a parseName object with the parsed + fullName lookup string + @method resolveView + */ + resolveView: function(parsedName) { + this.useRouterNaming(parsedName); + return this.resolveOther(parsedName); + }, + + resolveHelper: function(parsedName) { + return this.resolveOther(parsedName) || Ember.Handlebars.helpers[parsedName.fullNameWithoutType]; + }, + + /** + Lookup the model on the Application namespace + + @protected + @param {Object} parsedName a parseName object with the parsed + fullName lookup string + @method resolveModel + */ + resolveModel: function(parsedName) { + var className = classify(parsedName.name), + factory = get(parsedName.root, className); + + if (factory) { return factory; } + }, + /** + Look up the specified object (from parsedName) on the appropriate + namespace (usually on the Application) + + @protected + @param {Object} parsedName a parseName object with the parsed + fullName lookup string + @method resolveOther + */ + resolveOther: function(parsedName) { + var className = classify(parsedName.name) + classify(parsedName.type), + factory = get(parsedName.root, className); + if (factory) { return factory; } + }, + + /** + Returns a human-readable description for a fullName. Used by the + Application namespace in assertions to describe the + precise name of the class that Ember is looking for, rather than + container keys. + + @protected + @param {String} fullName the lookup string + @method lookupDescription + */ + lookupDescription: function(fullName) { + var parsedName = this.parseName(fullName); + + if (parsedName.type === 'template') { + return "template at " + parsedName.fullNameWithoutType.replace(/\./g, '/'); + } + + var description = parsedName.root + "." + classify(parsedName.name); + if (parsedName.type !== 'model') { description += classify(parsedName.type); } + + return description; + }, + + makeToString: function(factory, fullName) { + return factory.toString(); + } +}); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 By default, the application sets up these event listeners on the document body. However, in cases where you are embedding an Ember application inside @@ -36143,6 +51898,7 @@ DeprecatedContainer.prototype = { }); ``` +<<<<<<< HEAD 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 @@ -36323,8 +52079,234 @@ var Application = Ember.Application = Ember.Namespace.extend(Ember.DeferredMixin @method defaultRouter @return {Ember.Router} the default router - */ +======= +(function() { +/** +@module ember +@submodule ember-application +*/ +var get = Ember.get, set = Ember.set; + +function DeprecatedContainer(container) { + this._container = container; +} + +DeprecatedContainer.deprecate = function(method) { + return function() { + var container = this._container; + + Ember.deprecate('Using the defaultContainer is no longer supported. [defaultContainer#' + method + '] see: http://git.io/EKPpnA', false); + return container[method].apply(container, arguments); + }; +}; + +DeprecatedContainer.prototype = { + _container: null, + lookup: DeprecatedContainer.deprecate('lookup'), + resolve: DeprecatedContainer.deprecate('resolve'), + register: DeprecatedContainer.deprecate('register') +}; + +/** + 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: + + ```javascript + 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: + + ```javascript + 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: + + ```javascript + App = Ember.Application.create({ + customEvents: { + // add support for the paste event + paste: "paste" + } + }); + ``` + + 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: + + ```javascript + window.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 advantages of event delegation and the Ember view + layer, and a list of the event listeners that are setup by default, visit the + [Ember View Layer guide](http://emberjs.com/guides/understanding-ember/the-view-layer/#toc_event-delegation). + + ### Initializers + + Libraries on top of Ember can register additional initializers, like so: + + ```javascript + Ember.Application.initializer({ + name: "store", + + initialize: function(container, application) { + container.register('store:main', application.Store); + } + }); + ``` + + ### 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: + + ```javascript + window.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. + ``` + + @class Application + @namespace Ember + @extends Ember.Namespace +*/ + +var Application = Ember.Application = Ember.Namespace.extend(Ember.DeferredMixin, { + + /** + The root DOM element of the Application. This can be specified as an + element or a + [jQuery-compatible selector string](http://api.jquery.com/category/selectors/). + + 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. + + @property rootElement + @type DOMElement + @default 'body' + */ + rootElement: 'body', + + /** + 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. + + @property eventDispatcher + @type Ember.EventDispatcher + @default null + */ + eventDispatcher: null, + + /** + 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. For example: + + ```javascript + App = Ember.Application.create({ + customEvents: { + // add support for the paste event + paste: "paste" + } + }); + ``` + + @property customEvents + @type Object + @default null +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + */ + customEvents: null, + +<<<<<<< HEAD defaultRouter: function() { if (this.Router === false) { return; } var container = this.__container__; @@ -36409,10 +52391,116 @@ var Application = Ember.Application = Ember.Namespace.extend(Ember.DeferredMixin if (this._readinessDeferrals === 0) { Ember.run.once(this, this.didBecomeReady); +======= + // Start off the number of deferrals at 1. This will be + // decremented by the Application's own `initialize` method. + _readinessDeferrals: 1, + + init: function() { + if (!this.$) { this.$ = Ember.$; } + this.__container__ = this.buildContainer(); + + this.Router = this.defaultRouter(); + + this._super(); + + this.scheduleInitialize(); + + Ember.libraries.registerCoreLibrary('Handlebars', Ember.Handlebars.VERSION); + Ember.libraries.registerCoreLibrary('jQuery', Ember.$().jquery); + + if ( Ember.LOG_VERSION ) { + Ember.LOG_VERSION = false; // we only need to see this once per Application#init + var maxNameLength = Math.max.apply(this, Ember.A(Ember.libraries).mapBy("name.length")); + + Ember.debug('-------------------------------'); + Ember.libraries.each(function(name, version) { + var spaces = new Array(maxNameLength - name.length + 1).join(" "); + Ember.debug([name, spaces, ' : ', version].join("")); + }); + Ember.debug('-------------------------------'); } }, /** + Build the container for the current application. + + Also register a default application view in case the application + itself does not. + + @private + @method buildContainer + @return {Ember.Container} the configured container + */ + buildContainer: function() { + var container = this.__container__ = Application.buildContainer(this); + + return container; + }, + + /** + If the application has not opted out of routing and has not explicitly + defined a router, supply a default router for the application author + to configure. + + This allows application developers to do: + + ```javascript + var App = Ember.Application.create(); + + App.Router.map(function() { + this.resource('posts'); + }); + ``` + + @private + @method defaultRouter + @return {Ember.Router} the default router + */ + + defaultRouter: function() { + if (this.Router === false) { return; } + var container = this.__container__; + + if (this.Router) { + container.unregister('router:main'); + container.register('router:main', this.Router); + } + + return container.lookupFactory('router:main'); + }, + + /** + Automatically initialize the application once the DOM has + become ready. + + The initialization itself is scheduled on the actions queue + which ensures that application 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. + + @private + @method scheduleInitialize + */ + scheduleInitialize: function() { + var self = this; + + if (!this.$ || this.$.isReady) { + Ember.run.schedule('actions', self, '_initialize'); + } else { + this.$().ready(function runInitialize() { + Ember.run(self, '_initialize'); + }); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 + } + }, + + /** +<<<<<<< HEAD registers a factory for later injection Example: @@ -36474,8 +52562,54 @@ var Application = Ember.Application = Ember.Namespace.extend(Ember.DeferredMixin **/ initialize: function() { Ember.deprecate('Calling initialize manually is not supported. Please see Ember.Application#advanceReadiness and Ember.Application#deferReadiness'); +======= + Use this to defer readiness until some condition is true. + + Example: + + ```javascript + App = Ember.Application.create(); + App.deferReadiness(); + + jQuery.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. + + @method deferReadiness + */ + deferReadiness: function() { + Ember.assert("You must call deferReadiness on an instance of Ember.Application", this instanceof Ember.Application); + Ember.assert("You cannot defer readiness since the `ready()` hook has already been called.", this._readinessDeferrals > 0); + this._readinessDeferrals++; + }, + + /** + 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. + + @method advanceReadiness + @see {Ember.Application#deferReadiness} + */ + advanceReadiness: function() { + Ember.assert("You must call advanceReadiness on an instance of Ember.Application", this instanceof Ember.Application); + this._readinessDeferrals--; + + if (this._readinessDeferrals === 0) { + Ember.run.once(this, this.didBecomeReady); + } +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 }, /** +<<<<<<< HEAD @private Initialize the application. This happens automatically. @@ -36854,12 +52988,441 @@ Ember.runLoadHooks('Ember.Application', Ember.Application); (function() { +======= + registers a factory for later injection + + Example: + + ```javascript + 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}); + ``` + + @method register + @param fullName {String} type:name (e.g., 'model:user') + @param factory {Function} (e.g., App.Person) + @param options {String} (optional) + **/ + register: function() { + var container = this.__container__; + container.register.apply(container, arguments); + }, + /** + defines an injection or typeInjection + + Example: + + ```javascript + App.inject(, , ) + App.inject('model:user', 'email', 'model:email') + App.inject('model', 'source', 'source:main') + ``` + + @method inject + @param factoryNameOrType {String} + @param property {String} + @param injectionName {String} + **/ + inject: function() { + var container = this.__container__; + container.injection.apply(container, arguments); + }, + + /** + Calling initialize manually is not supported. + + Please see Ember.Application#advanceReadiness and + Ember.Application#deferReadiness. + + @private + @deprecated + @method initialize + **/ + initialize: function() { + Ember.deprecate('Calling initialize manually is not supported. Please see Ember.Application#advanceReadiness and Ember.Application#deferReadiness'); + }, + /** + Initialize the application. This happens automatically. + + Run any 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. + + @private + @method _initialize + */ + _initialize: function() { + if (this.isDestroyed) { return; } + + // At this point, the App.Router must already be assigned + if (this.Router) { + var container = this.__container__; + container.unregister('router:main'); + container.register('router:main', this.Router); + } + + this.runInitializers(); + Ember.runLoadHooks('application', this); + + // At this point, any initializers or load hooks that would have wanted + // to defer readiness have fired. In general, advancing readiness here + // will proceed to didBecomeReady. + this.advanceReadiness(); + + return this; + }, + + /** + Reset the application. This is typically used only in tests. It cleans up + the application in the following order: + + 1. Deactivate existing routes + 2. Destroy all objects in the container + 3. Create a new application container + 4. Re-route to the existing url + + Typical Example: + + ```javascript + + var App; + + Ember.run(function() { + App = Ember.Application.create(); + }); + + module("acceptance test", { + setup: function() { + App.reset(); + } + }); + + test("first test", function() { + // App is freshly reset + }); + + test("first 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. + + ```javascript + + var App; + + Ember.run(function() { + App = Ember.Application.create(); + }); + + module("acceptance test", { + setup: function() { + Ember.run(function() { + App.reset(); + App.deferReadiness(); + }); + } + }); + + test("first test", function() { + ok(true, 'something before app is initialized'); + + Ember.run(function() { + App.advanceReadiness(); + }); + ok(true, 'something after app is initialized'); + }); + ``` + + @method reset + **/ + reset: function() { + this._readinessDeferrals = 1; + + function handleReset() { + var router = this.__container__.lookup('router:main'); + router.reset(); + + Ember.run(this.__container__, 'destroy'); + + this.buildContainer(); + + Ember.run.schedule('actions', this, function() { + this._initialize(); + }); + } + + Ember.run.join(this, handleReset); + }, + + /** + @private + @method runInitializers + */ + runInitializers: function() { + var initializers = get(this.constructor, 'initializers'), + container = this.__container__, + graph = new Ember.DAG(), + namespace = this, + name, initializer; + + for (name in initializers) { + initializer = initializers[name]; + graph.addEdges(initializer.name, initializer.initialize, initializer.before, initializer.after); + } + + graph.topsort(function (vertex) { + var initializer = vertex.value; + Ember.assert("No application initializer named '"+vertex.name+"'", initializer); + initializer(container, namespace); + }); + }, + + /** + @private + @method didBecomeReady + */ + didBecomeReady: function() { + this.setupEventDispatcher(); + this.ready(); // user hook + this.startRouting(); + + if (!Ember.testing) { + // Eagerly name all classes that are already loaded + Ember.Namespace.processAll(); + Ember.BOOTED = true; + } + + this.resolve(this); + }, + + /** + Setup up the event dispatcher to receive events on the + application's `rootElement` with any registered + `customEvents`. + + @private + @method setupEventDispatcher + */ + setupEventDispatcher: function() { + var customEvents = get(this, 'customEvents'), + rootElement = get(this, 'rootElement'), + dispatcher = this.__container__.lookup('event_dispatcher:main'); + + set(this, 'eventDispatcher', dispatcher); + dispatcher.setup(customEvents, rootElement); + }, + + /** + trigger a new call to `route` whenever the URL changes. + If the application has a router, use it to route to the current URL, and + + @private + @method startRouting + @property router {Ember.Router} + */ + startRouting: function() { + var router = this.__container__.lookup('router:main'); + if (!router) { return; } + + router.startRouting(); + }, + + handleURL: function(url) { + var router = this.__container__.lookup('router:main'); + + router.handleURL(url); + }, + + /** + Called when the Application has become ready. + The call will be delayed until the DOM has become ready. + + @event ready + */ + ready: Ember.K, + + /** + @deprecated Use 'Resolver' instead + Set this to provide an alternate class to `Ember.DefaultResolver` + + + @property resolver + */ + resolver: null, + + /** + Set this to provide an alternate class to `Ember.DefaultResolver` + + @property resolver + */ + Resolver: null, + + willDestroy: function() { + Ember.BOOTED = false; + + this.__container__.destroy(); + }, + + initializer: function(options) { + this.constructor.initializer(options); + } +}); + +Ember.Application.reopenClass({ + initializers: {}, + initializer: function(initializer) { + // If this is the first initializer being added to a subclass, we are going to reopen the class + // to make sure we have a new `initializers` object, which extends from the parent class' using + // prototypal inheritance. Without this, attempting to add initializers to the subclass would + // pollute the parent class as well as other subclasses. + if (this.superclass.initializers !== undefined && this.superclass.initializers === this.initializers) { + this.reopenClass({ + initializers: Ember.create(this.initializers) + }); + } + + Ember.assert("The initializer '" + initializer.name + "' has already been registered", !this.initializers[initializer.name]); + Ember.assert("An initializer cannot be registered with both a before and an after", !(initializer.before && initializer.after)); + Ember.assert("An initializer cannot be registered without an initialize function", Ember.canInvoke(initializer, 'initialize')); + + this.initializers[initializer.name] = initializer; + }, + + /** + This creates a container with the default Ember naming conventions. + + It also configures the container: + + * 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` and `controllers` + 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 + + @private + @method buildContainer + @static + @param {Ember.Application} namespace the application to build the + container for. + @return {Ember.Container} the built container + */ + buildContainer: function(namespace) { + var container = new Ember.Container(); + + Ember.Container.defaultContainer = new DeprecatedContainer(container); + + container.set = Ember.set; + container.resolver = resolverFor(namespace); + container.normalize = container.resolver.normalize; + container.describe = container.resolver.describe; + container.makeToString = container.resolver.makeToString; + + container.optionsForType('component', { singleton: false }); + container.optionsForType('view', { singleton: false }); + container.optionsForType('template', { instantiate: false }); + container.optionsForType('helper', { instantiate: false }); + + container.register('application:main', namespace, { instantiate: false }); + + container.register('controller:basic', Ember.Controller, { instantiate: false }); + container.register('controller:object', Ember.ObjectController, { instantiate: false }); + container.register('controller:array', Ember.ArrayController, { instantiate: false }); + container.register('route:basic', Ember.Route, { instantiate: false }); + container.register('event_dispatcher:main', Ember.EventDispatcher); + + container.register('router:main', Ember.Router); + container.injection('router:main', 'namespace', 'application:main'); + + container.injection('controller', 'target', 'router:main'); + container.injection('controller', 'namespace', 'application:main'); + + container.injection('route', 'router', 'router:main'); + + return container; + } +}); + +/** + This function defines the default lookup rules for container lookups: + + * templates are looked up on `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. + + @private + @method resolverFor + @param {Ember.Namespace} namespace the namespace to look for classes + @return {*} the resolved value for a given lookup +*/ +function resolverFor(namespace) { + if (namespace.get('resolver')) { + Ember.deprecate('Application.resolver is deprecated in favor of Application.Resolver', false); + } + + var ResolverClass = namespace.get('resolver') || namespace.get('Resolver') || Ember.DefaultResolver; + var resolver = ResolverClass.create({ + namespace: namespace + }); + + function resolve(fullName) { + return resolver.resolve(fullName); + } + + resolve.describe = function(fullName) { + return resolver.lookupDescription(fullName); + }; + + resolve.makeToString = function(factory, fullName) { + return resolver.makeToString(factory, fullName); + }; + + resolve.normalize = function(fullName) { + if (resolver.normalize) { + return resolver.normalize(fullName); + } else { + Ember.deprecate('The Resolver should now provide a \'normalize\' function', false); + return fullName; + } + }; + + return resolve; +} + +Ember.runLoadHooks('Ember.Application', Ember.Application); +>>>>>>> 60d42738019a33cc73008e81dd0a80eaa6eac147 })(); (function() { +<<<<<<< HEAD /** @module ember @submodule ember-application @@ -36929,8 +53492,69 @@ Ember.ControllerMixin.reopen({ // if needs then initialize controllers proxy get(this, 'controllers'); +======= + +})(); + + + +(function() { +/** +@module ember +@submodule ember-application +*/ + +var get = Ember.get, set = Ember.set; + +function verifyNeedsDependencies(controller, container, needs) { + var dependency, i, l, missing = []; + + for (i=0, l=needs.length; i
+
@@ -6,7 +6,7 @@ {{t profiles.show.github}}:diff --git a/assets/scripts/app/templates/queues/list.hbs b/assets/scripts/app/templates/queues/list.hbs index fe08ffd2..b652c221 100644 --- a/assets/scripts/app/templates/queues/list.hbs +++ b/assets/scripts/app/templates/queues/list.hbs @@ -2,16 +2,16 @@ {{#each queue in controller}}
Travis
-{{/linkTo}} +{{/link-to}}-
-
{{#collection Travis.AccountsListView contentBinding="controller"}}
- {{#linkTo "account.index" view.account class="name"}}{{view.name}}{{/linkTo}}
+ {{#link-to "account.index" view.account class="name"}}{{view.name}}{{/link-to}}
Repositories: {{view.account.reposCount}} diff --git a/assets/scripts/app/templates/profile/tabs.hbs b/assets/scripts/app/templates/profile/tabs.hbs index 8f770575..6afb10c8 100644 --- a/assets/scripts/app/templates/profile/tabs.hbs +++ b/assets/scripts/app/templates/profile/tabs.hbs @@ -1,17 +1,17 @@
-
-
-
{{#each hook in hooks}}
-