The function that was called `test_flatten_ignores_serializables_by_default` has
been updated into `test_flatten_serializables_on_by_default`.  This is part of a
push towards having the treatment of serializables be handled entirely through
the `Role` system.

Subsequent commits put add the code that makes this test pass.

The serializable decorator for `xp_level` hasbeen modified to say that the function
represents a ModelType(ExperienceLevel).

This is my first interaction with the new syntax and, while I like it, I feel it
is a little unwieldy.

For example, the code in the test specifically looks like this:

    @serializable(type=ModelType(ExperienceLevel))
    def xp_level(self):
        return ExperienceLevel(dict(level=self.total_points * 2, title="Best"))

I think I would prefer something like this.

    @serializable(ModelType(ExperienceLevel))
    def xp_level(self):
        model_data = {
            'level': self.total_points * 2,
            'title': "Best",
        }
        return model_data

The type represented by the serialization could then expressed once and the
wrapped function itself only has to return the arguments used for instantiation.

Anyway, thinking out loud in addition to explaining a change to the tests.
There are two things going in this changeset together.  My mind wandered a
a little.

First, a function called `allow_none` has been defined to consolidate where
this logic lives in a single function.  The function takes two arguments, a
class and a field.  It sets it's default value to the value found on the class
but checks the field to see if an override was specified.

Second, the `include_serializables` flag has been removed.  This simplifies
the interface to `to_primitive` and centralizes the method used for serializing
a field, or not serializing a field, in the `Role` system which makes it easier
to reason about.
Moved `convert` to an implementation outside the `Model` class
Added a contrib directory and populating it with a type to handle Mongo ObjectId fields
Forgot an __init__ for contrib dir
Adjusted the behavior of how None is handled during validation.  The previous
behavior was incorrect and lead to empty fields breaking validation for fields
that were not required.

The correct behavior, which this patch provides, is to throw an error only for
required fields that are missing.
Adjusted the validation step once more to skip converting a field when the value
is `None`.  The validate function is still called to ensure further validation checks
take place.

This commit also makes `required=True` a required flag if a value of None is not
allowed.

For example, this code used to produce an error if x was None.  But it's not required.

    class Foo(Model):
        x = ListType(StringType(), min_size=1)

To properly throw an error now, use code like this:

    class Foo(Model):
        x = ListType(StringType(), min_size=1, required=True)
License no longer says Dictshield
Merge pull request #140 from bdickason/patch-2

License no longer says Dictshield
fixed a bug HashType when converting a value; the fix just tests the value to ensure it is a hexadecimal string rather than converting the value to the a long integer.  Without this fix, the final assertion in test_md5_type in test_serialize.py fails
Found some tests that appear to ensure broken behavior.  Updated and code fixes are coming.
Found another test that appears to rely on broken behavior.
Updated tests to use explicitly mentioned roles and to fix type coercion bugs after serialization.
This commit represents a big changeset that consolidates the serialization on
top of `apply_shape`.

The concept of `apply_shape` is local to the `MultiType` classes.  I now feel
the name `MultiType` is confusing and I might change it to `CompoundType`, to
make the intent more obvious.  `apply_shape` is applied to compound types
because we can't be sure if the compound type has types or models in it. The
new recursion allows us to ask the compount types themselves to apply the
coercion functions.  Almost all of the redundant logic that used to exist in
the `filter_by_role` functions is now in just the main implementation of
`apply_shape`.

Almost all of the tests are passing with this commit, except for two tests for
flattening behavior.  I am working on those next but feel this thought is now
complete and worth committing.
Added the `print_none` keyword to `apply_shape`.  This completes the migration
towards a recursive structure for the main serialization functions.

Also with this commit, every test is passing.  Wahoo!
Merge branch 'fix_recursion'
Merging in latest changes from the community.

Merge branch 'master' of github.com:j2labs/schematics
v0.9
Fixing version string
Fixing travis link in docs