Add Travis-CI building and badge
0.6.19 Version Rollover
Fixes the issue with clients not initialiy syncing up correctly

UCE - Fixes 2263 and there was a bug listed in VWF for this as well, but can't find the number
Update JQuery and JQuery UI to latest baseline. Refs #2660
Upgrading Bootstrap to latest baseline
Revert "Upgrading Bootstrap to latest baseline"
Too many site issues for site when we are reworking the site structure itself on another branch.
This reverts commit a9db4520d28d8e5640df96a132eea648e523effc.
Update KimRayValve to kimray. Closes #2952
Update README to the ideal.
Fixed documentation typos.  Refs #2855
Removed the extra css file in the js folder and updated admin.html.erb to include new jquery minfile. Refs #2660
Update node.js websocket URL format to include the app name and instance id
Change parseSocketUrl to get the application from the socket URL instead of the referrer URL
Add an ideal and a realistic README rewrite.
Merge branch 'development' into branch/readme-rewrite
Don't look for a specific number of digits for the time parameter
Begin moving the node registry to the kernel from model/object.

The kernel has been delegating knowledge of the node graph and node
change flags to the model/object driver. But this doesn't work well
since model/object isn't normally notified about changes to a node until
after the other drivers. Extra calls into model/object are in place so
that preceding drivers can ask about a node's ancestors or prototypes in
creatingNode, for example, but this is an abuse of the driver API.

Tracking changes in model/object also requires extra work since
model/object doesn't see changes to properties handled by other drivers.
Change flags may not be set in some cases, which can cause replication
errors.

The kernel will be better off if it manages this data itself. With a
local registry, it will be easier for the kernel to register a new node
just before it is first exposed to any driver and unregister a deleted
node right after its last driver message.

This commit creates the node and per-node property registries, and
records per-node property change flags.

Fixes #1815.
Only record changed properties in `getState`.

Previously, after any property changed on a patchable node, `getNode`
(which feeds `getState`) would include all of the node's properties in
the patch. Now, only the properties that actually changed are included.

Fixes #2236.
Track kernel re-entry originating with aggregate property sets and gets.

Set the markers so that if `kernel.setProperties` or
`kernel.getProperties` set or get a property having an accessor function
that refers back to the property, or if a driver calls back to the
kernel to refer to the property, `setProperty` or `getProperty` will
start the action with the correct driver.

Previously, only actions originating with `setProperty` or `getProperty`
were tracked this way. This commit adds tracking for actions originating
in `setProperties` and `getProperties` as well.
Allow descriptors to declare properties without assigning a value.

`kernel.createProperty( nodeID, name, undefined )` will create a new
property without assigning an initial value. This can be useful if the
property should have the value `undefined` or if a driver binds the node
to an internal object that already has a value (such as `transform` in a
Collada object).

But since YAML and JSON have no representation for `undefined`, there
has been no way to do the same thing using a component descriptor.

This commit extends the detailed initializer format slightly to allow an
`undefined` value to be explicitly declared:

    properties:
	  alpha:
	    "alpha"
	  beta:
	    value: "beta"
	  gamma:
	    undefined: true

`alpha` is created with the value `"alpha"` using a simple initializer.
`beta` is created with the value `"beta"` using a detailed initializer.
And `gamma` is created using a detailed initializer with the initial
value undefined.
Detect delegation during property assignments.

When a property assignment is executing, execution should stop once the
property is assigned. If the kernel is configured with drivers A and B,
for example, the kernel shouldn't call B if A handles the assignment.

The existing implmentation only does this correctly when a property
accepts the assignment directly or when it delegates to itself (such as
with `set: this.name = parseInt( value )`). If the assignment delegates
to another property, this isn't considered assignment, and execution on
the initiating property continues with the remaining drivers.

This causes extra work when invoking drivers lower in the stack for
properties that have already been delegated, change flags to be set on
nodes that haven't actually changed (for example n, in the case of n.p
=> m.q), and properties delegating to other propertes to be incorrectly
included in change sets (for example p in the case of n.p => n.q).

This commit detects delegation to other properties by watching for other
assignments made while executing `setProperty`. When delegation is
detected, execution completes just as it would if a driver accepted an
assignment directly.

Also, lots of tests.

Closes #1635.