| |
 | Posted by bauss |  Permalink Reply |
|
bauss 
| 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!
|
