Create MongoModel

There isn't much here in the way of functionality. At this point there is a `MongoModel` class, which is of type `MongoModelMetaClass`. The meta class is used primarily to associate the `Meta` class with subclasses; it checks for the required `collection` attribute and provides a default `field_map` attribute if none has been provided.

At this point in time the functionality of `MongoModel` is fairly limited. All that has been provided is the ability to get, set, and remove attributes that are meant to be part of the base document. There is no database interaction yet, so this commit is pretty useless, but it's a good point in time to capture in case the database interaction goes down a bad path.
Add basic connection behavior

This is by no means intended as the final state of connection to a database. It is, however, enough to get started building out the model functionality. A database connection can be opened through `connect()` and can be retrieved later on with `get_database()`.

I imagine that at some point I'll store multiple databases. I'd also like to add the ability to use existing connections. This would be useful for me as I use Flask-PyMongo in a lot of projects.
Add the ability to save

Just like all of previous other commits, this isn't necessarily meant to be the final version of this, but it's the first pass at saving data to the database.

In order to accomplish this, all models are given `default` as the name of the database--this is actually only done when no value is set in the model, but names other than default aren't supported yet--in the meta class, and the collection is associated with the model in its `__init__()`.

Right now `created` and `modified` are more or less forced upon each document. I'll probably add some settings to `Meta` to optionally override this behavior.
Add some tests

I think this is the beginning of a beautiful friendship.
Add custom exceptions for document retrieval

The `MultipleDocumentsFound` and `NoDocumentFound` exceptions can be used when querying for documents to send meaningful results to anyone querying the database.
Correct the document update

The document replacement in `MongoModel.save()` was being performed as an atomic update of any fields still associated with the document. This meant that any fields removed through `del` would be left behind.

By removing `$set` from the update, document replacement is used instead.
Remove ** from docstring

It appears that Sphinx sees `**` in a docstring as the beginning of a bit of boldface text. That makes sense because that is the delimiter used by reST for bold. While I had intended it to denote a keyword arguments dict.

Because Sphinx was throwing a warning for each unclosed `**`, I'm opting to remove them from the docstring.
Move association of collection to a decorator

When adding the saving ability in d8daa4e, I decided it would be a good idea to associate the collection object with the model at the time of instantiation. That way the collection would only be loaded up if it was actually being used.

While working on the document retrieval, however, I realized there was a major flaw in this approach: methods like `get()` would need to be class methods, and therefore not be used in conjunction with an instantiated object.

By creating the `requires_database` decorator, any method that will need to use the database can make sure the appropriate type, be it a class or an instance, will have a `db` attribute before trying to access it.
Add a get method to models

The `get()` method will return a single document matching the query passed into it through keyword arguments. If no matching documents are found, `NoDocumentFound` will be raised. If more than one matching document is found, `MultipleDocumentsFound` will be raised.

In order to check for the latter exception, PyMongo's `find()` method needs to be used instead of its `find_one()` method as `find_one()` will return the first matching document instead of the only matching document.

`get()` will return an instantiated object with the document assigned to `_meta.document`.
Remove an unused import

`get_database()` was no longer needed with 4263961. I should have removed it then.
Tidying up
Restore db as an attribute without the use of a decorator

I really wasn't happy with the decorator approach for making sure that `db` was assigned to the `_meta` attribute of both classes and instances, especially because the decorator's arguments replaced any wrapped method's when generating Sphinx docs or using `help()`.

It is now back to being a property, this time associated with the model at creation time. This works because a lambda is used so that the collection is only accessed when needed. In order to achieve this, `property` is subclassed as `Property` with a custom `__get__()` method that will call the class method surrounding the lambda.

This is essentially a revert of 4263961.

Thanks to @vincent-kuwornu for helping me get this working.
Make __init__()'s docstring consistent with the get()'s

The Sphinx `:class:` prefix should always be used for consistency.
Add a delete method

The `delete()` method will delete the document associated with the instance.

If the instance has no `_id` attribute, a `TypeError` will be raised. This is most likely to happen if the document has never been saved.
PEP8

PEP8 likes long wrapping strings to be capped at 72 characters.
Rename the delete method to remove

MongoDB calls its delete method `remove`. In order to provide a more consistent experience for developers, `delete()` is being renamed to `remove()`.

Most model mappers, on the other hand, seem to favor the name `delete`. For this reason, `delete()` is being retained, but as an alias for `remove()`.
Add version to delete()'s docstring
Add ability to save only select fields

When updating documents, you don't usually want to replace the entire document when all you want to update are a subset of its fields. This is where the `$set` operator comes into play. The `save_fields()` method takes a list of fields to update with `$set`.

Unlike `save()`, the `modified` field will not be updated. I'm still on the fence about this one. My guess is that I'll change my mind before this ships.
Add ability to remove only select fields

When updating documents, you don't usually want to replace the entire document when all you want to remove are a subset of its fields. This is where the `$unset` operator comes into play. The `remove_fields()` method takes a list of fields to remove from the document with `$unset`.

Just as with ae0e7ea, the `modified` field will not be updated and I'm on the fence about whether or not that should be the case.
Change location of the meta document assignment

I think I learned an important lesson today: it appears that assigning an empty dictionary in `__new__()` is like using an empty dictionary as the default value for a parameter, the dictionary will persist throughout the life of the application.

`_meta.document` is now given its value in `__init__()` instead. This way each instance will have its own version of the dictionary.