I finally got around and fixed the last corners here and there.
If you wonder what Diamond is, then it's a library for developing
full-stack MVC web-applications based on vibe.d.
It contains a lot of features (Which you can see in the READ ME)
To name a few of the key features:
* Full control over requests / responses when wanted.
* "Websettings" file that lets you control requests / responses
for:
* Before a request is handled.
* After a request has been handled.
* When an error occurres.
* When a page or controller action wasn't found.
* When a static file has been requested.
* Multiple static file paths
* Let's you bind to multiple ip addresses and ports.
* Let's you control default headers for each type of request
(default, static files, errors, not found etc.)
* Uses vibe.d for backend, so it's very powerful and all vibe.d
features can be used with Diamond
* Easy control over the application's type using *static if*
constructs.
* isWeb (true for both web-servers and web-apis.)
* isWebServer (true for web-servers)
* isWebApi (true for web-apis)
* isWeb, isWebServer and isWebApi will be false for standalone.
* ACL & Authentication tied to it
* Separate authentication that can be used either with or without
the ACL
* CSRF Protection
* Easy integrated cookie/session API.
* The network can be restricted to specific ips.
* Transactions
* Unittesting
* Logging
* i18n
* Version-control
* Route rewriting
* Database Integration & Object Relational Mapping
* Websockets
* Specialized Routes (Can fetch resources external internal or
local)
* Views are parsed at compile-time, thus rendering of views are
super fast
* Views can have layout views
* Views have a metadata section that lets you change view
configurations such as its controller, model, layout, route and
placeholders.
* Views have placeholders and layout view's can access the render
view's placeholders.
* Views can encode their data
* Has a rich syntax that allows for complex and innovative
rendering.
* Easy access to the current request / response using the
properties: *httpRequest* and *httpResponse*
* Can render other views within itself
* Any type of D code can be written within views.
* Allows for sections, which is useful to only render a part of
the view. (Very useful for responsive designs)
* Can be passed to controllers by their base view
* Layout views can be changed dynamically
* Expensive views can be cached.
* Flash-messages
* Controller actions are mapped through attributes. (By default
the route name will be the name of the function.)
* If wanted actions can be mapped manually, but that's a legacy
feature.
* Controller actions can easily control how the response is
handled, as they require a status returned
* Status.success (Will continue to handle the request.)
* Status.end (Will end the request; useful for json responses
etc. *Note: using the json() function already does it for you.)*
* Status.notFound (Will issue a 404 status for the response.)
* Can map mandatory actions that are executed on every requests.
(Useful for authentication etc.)
* Easy integrated authentication (Can be combined with ACL)
* RESTful
* Specific actions can be restricted to specific ips.
After 2.7.0 I have decided to drop backward compatibility as
2.7.0 barely introduces any major breaking changes, but it fixes
a lot of issues and now works with vibe.d 0.8.2 and mysql-native
2.1.0!!
Since last announced update the following has been added:
* i18n messages can now be added dynamically.
* Support for mysql-native 2.1.0
* Support for vibe.d 0.8.2
* Removed backward compatibility with older vibe.d versions
* Slowly moving away from shared static constructors. (Currently
Diamond implements a main function for a start.)
* Better internal usage of placeholders (They now append to the
view's content, instead of using std.array.replace.)
* Removed the rootPath property from the View class, because it
was expensive and kind of useless.
* You can now retrieve placeholder values from views
* Route creation was made public
* Added new view functionality such as the ability to delay view
render for layouts etc.
* Added the ability to use a single view for routing
* Added a view constructor extension type
Other than that minor optimizations and bug fixes has also taken
place.
Github: https://github.com/DiamondMVC/Diamond
Dub: https://code.dlang.org/packages/diamond (Currently waiting
for dub to update the package!)
In the last announcement for Diamond I said I'd implement a SEO
API and SOAP support and it's still planned, but it wasn't
prioritized like updating to vibe.d 0.8.2 and mysql-native 2.1.0
I still plan to implement it within the near future!
I think Diamond has reached a stable phase, which means I can
focus on adding tutorials, examples etc.
I also need to pick up working on the official Diamond website,
but I have a lot of actual paid work that I can't just put away
at the moment, so my time working on actual Diamond is limited
right now.
I'd like to give a special thanks to everyone who contributes to
D, vibe.d and mysql-native, because without them Diamond wouldn't
be where it's at!
Anyway,
Thank you for your time!
