=================
Release highlights
------------------
* A new, cleaner and faster implementation of Reg underlies this
version of Morepath. It turns generic functions into methods on the
``App`` class, and removes implicit behavior entirely.
This has some impact if you used the low-level ``function``
directive or if you defined your own predicates with the
``predicate`` and ``predicate_fallback`` directives, see details
below.
* A new build environment based around virtualenv and pip. We've
removed the old buildout-based build environment. ``doc/developing.rst``
has much more.
* Performance work boosts performance of Morepath significantly.
Removals & Deprecations
-----------------------
- **Removed**: ``morepath.remember_identity`` is removed from the
Morepath API.
Use ::
request.app.remember_identity(response, request, identity)
Instead of ::
remember_identity(response, request, identity, lookup=request.lookup)
- **Removed**: ``morepath.forget_identity`` is removed from the
Morepath API.
Use ::
request.app.forget_identity(response, request)
Instead of ::
morepath.forget_identity(response, request, lookup=request.lookup)
- **Removed** ``morepath.settings`` is removed from the Morepath API.
Use the ``morepath.App.settings`` property instead. You can access
this through ``app.settings``. You can access this through
``request.app.settings`` if you have the request. The following
directives now get an additional optional first argument called
``app``: ``permission_rule``, ``verify_identity``, ``dump_json``,
``load_json``, ``link_prefix`` and the ``variables`` function passed
to the path directive.
- **Removed** ``morepath.enable_implicit`` and
``morepath.disable_implicit`` are both removed from the Morepath API.
Morepath now uses generic *methods* on the application class. The
application class determines the context used.
- **Removed** We previously used buildout to install a development
environment for Morepath. We now use pip. See ``doc/developing.rst``
for details, and also below.
Features
--------
- **Breaking change** Dectate used to support the ``directive``
pseudo-directive to let you define directives. But this could lead
to import problems if you forgot to import the module where the
pseudo-directives are defined before using them. In this release we
define the directives directly on the ``App`` class using the new
``dectate.directive`` mechanism, avoiding this problem.
If you have code that defines new directives, you have to adjust
your code accordingly; see the `Dectate changelog`_ for more
details.
.. _`Dectate changelog`: http://dectate.readthedocs.io/en/latest/changes.html
- **Breaking change** Previously Morepath used Reg's dispatch
functions directly, with a mechanism to pass in a ``lookup``
argument to a dispatch function to control the application
context. The lookup was maintained on ``App.lookup``. Tests were to
pass the lookup explicitly. Reg also maintained this lookup in a
thread-local variable, and any dispatch call that did not have a
explicit lookup argument passed in used this implicit lookup
directly.
Reg has undergone a major refactoring which affects Morepath. As a
result, Morepath is faster and dispatch code becomes more
Pythonic. The concept of lookup is gone: no more lookup argument,
``app.lookup`` or implicit lookup. Instead, Morepath now makes use
of dispatch *methods* on the application. The application itself
provides the explicit dispatch context. See `448`_ for the
discussion leading up to this change.
.. _`448`: https://github.com/morepath/morepath/issues/448
Most Morepath application and library projects should continue to
work unchanged, but some changes are necessary if you used
some advanced features:
* If in your code you call a generic function from
``morepath.generic`` directly it won't work anymore. Call the
equivalent method on the app instance instead.
* If you pass through the ``lookup`` argument explicitly, remove
this. Calling the dispatch method on the app instance is enough to
indicate context.
* If you defined a generic function in your code, you should move it
to a ``morepath.App`` subclass instead and use
``morepath.dispatch_method`` instead of ``reg.dispatch``. Using
``reg.dispatch_method`` directly is possible but not recommended:
``morepath.dispatch_method`` includes caching behavior that speeds
up applications. For example::
class MyApp(morepath.App):
morepath.dispatch_method('obj')
def my_dispatch(self, obj):
pass
* The ``function`` directive has been replaced by the ``method`` directive,
where you indicate the dispatch method on the first argument. For
example::
App.method(MyApp.my_dispatch, obj=Foo)
def my_dispatch_impl(app, obj):
return "Implementation for Foo"
* The ``predicate`` directive can be used to install new predicates for
dispatch methods. The first argument should be a reference to the
dispatch method, for instance::
App.predicate(App.get_view, name='model', default=None,
index=ClassIndex)
def model_predicate(obj):
return obj.__class__
There is a new public method called ``App.get_view`` that you can
install view predicates on.
* The ``predicate_fallback`` directive gets a reference to the
method too. The decorated function needs to take the same
arguments as the dispatch method; previously it could be a subset.
So for example::
App.predicate_fallback(App.get_view, model_predicate)
def model_not_found(self, obj, request):
raise HTTPNotFound()
Where ``self`` refers to the app instance.
Bug fixes
---------
- Fix code_examples path for doctests with tox.
Build environment
-----------------
- We now use virtualenv and pip instead of buildout to set up the
development environment. The development documentation has been
updated accordingly. Also see issues `473`_ and `484`_.
- Have the manifest file for source distribution include all files
under VCS.
- As we reached 100% code coverage for pytest, coveralls integration
was replaced by the ``--fail-under=100`` argument of ``coverage
report`` in the tox coverage test.
.. _473: https://github.com/morepath/morepath/issues/473
.. _484: https://github.com/morepath/morepath/pull/484
Other
-----
- Refactored traject routing code with an eye on performance.
- Use abstract base classes from the standard library for
``morepath.IdentityPolicy``.
- Reorganize the table of contents of the documentation into a
hierarchy (`468`_).
- Expand the test suite to cover ``morepath.Request.reset``, loop
detection for deferred class links, dispatching of
``App.verify_identity``-decorated functions on the ``identity``
argument (`464`_). Coverage ratio is now 100%.
.. _464: https://github.com/morepath/morepath/issues/464
.. _468: https://github.com/morepath/morepath/pull/468