YUI.add('model', function (Y, NAME) {

/**

Attribute-based data model with APIs for getting, setting, validating, and

syncing attribute values, as well as events for being notified of model changes.

@module app

@submodule model

@since 3.4.0

**/

/**

Attribute-based data model with APIs for getting, setting, validating, and

syncing attribute values, as well as events for being notified of model changes.

In most cases, you'll want to create your own subclass of `Y.Model` and

customize it to meet your needs. In particular, the `sync()` and `validate()`

methods are meant to be overridden by custom implementations. You may also want

to override the `parse()` method to parse non-generic server responses.

@class Model

@constructor

@extends Base

@since 3.4.0

**/

var GlobalEnv = YUI.namespace('Env.Model'),

    Lang      = Y.Lang,

    YArray    = Y.Array,

    YObject   = Y.Object,

    /**

    Fired when one or more attributes on this model are changed.

    @event change

    @param {Object} changed Hash of change information for each attribute that

        changed. Each item in the hash has the following properties:

      @param {Any} changed.newVal New value of the attribute.

      @param {Any} changed.prevVal Previous value of the attribute.

      @param {String|null} changed.src Source of the change event, if any.

    **/

    EVT_CHANGE = 'change',

    /**

    Fired when an error occurs, such as when the model doesn't validate or when

    a sync layer response can't be parsed.

    @event error

    @param {Any} error Error message, object, or exception generated by the

      error. Calling `toString()` on this should result in a meaningful error

      message.

    @param {String} src Source of the error. May be one of the following (or any

      custom error source defined by a Model subclass):

      * `load`: An error loading the model from a sync layer. The sync layer's

        response (if any) will be provided as the `response` property on the

        event facade.

      * `parse`: An error parsing a JSON response. The response in question will

        be provided as the `response` property on the event facade.

      * `save`: An error saving the model to a sync layer. The sync layer's

        response (if any) will be provided as the `response` property on the

        event facade.

      * `validate`: The model failed to validate. The attributes being validated

        will be provided as the `attributes` property on the event facade.

    **/

    EVT_ERROR = 'error',

    /**

    Fired after model attributes are loaded from a sync layer.

    @event load

    @param {Object} parsed The parsed version of the sync layer's response to

        the load request.

    @param {any} response The sync layer's raw, unparsed response to the load

        request.

    @since 3.5.0

    **/

    EVT_LOAD = 'load',

    /**

    Fired after model attributes are saved to a sync layer.

    @event save

    @param {Object} [parsed] The parsed version of the sync layer's response to

        the save request, if there was a response.

    @param {any} [response] The sync layer's raw, unparsed response to the save

        request, if there was one.

    @since 3.5.0

    **/

    EVT_SAVE = 'save';

function Model() {

    Model.superclass.constructor.apply(this, arguments);

}

Y.Model = Y.extend(Model, Y.Base, {

    // -- Public Properties ----------------------------------------------------

    /**

    Hash of attributes that have changed since the last time this model was

    saved.

    @property changed

    @type Object

    @default {}

    **/

    /**

    Name of the attribute to use as the unique id (or primary key) for this

    model.

    The default is `id`, but if your persistence layer uses a different name for

    the primary key (such as `_id` or `uid`), you can specify that here.

    The built-in `id` attribute will always be an alias for whatever attribute

    name you specify here, so getting and setting `id` will always behave the

    same as getting and setting your custom id attribute.

    @property idAttribute

    @type String

    @default `'id'`

    **/

    idAttribute: 'id',

    /**

    Hash of attributes that were changed in the last `change` event. Each item

    in this hash is an object with the following properties:

      * `newVal`: The new value of the attribute after it changed.

      * `prevVal`: The old value of the attribute before it changed.

      * `src`: The source of the change, or `null` if no source was specified.

    @property lastChange

    @type Object

    @default {}

    **/

    /**

    Array of `ModelList` instances that contain this model.

    When a model is in one or more lists, the model's events will bubble up to

    those lists. You can subscribe to a model event on a list to be notified

    when any model in the list fires that event.

    This property is updated automatically when this model is added to or

    removed from a `ModelList` instance. You shouldn't alter it manually. When

    working with models in a list, you should always add and remove models using

    the list's `add()` and `remove()` methods.

    @example Subscribing to model events on a list:

        // Assuming `list` is an existing Y.ModelList instance.

        list.on('*:change', function (e) {

            // This function will be called whenever any model in the list

            // fires a `change` event.

            //

            // `e.target` will refer to the model instance that fired the

            // event.

        });

    @property lists

    @type ModelList[]

    @default `[]`

    **/

    // -- Protected Properties -------------------------------------------------

    /**

    This tells `Y.Base` that it should create ad-hoc attributes for config

    properties passed to Model's constructor. This makes it possible to

    instantiate a model and set a bunch of attributes without having to subclass

    `Y.Model` and declare all those attributes first.

    @property _allowAdHocAttrs

    @type Boolean

    @default true

    @protected

    @since 3.5.0

    **/

    _allowAdHocAttrs: true,

    /**

    Total hack to allow us to identify Model instances without using

    `instanceof`, which won't work when the instance was created in another

    window or YUI sandbox.

    @property _isYUIModel

    @type Boolean

    @default true

    @protected

    @since 3.5.0

    **/

    _isYUIModel: true,

    // -- Lifecycle Methods ----------------------------------------------------

    initializer: function (config) {

        this.changed    = {};

        this.lastChange = {};

        this.lists      = [];

    },

    // -- Public Methods -------------------------------------------------------

    /**

    Destroys this model instance and removes it from its containing lists, if

    any.

    The _callback_, if one is provided, will be called after the model is

    destroyed.

    If `options.remove` is `true`, then this method delegates to the `sync()`

    method to delete the model from the persistence layer, which is an

    asynchronous action. In this case, the _callback_ (if provided) will be

    called after the sync layer indicates success or failure of the delete

    operation.

    @method destroy

    @param {Object} [options] Sync options. It's up to the custom sync

        implementation to determine what options it supports or requires, if

        any.

      @param {Boolean} [options.remove=false] If `true`, the model will be

        deleted via the sync layer in addition to the instance being destroyed.

    @param {Function} [callback] Called after the model has been destroyed (and

        deleted via the sync layer if `options.remove` is `true`).

      @param {Error|null} callback.err If an error occurred, this parameter will

        contain the error. Otherwise _err_ will be `null`.

    @chainable

    **/

    destroy: function (options, callback) {

        var self = this;

        // Allow callback as only arg.

        if (typeof options === 'function') {

            callback = options;

            options  = null;

        }

        self.onceAfter('destroy', function () {

            function finish(err) {

                if (!err) {

                    YArray.each(self.lists.concat(), function (list) {

                        list.remove(self, options);

                    });

                }

                callback && callback.apply(null, arguments);

            }

            if (options && (options.remove || options['delete'])) {

                self.sync('delete', options, finish);

            } else {

                finish();

            }

        });

        return Model.superclass.destroy.call(self);

    },

    /**

    Returns a clientId string that's unique among all models on the current page

    (even models in other YUI instances). Uniqueness across pageviews is

    unlikely.

    @method generateClientId

    @return {String} Unique clientId.

    **/

    generateClientId: function () {

        GlobalEnv.lastId || (GlobalEnv.lastId = 0);

        return this.constructor.NAME + '_' + (GlobalEnv.lastId += 1);

    },

    /**

    Returns the value of the specified attribute.

    If the attribute's value is an object, _name_ may use dot notation to

    specify the path to a specific property within the object, and the value of

    that property will be returned.

    @example

        // Set the 'foo' attribute to an object.

        myModel.set('foo', {

            bar: {

                baz: 'quux'

            }

        });

        // Get the value of 'foo'.

        myModel.get('foo');

        // => {bar: {baz: 'quux'}}

        // Get the value of 'foo.bar.baz'.

        myModel.get('foo.bar.baz');

        // => 'quux'

    @method get

    @param {String} name Attribute name or object property path.

    @return {Any} Attribute value, or `undefined` if the attribute doesn't

      exist.

    **/

    // get() is defined by Y.Attribute.

    /**

    Returns an HTML-escaped version of the value of the specified string

    attribute. The value is escaped using `Y.Escape.html()`.

    @method getAsHTML

    @param {String} name Attribute name or object property path.

    @return {String} HTML-escaped attribute value.

    **/

    getAsHTML: function (name) {

        var value = this.get(name);

        return Y.Escape.html(Lang.isValue(value) ? String(value) : '');

    },

    /**

    Returns a URL-encoded version of the value of the specified string

    attribute. The value is encoded using the native `encodeURIComponent()`

    function.

    @method getAsURL

    @param {String} name Attribute name or object property path.

    @return {String} URL-encoded attribute value.

    **/

    getAsURL: function (name) {

        var value = this.get(name);

        return encodeURIComponent(Lang.isValue(value) ? String(value) : '');

    },

    /**

    Returns `true` if any attribute of this model has been changed since the

    model was last saved.

    New models (models for which `isNew()` returns `true`) are implicitly

    considered to be "modified" until the first time they're saved.

    @method isModified

    @return {Boolean} `true` if this model has changed since it was last saved,

      `false` otherwise.

    **/

    isModified: function () {

        return this.isNew() || !YObject.isEmpty(this.changed);

    },

    /**

    Returns `true` if this model is "new", meaning it hasn't been saved since it

    was created.

    Newness is determined by checking whether the model's `id` attribute has

    been set. An empty id is assumed to indicate a new model, whereas a

    non-empty id indicates a model that was either loaded or has been saved

    since it was created.

    @method isNew

    @return {Boolean} `true` if this model is new, `false` otherwise.

    **/

    isNew: function () {

        return !Lang.isValue(this.get('id'));

    },

    /**

    Loads this model from the server.

    This method delegates to the `sync()` method to perform the actual load

    operation, which is an asynchronous action. Specify a _callback_ function to

    be notified of success or failure.

    A successful load operation will fire a `load` event, while an unsuccessful

    load operation will fire an `error` event with the `src` value "load".

    If the load operation succeeds and one or more of the loaded attributes

    differ from this model's current attributes, a `change` event will be fired.

    @method load

    @param {Object} [options] Options to be passed to `sync()` and to `set()`

      when setting the loaded attributes. It's up to the custom sync

      implementation to determine what options it supports or requires, if any.

    @param {Function} [callback] Called when the sync operation finishes.

      @param {Error|null} callback.err If an error occurred, this parameter will

        contain the error. If the sync operation succeeded, _err_ will be

        `null`.

      @param {Any} callback.response The server's response. This value will

        be passed to the `parse()` method, which is expected to parse it and

        return an attribute hash.

    @chainable

    **/

    load: function (options, callback) {

        var self = this;

        // Allow callback as only arg.

        if (typeof options === 'function') {

            callback = options;

            options  = {};

        }

        options || (options = {});

        self.sync('read', options, function (err, response) {

            var facade = {

                    options : options,

                    response: response

                },

                parsed;

            if (err) {

                facade.error = err;

                facade.src   = 'load';

                self.fire(EVT_ERROR, facade);

            } else {

                // Lazy publish.

                if (!self._loadEvent) {

                    self._loadEvent = self.publish(EVT_LOAD, {

                        preventable: false

                    });

                }

                parsed = facade.parsed = self._parse(response);

                self.setAttrs(parsed, options);

                self.changed = {};

                self.fire(EVT_LOAD, facade);

            }

            callback && callback.apply(null, arguments);

        });

        return self;

    },

    /**

    Called to parse the _response_ when the model is loaded from the server.

    This method receives a server _response_ and is expected to return an

    attribute hash.

    The default implementation assumes that _response_ is either an attribute

    hash or a JSON string that can be parsed into an attribute hash. If

    _response_ is a JSON string and either `Y.JSON` or the native `JSON` object

    are available, it will be parsed automatically. If a parse error occurs, an

    `error` event will be fired and the model will not be updated.

    You may override this method to implement custom parsing logic if necessary.

    @method parse

    @param {Any} response Server response.

    @return {Object} Attribute hash.

    **/

    parse: function (response) {