The list of features is constantly growing as the XAO library assimilates patterns and exposes them in an easy to use API. Below is a list of already existing features. Keep watching this page to see new ones as they come out. Don't forget, it's easy to cherry pick just the features that you want in your application so that you don't have to expose yourself to too much complexity (for learning and/or for maintaining).
core features Edit
- Easy to learn, yet capable of complex feature sets. YOU DO NOT NEED TO LEARN ALL THE FEATURES in order to take advantage of the XAO library. You can start building apps right away with the bare minimum of XAO (see tutorials) and then learn the other features you want as you go.
- Easy to debug your XML and XSLT. Detailed error reports accompanied by error line highlighting can really speed up the debug process. XAO has taken out a huge amount of the tedium associated with tracking down problems.
- Implement XSLT templating in a trivially easy way. You can spend more time learning how to write XSLT and less time learning how to manage it's integration with PHP.
- Comprehensive API documentation. As new functionality is released into the library, it is always accompanied by API documentation that's built right into the source code. It's then easy to automatically generate HTML documentation from this to provide the developer with a complete reference to the library.
- Unit tests for quality control. XAO is destributed with a test harness which can be used to run the built-in unit tests. The unit testing system was custom built for XAO to simplify the integration of unit testing into the application development process.
- Unified Exception handling framework for comprehensive messaging and error logging.
Architectural enhancements for complex apps Edit
- Event handler framework for HTTP requests. An XML file is used to map HTTP requests to user-defined handler functions. This reduces the development process to creating HTML forms and then writing handler functions. You can then stop worrying about the plumbing - which is great when your app starts balooning in size.
- XML Configuration file parsing. Application variables can be kept in highly structured parameter sets and not in the application's code base. Your application parameters can then be read from your XML config files and exposed to your code as multi-dimensional arrays. The whole process is cached and your XML config file is only re-read and parsed when it's modification date is newer than the cache file date. Storing config in XML format opens them up to the posibility of easily building an admin front end to update the file. With XAO's extensive XML support, it should be very easy. It's easy to keep your config files OUTSIDE the web root, thereby keeping your data secure. I'm thinking of shipping XAO with a configurator app written in XUL (like the test harness) which will allow you to read/modify your config file with a nice GUI. At the very least, I will probably develop an XSLT file to make it look pretty as a HTML report.
- XMLDB apbstraction layer for Tamino, eXist, Xindice to be developed.
- Server-Side HTTP input validation framework. Makes adding validation to HTML forms a cynch. You can then declare validation parameters using hidden form elements in your HTML forms to automatically invoke the server-side validation. Extend the basic set of input parser methods with your own validation handler methods. Integrate the validatior object with the request map.
- Clever caching framework where user specifies criteria for fresh dynamic generated output. The usefulness of this is limited to complex scripts which take a long time to generate content.
- Easy SOAP/XMP-RPC API to be developed.
SQL database features Edit
- RDBMS abstraction layers. Currently PostgreSQL, Oracle, Acccess, MySQL(to do), MSSQL(to do) are supported. It's easy to write your own driver file to provide access to a new RDBMS technology. I'll probably get around to writing a MySQL driver at some stage. Remember, features like this are OPTIONAL, if you don't like our built-in abstraction layer, you can use one you like or even just the native PHP functions.
- Database Entity Objects. Almost always, the business logic of your application will regard some of your database tables as logical business entities. Creating entity classes which can work easily with underlying an table or view is now easy. ie. $MyEntity->Insert(array('id'=>123,'name'=>'foo test')); The underlying entity class may also be a good place for me to add in SQL injection protection at some stage. It will most likely be in the form of variable/data binding where PHP's RDBMS API supports it for the given RDBMS. Since these database entity objects accept a driver object in their constructor, it is easy to have the same entity support different types of database servers (simply by changing the driver object you pass to it).
- Built-in converters for SQL query results-to-XML processing. Part of the core functionality is to build XML documents from database content. The support to do this is nothing short of comprehensive. It includes column-based event handlers, splicing XML element sub-trees, element/attribute transformation (if your schema/vocabulary requires it). Yet all the fancy stuff can be by-passed to build XML result sets in 3 lines of code.
- Built-in function to create heirachical XML for SQL result sets with a "parent ID column". Use a view if parent/child fields are in a separate table to facilitate many-to-many.
- There is a big array of convenience methods for dealing with XML content once it has reached a XAO XML document object (on it's way to being output as an XML page or an XSLT transformation). They can be searched by tag name or by using XPath queries very easily.
- Any XAO XML document or sub-document object can have handler methods added to them (via inheritance) which will process the results of XPath queries or tag name queries. Queries can be stacked for one-time execution. This is great for data manipulations, structural transformations (pre-XSLT) such as filtering, even data driven side-efects (ie, interpreting XML based scripts or messages), or high-level business logic parsing.
- easily manifest PHP associative arrays as an XML subtree.