Agile Toolkit - 150 features
Agile Toolkit is a web framework and collection of web components aimed at giving developers a fully-functional Web User Interface. The web interface is built using a very smart Object-Oriented princeples, similar to those in Desktop Applications but heavily based on individual component templates and abstraction.
Agile Toolkit is completely designed for PHP5+. It does not have to maintain compatibility and therefore takes full advantage of Object Oriented features. Inheritance and overriding is actively in all classes including Models and Views.
CodeIgniter is based around singletons. Developer extract data from one one class to feed into another. In Agile Toolkit classes interract with eachother. Models also rely on DSQL class, which is similar to DB in CodeIgniter but maintains each query as a separate instance. This class is also used by Views, so you can easily change the query used by Lister without modifying or inheriting the class.
Agile Toolkit brings in the full stack of User Interface which is completely integrated with models and the rest of the framework. Both frameworks are quite good at being fast and flexible in terms of HOW you want to structure your application.
Models in Agile Toolkit are more powerful, store field meta-information and relationship information. Models can span across multiple SQL tables, contain sub-queries and conditions.
Validation is approached differently. Instead of defining rules, models now throw exceptions which User Interface intercepts and show to user through AJAX. Libraries in CI are similar to Controlers in Agile Toolkit. Helpers in CI are similar to Views in Agile Toolkit.
Agile Toolkit does not aim to re-implement features already provided in PHP, so it does not provide advanced session handling features like CI, Image, FTP or Language classes. Other feature are implemented differently. For example, encryption in CI provides API interface to developer. Encryption in Agile Toolkit binds into model and magically auto-encrypts it's fields.
Agile Toolkit allows existance of multiple APIs at the same time and does not use globals at all. Therefore features like Hooks differ slightly. Agile Toolkit has a distinctive Appliation object, while CI mostly relies on Front Controller
Agile Toolkit uses concept of Enhancement and Degradation. For example even though you can be using AJAX to load your application content it would stil work without AJAX (which is essential for search engines).
Initial loading time of Agile Time is much shorter, because it does not rely on server-side JS and does not attempt to pre-load all the components. It will load them on demand and would rely on the server-side to do most of the rendering and processing. For example, form-validation in Agile Toolkit is done server-side, but because they're submitted with AJAX, user is getting same visual feedback as with JS-side validation.
Agile Toolkit is tightly integrated with jQuery and jQuery UI. The general concept of coding is "add first, tweak after" instead of supplying arrays with lots of prepared data to constructor of element.
HTML code produced by Agile Toolkit is fully customizable. By default jQuery CSS framework is used along with 960gs, but that can be changed too.
Agile Toolkit does not attempt to follow and copy concepts from success of Ruby on Rails. The whole MVC concept is shifted and re-balanced to meet requirements of User Interface.
If you have been using code-generator to update 3-5 files at a time, in Agile Toolkit you work from one place. This place is a 'Page' and as you add views on your pages, you decide which models to bind them with. So by looking at a single page, you can see what's happening instead of having models, routes, views, controllers, helpers and stores just for a singe CRUD page. Of course you can define custom views, controllers but you will find that generic ones are actually quite handy.
Symfony, especially it's 2nd version takes many of the advantages from PHP5.3. Agile Toolkit takes some of the features such as exceptions, inheritance but leaves out features such as interfaces, closures and namespaces.
Basic components such as CRUD while both present in frameworks are implemented differently. Agile Toolkit does not generate any code but you can extend the crud class. Use of templates and meta-data in models helps manipulate CRUD in the way you want. Form implementation is more lightweight in Agile Toolkit and it trades all the layouting features for a simple "use your own tempalte" along with 6 built-in CSS-based form layouts.
Separation of object initialization and rendering allows lots post-initialization tweaking. You can now squeeze some content into other object output even if it wasn't initially intended by the author.
Agile Toolkit is not introducing extra complexity. It provides abstraction only when there are benefits form that. Many things in Agile Toolkit are not abstracter. For example model validation is done in the old-fashioned way - with "if" and "throw". On pages we still use GET arguments and work with them directly.
When it comes to templates, the template engine in Agile Toolkit is very simple. It only has concept of regions and tags. It's very similar to PHP native templates, except that you can get regions from them. PHP code decides what to do with the tempalte.
On other hand, Agile Toolkit makes it awesomly easy for a PHP developers to make Rich, Stylish and well organised application with PHP code alone.
Models in Agile Toolkit use get()/set() to access properties unlike defining them as native PHP properties. Oh and templates use get() and set(). And many other things can use get() and set(), which is an universal concept.
Agile Toolkit gives you a choice of APIs. API controlls which parts of the toolkit will be loaded. You can make your own API class and decide what you want in there keeping everything very lightweight and speedy.
Setter and getter functions are not very common in Agile Toolkit. Often things are accessed directly to reduce amount of code and keep things simple. For example you can get name of any object from $object->name. Technically you can change the name at your own risk. Agile Toolkit will not protect the property and expose it only through method for performance reasons.
Many methods and functions will assume that the arguments are handed in properly reducing overheads. Few risky places, however, do perform a validation to avoid common mistakes. Finally, there is a freedom in the way how resources are loaded, you can place them in different folders of your choice, as long as you instruct loader about search locations. You can even place all the objects into a single index.php file and your application would work anyway.
There are no hard dependencies, objects are loaded when needed. No direct includes. You can, however, search for "-<add" and it will become very clear, what your objects are using and when.
Finally, Agile Toolkit attempts to keep features of each class to a minimum. Most of the views, controllers are implemented in a 20-50 lines of code. All of the framework is written by a same author instead of highly de-coupled framework with many different coding styles and overlap of features. Agile Toolkit makes it easier to "add" features but not tries to implement all of them.
Agile Toolkit packs a 3 major features but also has a huge amount of minor features.
- Small footprint but huge gain
- Zero configuration and no code generation
- Lets you focus on "what", not "how"
- Encouraging good quality code available for free or fairly priced
Query Building - DSQL
- Extremely easy to learn and use
- Object-oriented query model. Multiple queries are not conflicting
- Querying multiple tables through joins
- Vendor-independent database feature use
- Argument quoting and escaping
- Support for advanced expressions
- Parametrical queries through PDO
- Sub-query support (with parametric variables)
- Automated caching of prepared statements
- Multiple database connections
- Native integration with Views, Models, and the rest of Agile Toolkit
- Extremely lightweight
- Debugging support
- Extend to build your own queries using templates
- Easy to learn and use
- Uses native PHP code to define
- Follows your business entities and can divert from your database schema
- Supports joined tables with different types of relation
- Foreign key support and subqueries
- Extensive support for calculated columns
- Model inheritance for more secure data model
- Conditions on physical, related and calculated fields
- Dynamic field types, flags and properties
- Add additional conditions, joins, fields for existing model on the fly
- Active record implementation, load, change and save data back
- Hooks and methods for controlling actions before or after operations (behaviours)
- One class per model. No XML/YAML or any extra files
- Define actual fields to be used and their order when using with Views
- Extract dynamic query from model for multi-record SQL operations
- Support for "master" fields, which much be conditioned and defaulted to certain value
- Support for system fields, which will not appear on views. Read-only fields.
- Model-level validation.
- Related model traversing. Automatically pre-loads data.
- Default field values
- Captions for fields. Automatically produce caption from field name if undefined
- Extend to add your own properties to fields
- Model controllers can add behaviour, fields (timestamps, audit, soft delete)
- Separate table audit / logging
- Determining and updating only fields which value was changed
- Use conditions in complex calculated sub-query fields as defined in their respective model
- Load active record data by id or other field
- Customize display name by supplying your own SQL
- Controllers have different responsiblities in Agile Toolkit
- Front-controller is implemented as Page object
- Libraries are Application-Controllers. They extend how application behaves
- Helpers in other frameworks may be either Controller or View for better structure
- Apply one or several controllers on a single object.
- Model controllers adds behvaiour, conditions, fields or encryption to models
- Controllers are transparent. Strong encryption controller is attached to model where fields continue to work ir a regular way
- Register system-wide fall-back functions.
- Inject methods into objects.
- Advanced object-level "hook" system
- Views produce HTML markup, such as button, form, image or icon
- One view can recursively consist of other views
- All views rely on a simple-for-designers-to-understand HTML templates
- Template engine contain no business logic, only define regions
- When adding view to another, position it anywhere in owner's template
- Views generate and insert unique-name for each object
- Function js() allows to bind view with jQuery chains through behaviours
- Reload view through AJAX painlessly
- Regardless of complexity, multiple views will not conflict on same page
- AJAX request can render selective view
- Views are rendered after everything is initialized. Hence you can delete views after they are added.
- Because Views are classes, they can inherit each-other
- Agile Toolkit comes with many built-in views
- CRUD is implemented as view, hence you can have multiple CRUD controls on the page
- You can use views for layouting or tabs.
- View can have default template, but you can specify a different template when adding
- You can convert view into HTML by echoing it, but never do it. Render will echo everything for you
- Output is echo'ed only once, after render, so the page will not be displayed partially
- You can re-arrange objects in a view after they are added through controller
- Grid based on pure HTML with support for Paginator, Sorting, Totals and inline editing
- Multiple API classes are available. Select the most appropriate for your web app
- Support for lightweight config file (php syntax)
- Full-featured implementation of exception handling
- Application is derived from View, hence it has a global template (shared.html)
- Through controllers, add more SEO capabilities to your web application
- Transparent localization support. Develop your app, then localize
- Upgrade full Agile Toolkit codebase or addons without loosing your customization
- Inject your own classes (Form, Grid) to be used everywhere
- Create multiple applicaiton instances
- Support for skins allowing to white-label software
- PathFinder helps locate files in multiple locations based on file type
- Certain template tags are universally changed to set proper page-links or location to HTML assets
- Add authentication controller to restrict access on white or black-list basis.
- Authentication can use default login form or your own
- Multiple encryptions for authentication - md5, sha1, sha256 and your own
- Presence of Sticky GET arguments
- Page-based routing. Can be extended through .htaccess into Ruby-style. Use any extension in URL
- Support for mod_rewrite.
- Apps can be deployed in webroot or subdirectory
- Support for sub-pages and page hierarchies.
- Inherit one page from another
- Backwards-compatibility controller
- Database migration scripts (alter table)
- Development and Production mode
- File pushing. Place file with the same name in local directory to override file from Agile Toolkit
- Compatible with your PaaS PHP Platform
- CRUD View — bind with your model to create, browse, edit or delete model entities
- Filestore — powerful models for storing meta information about uploaded files. Multi-volume support
- Image — extends File implementation of Filestore but adds ability for automatic cropping and thumbnails
- Strong Encryption — use OpenSSL for one-way encryption of model fields
- Payments / Paypal — implement support for charing visitors through PayPal
- Payments / Realex — credit card processing through Realex Payments
- Credit Card model — instantly create your payment form
- CampaignMonitor — taps into SOAP interface of CampaignMonitor
- OAuth — integrates with 3rd party authentication, Linkedin, Twitter, Google
- FormAndSave — simple addon adding MVC form with database saving on submit
- Any view in the system can have jQuery chain attached through behaviour, such as "click"
- Behaviour on one object can trigger chain on another object
- One behaviour can trigger multiple chains.
- You can use your own events and trigger them manually.
- Redefine selector or use "this", "document" or "window".
- Submitting form executes jQuery chain also.
- Enclose chain into function.
jQuery UI extension
- Avoid multiple requests when user clicks AJAX button inpatiently
- Handle slow page loading to display global spinner
- Ability to handle session expiration in AJAX requests
- jQuery UI widget for form. Adds AJAX submit and nice error display
- jQuery UI widget for grid. Add field reloading, pagination
- jQuery UI widget for expander. Expands table and loads page inside
- Plugin for "atk4_loader". Improves for content loading and reloading
- Extensible univ.js chain allowing to add more custom JS methods accessible from PHP
- Support for dynamic loading and JS dependencies.
- Load AJAX page along with 3rd party jQuery plugins and widgets
- Growl-style JS success notification
- Native support of jQuery UI dialogs
- Widget for menu and link AJAX-ification
- Support for datepicker
User Interface and design
Agile Toolkit comes with awesome and flexible design (skin). It will let you develop without worrying about the look of your application. If you have designer in your team, he can produce a new and unique skin.
- Typography and CSS reset included, so that you don't need to worry
- GS-10 is used by default, but different Grid Systems can be used
- Six CSS classes for building form layouts. Since column, multi-column forms
- Support for hybrid form layouts. If everything fails, use custom form layout
- Based on jQuery UI CSS framework. Use themeroller for new theme
- 128 extra icons included in addition to ones provided with jQuery UI
- Support for fixed width and full-screen layout
- Comes with two CSS skis: "default" and "elephant". Switch in index.php file
- Views for error, info and warning boxes
- Form hints
- Menu template
- Grid template