This Week in Wonder

Ajax
The AjaxExample2 app has been committed to Wonder. This is the application that was shown during the Ajax session at WOWODC 2008. Whereas AjaxExample shows off many features of the framework but not with real-world examples, AjaxExample2 takes the approach of trying to show the framework off in the context of solving real interface problems.

ibox.js in AjaxModalContainer was updated to 2.17b

You no longer have to iBox.init() at the end of your AjaxUpdateContainers when you generate new AjaxModalContainers in ajax responses. This all "just works" now.

AjaxModalContainer has a new locked flag that disallows closing and an open flag that forces it open (rather than waiting for a click).

AjaxModalContainer works with HTTPS URLs now.

New AjaxUtils.arrayValueForBinding utility method, which supports loading array bindings that are defined as references to NSArray as well as inline JSON-syntax Strings.

Migrations
ERXMigrationTable provides a newLargeStringColumn method that corresponds roughly to the varcharLarge prototype in Wonder. This helps to abstract out the weird big column width you'd previously have to define in your migrations for those columns and hopefully makes this more database independent.

EOF
ERXModelGroup checks for a subtle problem that is probably more common than people might think where your connection dictionaries across multiple models aren't EXACTLY the same, which results in EOF treating them like different databases. Now this will generate an exception at startup.

ERXJDBCConnectionBroker has a new fix for a resource contention problem with leaving connections in an incorrect state.

FrontbasePlugIn
You can now set com.frontbase.unique.[ModelName].[EntityName]=xxx, com.frontbase.unique.[ModelName]=xxx, or com.frontbase.unique=xxx to specify the initial unique value that is used by the FrontBasePlugIn when it generates sequences. I don't think EntityModeler will pick this up, but if you're using migrations, you'll get it.

Components
Ravi Mendis has committed fixes for XHTML compliance in several components.

Misc
ERXResponse supports pushing and popping response content on a stack. This is interesting if you want to post process the output of a single component in isolation from the rest of the response (but you want to maintain all the other state of the response).

ERXExtensions.initApp and ERXExtensions.initEOF should be a little easier to use now. In your JUnit TestSuites, you can just add a static method:


static {
ERXExtensions.initApp(Application.class, new String[0]);
}


and you will be running your test case in a full Wonder-ful Application environment.

ERIUI
If you've ever tried out the iui css + js for making iPhone apps, you may have noticed that it is a complete disaster for connecting to component-action-based WO apps. The Javascript presumes stateless URLs and eventually will explode. ERIUI takes the base CSS work from iui but with a completely rewritten Javascript layer that provides much richer stateful component-based interactions with your app. The docs are severely lacking on this one at the moment (this was just a hobby framework for me). To get good performance on the phone, the framework uses WebKit CSS animations (which currently only works in the WebKit nightlies, not in Safari 3.x), though it "gracefully" degrades (to no animation) on the desktop. Checkout ERIUIExample to see it in action ... This should be considered "preview" quality for now.

Google Chart
There's a new GoogleChart framework for generating charts via the Google Chart API. This is inspired (quite a bit) by the Ruby googlecharts framework. There's more info here.

These 9 Weeks in Wonder

 Yeah, I know, long time no write ... Occasionally Real Work (TM) gets in the way.

Migrations
newLocalizedStringColumn supports creating string columns that work with Wonder's localized attributes ("name_en," "name_de," etc).

Migration support for dropping composite pks (though the FrontBase plugin doesn't actually support this :( ).

BigInteger column support.

newFlagBooleanColumn which generates a Types.BOOLEAN column instead of a varchar(5) or int boolean column.

ERIndexing
Updated to Lucene 2.3.2.

ERIndexingExample is a new example app that shows how to use ERIndexing.

ERCaching
More work on memcached integration, though I think (correct me if I'm wrong, Anjo?) it's not quite ready for primetime yet.

ERSelenium
StandaloneRunner supports running Selenium tests from the commandline.

SproutCore
Initial work on supporting the development of SproutCore applications with WO. Currently the work on SproutCore has been replacing the rails-based templating system with a WO-based templating system. While not necessarily required for developing SC apps, it provides nicer integration with existing tools. Currently you can run the WO-equivalent of several of the SC example apps in live mode ..... mostly :) This is to be considered very experimental right now.

Check out the SproutCoreExample app to see it in action.

Wonder 2.0
We're on Wonder 5.0, but iTunes has lots of miscellaneous enhancements to their Wonder 2.0 fork. Thanks to the iTunes folks, all the enhancements that live in 2.0 are now moving up to the trunk.

JSON
Lots of work on JSON support in Ajax framework.

You can now optionally include attributes and relationships in your JSON results via the client class property setting in your model.

You can specify writable vs read-only attributes.

Marshalling/unmarshalling of EOTemporaryGlobalIDs is supported, so you can pass around uncommitted EO's to/from the server.

There is now support in the client API's for converting full EO's to EO stubs as a performance enhancement when passing to API's that only require an EO's id (the server side faults it back in for you).

Support for custom EO serializers. For instance, you can add the custom serializer for ERAttachments by calling JSONRPCBridge.getSerializer().registerSerializer(new ERAttachmentObjectSerializer()), which will inject the attachmentUrl into the JSON object during serialization so your client can simply refer to the attachment without doing another round-trip.

JSONComponents are an experiment in trying to rethink web services in the language of WOComponents. JSON service endpoints can now return JSONComponents, which are stateful service endpoints. This allows for cleaner encapsulation of your services while also allowing the server to make decisions on the routing path through your service as well as the services themselves being stateful. For instance, clients can call the login method of the authentication service, which can return back the next service to talk to, and just like WOComponents, repeated calls to the component return to the correct state on the server. The end result is actually a bit like PDO ... JSONComponent are to Component Actions as traditional WOWebServices are to DirectActions.

ERAttachment
ERAttachment URLs are now a little smarter and more optimized in that the URL can now include the PK of the attachment being requested. It still verifies the provided webpath for security, but the server can almost always avoid an extra fetch by attempting to fault the PK rather than fetch by webpath.

ERExtensions
ERXRemoteNotificationCenter provides support for posting arbitrary notifications across multiple servers. Provides a simple implementation as well as a JGroups implementation.

ERXIFrame can act as a component for simply creating an iframe to a URL, or more interestingly can render its component content as the iframe contents, which is really handy.

ERXPartialMarker/ERXPartialWrapper is crazy, but if I understand it properly, it provides support for rendering one section of your page that will appear in another section of your page. It's currently used by the SproutCore framework.

ERXFlashMovie is just a handy wrapper around embedding an SWF in a page.

ERXEOGlobalIDUtilities does a lot more work to make sure that it doesn't refetch objects that were already faulted.

ERXQ.containsObject. If you're a fan of the "contains" qualifier selector, you'll be a fan of this method.

ERXRecursiveBatchFetching is a terrible name. It's now named ERXBatchFetchUtilities. The old class extends the new class and is marked @deprecated. ERXBatchFetchUtilities also now provides several batch fetching variants based on ERXKey.

ERXDatabaseContextMulticastingDelegate now supports both 5.3 and 5.4.

ERXTemporaryGlobalID provides many of the benefits of 24-byte GUID PKs without the annoyance of byte[] PKs in your database by "fitting" a GUID into a long-sized value.

ERXEOControlUtilities.convertEOtoGID and convertGIDtoEO now support non-EO objects that contain EOs (for instance, a pojo proxy object that wraps an EO) via the IERXEOContainer and IERXGIDContainer interfaces.

ERXMutableURL is a little smarter about not generating :80's for http and :443's for https.

ERXEOAccessUtilities.createRelationship and createFlattenedRelationship provide easier methods for programatically mucking with your EOModels

ERXEOControlUtilities.distinctValuesForKeyPath will give you an array of the distinct values of a particular keypath on an entity.

ERXModernNavigationMenu/Item provides an upgraded replacement of ERXNavigationMenu/item that are CSS and semantic markup instead of the older table-based layout.

ERXArrayChooser now supports arbitrary qualifiers and fetching of shared objects.

ERXModuloQualifier can generate SQL queries that use the "mod" keyword.

ERXFetchSpecificationBatchIterator now supports prefetching and raw rows.

ERXGenericRecord will now cache its primary key rather than constantly regenerate.

ERXJobLoadBalancer "solves the following problem: we have a set of jobs (identified by an Id) waiting to be processed. Several worker processes are competing for jobs and we need to way to efficiently parcel out those jobs out. We want to avoid as much as possible several workers attempting to grab the same jobs and locking it." This works across instances, by the way. It's works sort of like Xgrid. The new version of ERMailer coming from Wonder 2.0 will use this class to load balance sending email across multiple instances/apps.

Ajax
AjaxObserveField has a new onCreate option that is called after form serialization, but prior to form submission, which allows you to do things like disabling the form while it's sending in the background.

Better compatibility with FireFox 3's more aggressive caching of Ajax requests.

AjaxModalContainer supports binding "action" even when ajax=true, so you can perform a component action prior to rendering the component content of your container.

BugTracker
BugTracker now include support for the audit trails.

Maven
Lots of work on the maven build files for Wonder. As I understand it, which I don't :), Wonder Maven builds "just work".

WO Adaptors
Q updated all the WO adaptors in Wonder. The 5.4 enhancements are merged with the Wonder enhancements. The build files have all been cleaned up, FreeBSD support was added, and several fixes went into the FastCGI adaptor.

ERRest
ERXUnsafeRestEntityDelegate can now be optionally enabled in production. This is handy if your restful service is behind authentication and only used for administrative services where ACLs are not an issue.

ERXAbstractRestEntityDelegate subclasses can more easily provide support for custom "primary keys" to be generated and resolved by overriding _isEOID, _objectWithKey, and idForEO methods.