DataTable design overview
=========================

These are my early thoughts on how to structure DataTable in 3.5.0.  Feedback is welcome in the comments.

## Instantiable classes out of the box
```
new Y.DataTable({...});
new Y.DataTable.Base({...});
```

## Class generation
```
Y.DataTable.Base = Y.Base.create('datatable', Y.Widget, [Y.DataTable.Core]);
Y.DataTable = Y.mix(
    Y.Base.create('datatable', Y.DataTable.Base, []),
    Y.DataTable, true);
```

Class extensions CAN (if non-invasive by default)

```
Y.Base.mix(Y.DataTable, [ Y.DataTable.Sortable ]);
```

## Primary configuration
```
new Y.DataTable({
    data: [{ ... }, { ... }, ... ]
    data: modelList
    data: {
        source: url, function, xml
        type: 'json'
        schema: { ... }        
    }

    columns: (optional) [ key, key, { key: key, config: stuff, ... }, ... ]

    recordType: (optional) ModelClass

    headerView: (optional) ViewClass
    bodyView: (optional) ViewClass
    footerView: (optional) ViewClass

    summary: (optional) 'string'
    caption: (optional) 'string'
});
```

## Instance structure
```
instance
    .data = modelListInstance

    .head = viewInstance
    .body = viewInstance
    .foot = viewInstance
```

## Component classes

 * `Y.DataTable.Core`

    Everything added to Y.Widget to make DataTable.Base

 * `Y.DataTable.HeaderView`
 * `Y.DataTable.BodyView`
 * `Y.DataTable.FooterView`

    Used by DataTable(.Base) to render the table contents.

    Referenced via configuration, not composition.

 * `Y.DataTable.Source`

    Optional class extension.

    Adds support `data` config to generate ML with DataSource load.

 * `Y.DataTable.Scrollable`

    Optional class extension.

    Adds support for scrolling table.  May be used to create a third instantiable class.

 * `Y.DataTable.ScrollingBodyView`

    Used in place of DataTable.BodyView to render the scrolling table. May not be necessary?

 * `Y.DataTable.Sortable`

    Adds support for sorting headers and sortable config.

## Render lifecycle
`instance.render(...)`

 1. build <table> (markup only or off DOM node?)
 2. instantiate header, body, footer views passing
    1. the DT instance
    2. the created table?
    3. the `data` ModelList?
 3. call each view's render()

Logic for reacting to user input is moved to the View classes

_Concern: string based rendering would have viewX.render() return a string or populate a property, but it has requirements of the DT renderer_

## Load lifecycle
`instance.load(...)`

Pass through to this.data.load(...).  Let the ModelList be responsible for data interaction.

## Default Model generation

 * No ModelList is provided in `data` configuration AND
 * No `recordType` is provided in configuration

 1. Use the first item in the data array to build ATTRS and Y.Base.create(...)
 2. If data is empty, use columns?