What's New!
Overview of notable features and major changes in the latest release.
A lot of time and effort has gone into revamping the developer documentation, which includes:
The naming conventions and library paths in Cement 2 were laborious to type and remember. Now all modules/methods/etc are importable from
cement namespace directly, and the naming is simplified (ex: CementApp is now App, CementHandler is now Handler, etc).from cement import App, Controller, ex
class Base(Controller):
class Meta:
label = 'base'
@ex(help='this is a command')
def cmd1(self):
print('Inside Base.cmd1()')
class MyApp(App):
class Meta:
label = 'myapp'
handlers = [Base]
The Cement Developer Tools allow developers to quickly generate projects, plugins, extensions, and scripts:
$ cement generate project ./myapp
INFO: Generating cement project in ./myapp/
$ cement generate plugin ./myapp/plugins/
INFO: Generating cement plugin in ./myapp/plugins/
$ cement generate extension ./myapp/ext/
INFO: Generating cement extension in ./myapp/ext/
$ cement generate script .
INFO: Generating cement script in .
In Cement 2, the design of the interface and handler system was not easy to follow for new developers to the framework. It was also loosely modeled after ZopeInterface, and that may have lead to some odd naming conventions (IMeta, IMyInterface, etc), and an implementation that just felt weird.
Interfaces are now defined using the standard library's Abstract Base Class module per the request of the community, moving the framework away from oddities and more toward common Python standards.
Cement now includes a fully functioning docker setup out-of-the-box for local development of the framework that includes all dependencies, and dependency services like Redis, Memcached, etc.
Getting up and running is as simple as running the following:
$ make dev
|> cement <| src #
This drops you into a shell within a docker container, and environment so that everything required to dev, and test is ready to roll:
|> cement <| src # make test
|> cement <| src # make docs
See the
Makefile for more common development tasks (for framework development).Cement now supports the ability to override all config object settings via their associated environment variables. For example:
myapp.py
cli
from cement import App, init_defaults
CONFIG = init_defaults('myapp')
CONFIG['myapp']['foo'] = 'bar'
class MyApp(App):
class Meta:
label = 'myapp'
config_defaults = CONFIG
with MyApp() as app:
app.run()
foo = app.config.get('myapp', 'foo')
print('Foo => %s' % foo)
$ python myapp.py
Foo => bar
$ export MYAPP_FOO='not-bar'
$ python myapp.py
Foo => not-bar
Environment variables are logically mapped to configuration settings based on their config keys and are prefixed with
MYAPP_ (based on the label of the app). So:config['myapp']['foo']=>$MYAPP_FOOconfig['some_section']['foo']=>$MYAPP_SOME_SECTION_FOO
Interface | Description |
Rendering of template data (content, files, etc). Existing output handler extensions were also updated to include an associated template handler ( MustacheTemplateHandler, Jinja2TemplateHandler, etc). |
Extension | Description |
Used primarily in development as a replacement for standard print(), allowing the developer to honor framework features like pre_render and post_render hooks. | |
Adds the ability to easily obfuscate sensitive data from rendered output (think IP addresses, credit card numbers, etc) | |
Adds the ability for application developers to add a generate controller to their application, and include any number of source templates to generate from. Think myapp generate plugin for third party developers to create plugins for your application from a fully-functional working template. |
Last modified 5yr ago