Renamed extras directory to data

This directory can no longer be said to just contain random extra files
that are optionally needed to use the software.  These are data files
and we should call a duck a duck.
Moved data files to folders based on source

Frictionless data packages are folder based so the first step to
implementing them is to move all data files into folders based on their
source.
Created frictionless data package definition files

Adding these files makes these folders into frictionless data packages.
The software now just needs modified to read these data package files
rather than individual data files.
Added Sources to seanreynolds and phb data packages

This should allow people to more easily verify the license data.
Added type param to data packages

I've deviated a bit from the frictionless data packaging standard and
added a type param to the resource definitions. This will allow us to
specify more than one (for example) class file in a package.  Doing this
allows package maintainers to split files into manageable chunks and to
provide more descriptive file names.
Data package definitions now loaded

Data package definitions are now loaded into the application.  The data
files themselves are still now though.
Most getter functions defined for packageFile

Most of the getter functions for packageFile are now defined.  Left to
do are Licenses, Maintainers, and Resources.  I've also added code to
list out the loaded packages in the Advanced Output area.
Remaining getter methods for packageFile completed. dataFile class
defined.

packageFile now has getter methods for Licenses, Maintainers, and
Resources.  It may be possible to make a method that combines License
and Licenses into one pre-formatted output.  It may be worth making a
method that gives a pre-formatted output for Maintainers as well.

The first version of the dataFiles class was also defined in this
commit.  Currently it only keeps track of the data it was passed. The
datafiles will be lazy initialized the first time their data is
requested.
Merge branch 'master' into package

Conflicts:
	base.js

Evil merging master into package.  Needed most recent commit on Master
branch where appLocation was modified to include a calculation of
window.path.  This commit is an evil merge because it also modifies all
functions that previously passed around path/location to instead just
grab window.path.
Removing test from load.json

The last line of load.json tried to load a package named test.  This
package does not exist and was only there to test the error handling
code of the package loader.  Since it appears to work, I am removing
this line.  There is no reason to do an extra GET request anymore.
Indented some advanced log output

Intended list of package files being loaded for readability purposes.
dataFile objects now get correct path information.

All of the information required for the correct path to the data files
to be found is now passed to the dataFile object.  Previous behaviour
was to just pass the filename, which was horribly inadequate.
Fixed minor bug in path for dataFile class and added getData method.

There was a minor bug in the path calculation for the dataFile class
that resulted in the .json file extension being applied twice, which has
now been resolved.  Additionally the getData method on the dataFile
class has been implemented.  It returns a promise object that can be
acted upon once the data has loaded.
Added comments to identify sections of code containing class definitions

Added sections for two types of class definitions, those related to the
packaging system and those related to actually using the data that is
stored in the packages.  This should make finding those classes a little
bit easier.
packageFileList now uses promises and load.json is not hardcoded

When instantiating a new packageFileList it will check to see if it was
passed a load.json location.  If it was, it will attempt to load
packages from that directory, if not it defaults to data/load.json.  It
will begin to load packages immediately, but the package list can't be
used until all of the packages are loaded.  A new method named
getLoadedPackages has been added that returns a promise that is
fulfilled when all of the packages have been loaded.
packageFile now uses promises

The packageFile class now uses promises to ease loading of individual
packages.  The packageFileList class has been modified accordingly.
packageFile getter methods now only exist after loading is complete

The packageFile class has been modified to mutate itself after the
package has finished loading adding all of the getter methods.  Previous
behaviour was to have them available from instantiation which may have
lead to trying to use them before the data they pull from was available.
Created dataStore parent and began work on namesDataStore

Created a prototype object called dataStore that all data stores will
inherit from.  Created namesDataStore class and created a getFirstName
method within it.  Also wrote unweightedRandom function and added a few
more lines to beginning of the file to initialize things.
Modified packageFileList to use a when promise

Simplified some of the code in packageFileList by implementing a when
promise.
Merge branch 'jsonCleanup' into package